OLD | NEW |
1 // Copyright 2008 the V8 project authors. All rights reserved. | 1 // Copyright 2008 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 470 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
481 TestCharacterClassEscapes('D', NotDigit); | 481 TestCharacterClassEscapes('D', NotDigit); |
482 TestCharacterClassEscapes('s', IsWhiteSpace); | 482 TestCharacterClassEscapes('s', IsWhiteSpace); |
483 TestCharacterClassEscapes('S', NotWhiteSpace); | 483 TestCharacterClassEscapes('S', NotWhiteSpace); |
484 TestCharacterClassEscapes('w', IsRegExpWord); | 484 TestCharacterClassEscapes('w', IsRegExpWord); |
485 TestCharacterClassEscapes('W', NotWord); | 485 TestCharacterClassEscapes('W', NotWord); |
486 } | 486 } |
487 | 487 |
488 | 488 |
489 static RegExpNode* Compile(const char* input, bool multiline, bool is_ascii) { | 489 static RegExpNode* Compile(const char* input, bool multiline, bool is_ascii) { |
490 V8::Initialize(NULL); | 490 V8::Initialize(NULL); |
491 FlatStringReader reader(Isolate::Current(), CStrVector(input)); | 491 Isolate* isolate = Isolate::Current(); |
| 492 FlatStringReader reader(isolate, CStrVector(input)); |
492 RegExpCompileData compile_data; | 493 RegExpCompileData compile_data; |
493 if (!v8::internal::RegExpParser::ParseRegExp(&reader, multiline, | 494 if (!v8::internal::RegExpParser::ParseRegExp(&reader, multiline, |
494 &compile_data)) | 495 &compile_data)) |
495 return NULL; | 496 return NULL; |
496 Handle<String> pattern = FACTORY->NewStringFromUtf8(CStrVector(input)); | 497 Handle<String> pattern = isolate->factory()-> |
| 498 NewStringFromUtf8(CStrVector(input)); |
497 RegExpEngine::Compile(&compile_data, false, multiline, pattern, is_ascii); | 499 RegExpEngine::Compile(&compile_data, false, multiline, pattern, is_ascii); |
498 return compile_data.node; | 500 return compile_data.node; |
499 } | 501 } |
500 | 502 |
501 | 503 |
502 static void Execute(const char* input, | 504 static void Execute(const char* input, |
503 bool multiline, | 505 bool multiline, |
504 bool is_ascii, | 506 bool is_ascii, |
505 bool dot_output = false) { | 507 bool dot_output = false) { |
506 v8::HandleScope scope; | 508 v8::HandleScope scope; |
(...skipping 201 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
708 input_start, | 710 input_start, |
709 input_end, | 711 input_end, |
710 captures, | 712 captures, |
711 Isolate::Current()); | 713 Isolate::Current()); |
712 } | 714 } |
713 | 715 |
714 | 716 |
715 TEST(MacroAssemblerNativeSuccess) { | 717 TEST(MacroAssemblerNativeSuccess) { |
716 v8::V8::Initialize(); | 718 v8::V8::Initialize(); |
717 ContextInitializer initializer; | 719 ContextInitializer initializer; |
| 720 Factory* factory = Isolate::Current()->factory(); |
718 | 721 |
719 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); | 722 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); |
720 | 723 |
721 m.Succeed(); | 724 m.Succeed(); |
722 | 725 |
723 Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("")); | 726 Handle<String> source = factory->NewStringFromAscii(CStrVector("")); |
724 Handle<Object> code_object = m.GetCode(source); | 727 Handle<Object> code_object = m.GetCode(source); |
725 Handle<Code> code = Handle<Code>::cast(code_object); | 728 Handle<Code> code = Handle<Code>::cast(code_object); |
726 | 729 |
727 int captures[4] = {42, 37, 87, 117}; | 730 int captures[4] = {42, 37, 87, 117}; |
728 Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("foofoo")); | 731 Handle<String> input = factory->NewStringFromAscii(CStrVector("foofoo")); |
729 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 732 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
730 const byte* start_adr = | 733 const byte* start_adr = |
731 reinterpret_cast<const byte*>(seq_input->GetCharsAddress()); | 734 reinterpret_cast<const byte*>(seq_input->GetCharsAddress()); |
732 | 735 |
733 NativeRegExpMacroAssembler::Result result = | 736 NativeRegExpMacroAssembler::Result result = |
734 Execute(*code, | 737 Execute(*code, |
735 *input, | 738 *input, |
736 0, | 739 0, |
737 start_adr, | 740 start_adr, |
738 start_adr + seq_input->length(), | 741 start_adr + seq_input->length(), |
739 captures); | 742 captures); |
740 | 743 |
741 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 744 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
742 CHECK_EQ(-1, captures[0]); | 745 CHECK_EQ(-1, captures[0]); |
743 CHECK_EQ(-1, captures[1]); | 746 CHECK_EQ(-1, captures[1]); |
744 CHECK_EQ(-1, captures[2]); | 747 CHECK_EQ(-1, captures[2]); |
745 CHECK_EQ(-1, captures[3]); | 748 CHECK_EQ(-1, captures[3]); |
746 } | 749 } |
747 | 750 |
748 | 751 |
749 TEST(MacroAssemblerNativeSimple) { | 752 TEST(MacroAssemblerNativeSimple) { |
750 v8::V8::Initialize(); | 753 v8::V8::Initialize(); |
751 ContextInitializer initializer; | 754 ContextInitializer initializer; |
| 755 Factory* factory = Isolate::Current()->factory(); |
752 | 756 |
753 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); | 757 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); |
754 | 758 |
755 uc16 foo_chars[3] = {'f', 'o', 'o'}; | 759 uc16 foo_chars[3] = {'f', 'o', 'o'}; |
756 Vector<const uc16> foo(foo_chars, 3); | 760 Vector<const uc16> foo(foo_chars, 3); |
757 | 761 |
758 Label fail; | 762 Label fail; |
759 m.CheckCharacters(foo, 0, &fail, true); | 763 m.CheckCharacters(foo, 0, &fail, true); |
760 m.WriteCurrentPositionToRegister(0, 0); | 764 m.WriteCurrentPositionToRegister(0, 0); |
761 m.AdvanceCurrentPosition(3); | 765 m.AdvanceCurrentPosition(3); |
762 m.WriteCurrentPositionToRegister(1, 0); | 766 m.WriteCurrentPositionToRegister(1, 0); |
763 m.Succeed(); | 767 m.Succeed(); |
764 m.Bind(&fail); | 768 m.Bind(&fail); |
765 m.Fail(); | 769 m.Fail(); |
766 | 770 |
767 Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^foo")); | 771 Handle<String> source = factory->NewStringFromAscii(CStrVector("^foo")); |
768 Handle<Object> code_object = m.GetCode(source); | 772 Handle<Object> code_object = m.GetCode(source); |
769 Handle<Code> code = Handle<Code>::cast(code_object); | 773 Handle<Code> code = Handle<Code>::cast(code_object); |
770 | 774 |
771 int captures[4] = {42, 37, 87, 117}; | 775 int captures[4] = {42, 37, 87, 117}; |
772 Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("foofoo")); | 776 Handle<String> input = factory->NewStringFromAscii(CStrVector("foofoo")); |
773 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 777 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
774 Address start_adr = seq_input->GetCharsAddress(); | 778 Address start_adr = seq_input->GetCharsAddress(); |
775 | 779 |
776 NativeRegExpMacroAssembler::Result result = | 780 NativeRegExpMacroAssembler::Result result = |
777 Execute(*code, | 781 Execute(*code, |
778 *input, | 782 *input, |
779 0, | 783 0, |
780 start_adr, | 784 start_adr, |
781 start_adr + input->length(), | 785 start_adr + input->length(), |
782 captures); | 786 captures); |
783 | 787 |
784 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 788 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
785 CHECK_EQ(0, captures[0]); | 789 CHECK_EQ(0, captures[0]); |
786 CHECK_EQ(3, captures[1]); | 790 CHECK_EQ(3, captures[1]); |
787 CHECK_EQ(-1, captures[2]); | 791 CHECK_EQ(-1, captures[2]); |
788 CHECK_EQ(-1, captures[3]); | 792 CHECK_EQ(-1, captures[3]); |
789 | 793 |
790 input = FACTORY->NewStringFromAscii(CStrVector("barbarbar")); | 794 input = factory->NewStringFromAscii(CStrVector("barbarbar")); |
791 seq_input = Handle<SeqAsciiString>::cast(input); | 795 seq_input = Handle<SeqAsciiString>::cast(input); |
792 start_adr = seq_input->GetCharsAddress(); | 796 start_adr = seq_input->GetCharsAddress(); |
793 | 797 |
794 result = Execute(*code, | 798 result = Execute(*code, |
795 *input, | 799 *input, |
796 0, | 800 0, |
797 start_adr, | 801 start_adr, |
798 start_adr + input->length(), | 802 start_adr + input->length(), |
799 captures); | 803 captures); |
800 | 804 |
801 CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result); | 805 CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result); |
802 } | 806 } |
803 | 807 |
804 | 808 |
805 TEST(MacroAssemblerNativeSimpleUC16) { | 809 TEST(MacroAssemblerNativeSimpleUC16) { |
806 v8::V8::Initialize(); | 810 v8::V8::Initialize(); |
807 ContextInitializer initializer; | 811 ContextInitializer initializer; |
| 812 Factory* factory = Isolate::Current()->factory(); |
808 | 813 |
809 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4); | 814 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4); |
810 | 815 |
811 uc16 foo_chars[3] = {'f', 'o', 'o'}; | 816 uc16 foo_chars[3] = {'f', 'o', 'o'}; |
812 Vector<const uc16> foo(foo_chars, 3); | 817 Vector<const uc16> foo(foo_chars, 3); |
813 | 818 |
814 Label fail; | 819 Label fail; |
815 m.CheckCharacters(foo, 0, &fail, true); | 820 m.CheckCharacters(foo, 0, &fail, true); |
816 m.WriteCurrentPositionToRegister(0, 0); | 821 m.WriteCurrentPositionToRegister(0, 0); |
817 m.AdvanceCurrentPosition(3); | 822 m.AdvanceCurrentPosition(3); |
818 m.WriteCurrentPositionToRegister(1, 0); | 823 m.WriteCurrentPositionToRegister(1, 0); |
819 m.Succeed(); | 824 m.Succeed(); |
820 m.Bind(&fail); | 825 m.Bind(&fail); |
821 m.Fail(); | 826 m.Fail(); |
822 | 827 |
823 Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^foo")); | 828 Handle<String> source = factory->NewStringFromAscii(CStrVector("^foo")); |
824 Handle<Object> code_object = m.GetCode(source); | 829 Handle<Object> code_object = m.GetCode(source); |
825 Handle<Code> code = Handle<Code>::cast(code_object); | 830 Handle<Code> code = Handle<Code>::cast(code_object); |
826 | 831 |
827 int captures[4] = {42, 37, 87, 117}; | 832 int captures[4] = {42, 37, 87, 117}; |
828 const uc16 input_data[6] = {'f', 'o', 'o', 'f', 'o', '\xa0'}; | 833 const uc16 input_data[6] = {'f', 'o', 'o', 'f', 'o', '\xa0'}; |
829 Handle<String> input = | 834 Handle<String> input = |
830 FACTORY->NewStringFromTwoByte(Vector<const uc16>(input_data, 6)); | 835 factory->NewStringFromTwoByte(Vector<const uc16>(input_data, 6)); |
831 Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input); | 836 Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input); |
832 Address start_adr = seq_input->GetCharsAddress(); | 837 Address start_adr = seq_input->GetCharsAddress(); |
833 | 838 |
834 NativeRegExpMacroAssembler::Result result = | 839 NativeRegExpMacroAssembler::Result result = |
835 Execute(*code, | 840 Execute(*code, |
836 *input, | 841 *input, |
837 0, | 842 0, |
838 start_adr, | 843 start_adr, |
839 start_adr + input->length(), | 844 start_adr + input->length(), |
840 captures); | 845 captures); |
841 | 846 |
842 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 847 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
843 CHECK_EQ(0, captures[0]); | 848 CHECK_EQ(0, captures[0]); |
844 CHECK_EQ(3, captures[1]); | 849 CHECK_EQ(3, captures[1]); |
845 CHECK_EQ(-1, captures[2]); | 850 CHECK_EQ(-1, captures[2]); |
846 CHECK_EQ(-1, captures[3]); | 851 CHECK_EQ(-1, captures[3]); |
847 | 852 |
848 const uc16 input_data2[9] = {'b', 'a', 'r', 'b', 'a', 'r', 'b', 'a', '\xa0'}; | 853 const uc16 input_data2[9] = {'b', 'a', 'r', 'b', 'a', 'r', 'b', 'a', '\xa0'}; |
849 input = FACTORY->NewStringFromTwoByte(Vector<const uc16>(input_data2, 9)); | 854 input = factory->NewStringFromTwoByte(Vector<const uc16>(input_data2, 9)); |
850 seq_input = Handle<SeqTwoByteString>::cast(input); | 855 seq_input = Handle<SeqTwoByteString>::cast(input); |
851 start_adr = seq_input->GetCharsAddress(); | 856 start_adr = seq_input->GetCharsAddress(); |
852 | 857 |
853 result = Execute(*code, | 858 result = Execute(*code, |
854 *input, | 859 *input, |
855 0, | 860 0, |
856 start_adr, | 861 start_adr, |
857 start_adr + input->length() * 2, | 862 start_adr + input->length() * 2, |
858 captures); | 863 captures); |
859 | 864 |
860 CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result); | 865 CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result); |
861 } | 866 } |
862 | 867 |
863 | 868 |
864 TEST(MacroAssemblerNativeBacktrack) { | 869 TEST(MacroAssemblerNativeBacktrack) { |
865 v8::V8::Initialize(); | 870 v8::V8::Initialize(); |
866 ContextInitializer initializer; | 871 ContextInitializer initializer; |
| 872 Factory* factory = Isolate::Current()->factory(); |
867 | 873 |
868 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); | 874 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); |
869 | 875 |
870 Label fail; | 876 Label fail; |
871 Label backtrack; | 877 Label backtrack; |
872 m.LoadCurrentCharacter(10, &fail); | 878 m.LoadCurrentCharacter(10, &fail); |
873 m.Succeed(); | 879 m.Succeed(); |
874 m.Bind(&fail); | 880 m.Bind(&fail); |
875 m.PushBacktrack(&backtrack); | 881 m.PushBacktrack(&backtrack); |
876 m.LoadCurrentCharacter(10, NULL); | 882 m.LoadCurrentCharacter(10, NULL); |
877 m.Succeed(); | 883 m.Succeed(); |
878 m.Bind(&backtrack); | 884 m.Bind(&backtrack); |
879 m.Fail(); | 885 m.Fail(); |
880 | 886 |
881 Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("..........")); | 887 Handle<String> source = factory->NewStringFromAscii(CStrVector("..........")); |
882 Handle<Object> code_object = m.GetCode(source); | 888 Handle<Object> code_object = m.GetCode(source); |
883 Handle<Code> code = Handle<Code>::cast(code_object); | 889 Handle<Code> code = Handle<Code>::cast(code_object); |
884 | 890 |
885 Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("foofoo")); | 891 Handle<String> input = factory->NewStringFromAscii(CStrVector("foofoo")); |
886 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 892 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
887 Address start_adr = seq_input->GetCharsAddress(); | 893 Address start_adr = seq_input->GetCharsAddress(); |
888 | 894 |
889 NativeRegExpMacroAssembler::Result result = | 895 NativeRegExpMacroAssembler::Result result = |
890 Execute(*code, | 896 Execute(*code, |
891 *input, | 897 *input, |
892 0, | 898 0, |
893 start_adr, | 899 start_adr, |
894 start_adr + input->length(), | 900 start_adr + input->length(), |
895 NULL); | 901 NULL); |
896 | 902 |
897 CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result); | 903 CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result); |
898 } | 904 } |
899 | 905 |
900 | 906 |
901 TEST(MacroAssemblerNativeBackReferenceASCII) { | 907 TEST(MacroAssemblerNativeBackReferenceASCII) { |
902 v8::V8::Initialize(); | 908 v8::V8::Initialize(); |
903 ContextInitializer initializer; | 909 ContextInitializer initializer; |
| 910 Factory* factory = Isolate::Current()->factory(); |
904 | 911 |
905 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); | 912 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); |
906 | 913 |
907 m.WriteCurrentPositionToRegister(0, 0); | 914 m.WriteCurrentPositionToRegister(0, 0); |
908 m.AdvanceCurrentPosition(2); | 915 m.AdvanceCurrentPosition(2); |
909 m.WriteCurrentPositionToRegister(1, 0); | 916 m.WriteCurrentPositionToRegister(1, 0); |
910 Label nomatch; | 917 Label nomatch; |
911 m.CheckNotBackReference(0, &nomatch); | 918 m.CheckNotBackReference(0, &nomatch); |
912 m.Fail(); | 919 m.Fail(); |
913 m.Bind(&nomatch); | 920 m.Bind(&nomatch); |
914 m.AdvanceCurrentPosition(2); | 921 m.AdvanceCurrentPosition(2); |
915 Label missing_match; | 922 Label missing_match; |
916 m.CheckNotBackReference(0, &missing_match); | 923 m.CheckNotBackReference(0, &missing_match); |
917 m.WriteCurrentPositionToRegister(2, 0); | 924 m.WriteCurrentPositionToRegister(2, 0); |
918 m.Succeed(); | 925 m.Succeed(); |
919 m.Bind(&missing_match); | 926 m.Bind(&missing_match); |
920 m.Fail(); | 927 m.Fail(); |
921 | 928 |
922 Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^(..)..\1")); | 929 Handle<String> source = factory->NewStringFromAscii(CStrVector("^(..)..\1")); |
923 Handle<Object> code_object = m.GetCode(source); | 930 Handle<Object> code_object = m.GetCode(source); |
924 Handle<Code> code = Handle<Code>::cast(code_object); | 931 Handle<Code> code = Handle<Code>::cast(code_object); |
925 | 932 |
926 Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("fooofo")); | 933 Handle<String> input = factory->NewStringFromAscii(CStrVector("fooofo")); |
927 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 934 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
928 Address start_adr = seq_input->GetCharsAddress(); | 935 Address start_adr = seq_input->GetCharsAddress(); |
929 | 936 |
930 int output[4]; | 937 int output[4]; |
931 NativeRegExpMacroAssembler::Result result = | 938 NativeRegExpMacroAssembler::Result result = |
932 Execute(*code, | 939 Execute(*code, |
933 *input, | 940 *input, |
934 0, | 941 0, |
935 start_adr, | 942 start_adr, |
936 start_adr + input->length(), | 943 start_adr + input->length(), |
937 output); | 944 output); |
938 | 945 |
939 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 946 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
940 CHECK_EQ(0, output[0]); | 947 CHECK_EQ(0, output[0]); |
941 CHECK_EQ(2, output[1]); | 948 CHECK_EQ(2, output[1]); |
942 CHECK_EQ(6, output[2]); | 949 CHECK_EQ(6, output[2]); |
943 CHECK_EQ(-1, output[3]); | 950 CHECK_EQ(-1, output[3]); |
944 } | 951 } |
945 | 952 |
946 | 953 |
947 TEST(MacroAssemblerNativeBackReferenceUC16) { | 954 TEST(MacroAssemblerNativeBackReferenceUC16) { |
948 v8::V8::Initialize(); | 955 v8::V8::Initialize(); |
949 ContextInitializer initializer; | 956 ContextInitializer initializer; |
| 957 Factory* factory = Isolate::Current()->factory(); |
950 | 958 |
951 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4); | 959 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4); |
952 | 960 |
953 m.WriteCurrentPositionToRegister(0, 0); | 961 m.WriteCurrentPositionToRegister(0, 0); |
954 m.AdvanceCurrentPosition(2); | 962 m.AdvanceCurrentPosition(2); |
955 m.WriteCurrentPositionToRegister(1, 0); | 963 m.WriteCurrentPositionToRegister(1, 0); |
956 Label nomatch; | 964 Label nomatch; |
957 m.CheckNotBackReference(0, &nomatch); | 965 m.CheckNotBackReference(0, &nomatch); |
958 m.Fail(); | 966 m.Fail(); |
959 m.Bind(&nomatch); | 967 m.Bind(&nomatch); |
960 m.AdvanceCurrentPosition(2); | 968 m.AdvanceCurrentPosition(2); |
961 Label missing_match; | 969 Label missing_match; |
962 m.CheckNotBackReference(0, &missing_match); | 970 m.CheckNotBackReference(0, &missing_match); |
963 m.WriteCurrentPositionToRegister(2, 0); | 971 m.WriteCurrentPositionToRegister(2, 0); |
964 m.Succeed(); | 972 m.Succeed(); |
965 m.Bind(&missing_match); | 973 m.Bind(&missing_match); |
966 m.Fail(); | 974 m.Fail(); |
967 | 975 |
968 Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^(..)..\1")); | 976 Handle<String> source = factory->NewStringFromAscii(CStrVector("^(..)..\1")); |
969 Handle<Object> code_object = m.GetCode(source); | 977 Handle<Object> code_object = m.GetCode(source); |
970 Handle<Code> code = Handle<Code>::cast(code_object); | 978 Handle<Code> code = Handle<Code>::cast(code_object); |
971 | 979 |
972 const uc16 input_data[6] = {'f', 0x2028, 'o', 'o', 'f', 0x2028}; | 980 const uc16 input_data[6] = {'f', 0x2028, 'o', 'o', 'f', 0x2028}; |
973 Handle<String> input = | 981 Handle<String> input = |
974 FACTORY->NewStringFromTwoByte(Vector<const uc16>(input_data, 6)); | 982 factory->NewStringFromTwoByte(Vector<const uc16>(input_data, 6)); |
975 Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input); | 983 Handle<SeqTwoByteString> seq_input = Handle<SeqTwoByteString>::cast(input); |
976 Address start_adr = seq_input->GetCharsAddress(); | 984 Address start_adr = seq_input->GetCharsAddress(); |
977 | 985 |
978 int output[4]; | 986 int output[4]; |
979 NativeRegExpMacroAssembler::Result result = | 987 NativeRegExpMacroAssembler::Result result = |
980 Execute(*code, | 988 Execute(*code, |
981 *input, | 989 *input, |
982 0, | 990 0, |
983 start_adr, | 991 start_adr, |
984 start_adr + input->length() * 2, | 992 start_adr + input->length() * 2, |
985 output); | 993 output); |
986 | 994 |
987 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 995 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
988 CHECK_EQ(0, output[0]); | 996 CHECK_EQ(0, output[0]); |
989 CHECK_EQ(2, output[1]); | 997 CHECK_EQ(2, output[1]); |
990 CHECK_EQ(6, output[2]); | 998 CHECK_EQ(6, output[2]); |
991 CHECK_EQ(-1, output[3]); | 999 CHECK_EQ(-1, output[3]); |
992 } | 1000 } |
993 | 1001 |
994 | 1002 |
995 | 1003 |
996 TEST(MacroAssemblernativeAtStart) { | 1004 TEST(MacroAssemblernativeAtStart) { |
997 v8::V8::Initialize(); | 1005 v8::V8::Initialize(); |
998 ContextInitializer initializer; | 1006 ContextInitializer initializer; |
| 1007 Factory* factory = Isolate::Current()->factory(); |
999 | 1008 |
1000 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); | 1009 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); |
1001 | 1010 |
1002 Label not_at_start, newline, fail; | 1011 Label not_at_start, newline, fail; |
1003 m.CheckNotAtStart(¬_at_start); | 1012 m.CheckNotAtStart(¬_at_start); |
1004 // Check that prevchar = '\n' and current = 'f'. | 1013 // Check that prevchar = '\n' and current = 'f'. |
1005 m.CheckCharacter('\n', &newline); | 1014 m.CheckCharacter('\n', &newline); |
1006 m.Bind(&fail); | 1015 m.Bind(&fail); |
1007 m.Fail(); | 1016 m.Fail(); |
1008 m.Bind(&newline); | 1017 m.Bind(&newline); |
1009 m.LoadCurrentCharacter(0, &fail); | 1018 m.LoadCurrentCharacter(0, &fail); |
1010 m.CheckNotCharacter('f', &fail); | 1019 m.CheckNotCharacter('f', &fail); |
1011 m.Succeed(); | 1020 m.Succeed(); |
1012 | 1021 |
1013 m.Bind(¬_at_start); | 1022 m.Bind(¬_at_start); |
1014 // Check that prevchar = 'o' and current = 'b'. | 1023 // Check that prevchar = 'o' and current = 'b'. |
1015 Label prevo; | 1024 Label prevo; |
1016 m.CheckCharacter('o', &prevo); | 1025 m.CheckCharacter('o', &prevo); |
1017 m.Fail(); | 1026 m.Fail(); |
1018 m.Bind(&prevo); | 1027 m.Bind(&prevo); |
1019 m.LoadCurrentCharacter(0, &fail); | 1028 m.LoadCurrentCharacter(0, &fail); |
1020 m.CheckNotCharacter('b', &fail); | 1029 m.CheckNotCharacter('b', &fail); |
1021 m.Succeed(); | 1030 m.Succeed(); |
1022 | 1031 |
1023 Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("(^f|ob)")); | 1032 Handle<String> source = factory->NewStringFromAscii(CStrVector("(^f|ob)")); |
1024 Handle<Object> code_object = m.GetCode(source); | 1033 Handle<Object> code_object = m.GetCode(source); |
1025 Handle<Code> code = Handle<Code>::cast(code_object); | 1034 Handle<Code> code = Handle<Code>::cast(code_object); |
1026 | 1035 |
1027 Handle<String> input = FACTORY->NewStringFromAscii(CStrVector("foobar")); | 1036 Handle<String> input = factory->NewStringFromAscii(CStrVector("foobar")); |
1028 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 1037 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
1029 Address start_adr = seq_input->GetCharsAddress(); | 1038 Address start_adr = seq_input->GetCharsAddress(); |
1030 | 1039 |
1031 NativeRegExpMacroAssembler::Result result = | 1040 NativeRegExpMacroAssembler::Result result = |
1032 Execute(*code, | 1041 Execute(*code, |
1033 *input, | 1042 *input, |
1034 0, | 1043 0, |
1035 start_adr, | 1044 start_adr, |
1036 start_adr + input->length(), | 1045 start_adr + input->length(), |
1037 NULL); | 1046 NULL); |
1038 | 1047 |
1039 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 1048 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
1040 | 1049 |
1041 result = Execute(*code, | 1050 result = Execute(*code, |
1042 *input, | 1051 *input, |
1043 3, | 1052 3, |
1044 start_adr + 3, | 1053 start_adr + 3, |
1045 start_adr + input->length(), | 1054 start_adr + input->length(), |
1046 NULL); | 1055 NULL); |
1047 | 1056 |
1048 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 1057 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
1049 } | 1058 } |
1050 | 1059 |
1051 | 1060 |
1052 TEST(MacroAssemblerNativeBackRefNoCase) { | 1061 TEST(MacroAssemblerNativeBackRefNoCase) { |
1053 v8::V8::Initialize(); | 1062 v8::V8::Initialize(); |
1054 ContextInitializer initializer; | 1063 ContextInitializer initializer; |
| 1064 Factory* factory = Isolate::Current()->factory(); |
1055 | 1065 |
1056 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); | 1066 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4); |
1057 | 1067 |
1058 Label fail, succ; | 1068 Label fail, succ; |
1059 | 1069 |
1060 m.WriteCurrentPositionToRegister(0, 0); | 1070 m.WriteCurrentPositionToRegister(0, 0); |
1061 m.WriteCurrentPositionToRegister(2, 0); | 1071 m.WriteCurrentPositionToRegister(2, 0); |
1062 m.AdvanceCurrentPosition(3); | 1072 m.AdvanceCurrentPosition(3); |
1063 m.WriteCurrentPositionToRegister(3, 0); | 1073 m.WriteCurrentPositionToRegister(3, 0); |
1064 m.CheckNotBackReferenceIgnoreCase(2, &fail); // Match "AbC". | 1074 m.CheckNotBackReferenceIgnoreCase(2, &fail); // Match "AbC". |
1065 m.CheckNotBackReferenceIgnoreCase(2, &fail); // Match "ABC". | 1075 m.CheckNotBackReferenceIgnoreCase(2, &fail); // Match "ABC". |
1066 Label expected_fail; | 1076 Label expected_fail; |
1067 m.CheckNotBackReferenceIgnoreCase(2, &expected_fail); | 1077 m.CheckNotBackReferenceIgnoreCase(2, &expected_fail); |
1068 m.Bind(&fail); | 1078 m.Bind(&fail); |
1069 m.Fail(); | 1079 m.Fail(); |
1070 | 1080 |
1071 m.Bind(&expected_fail); | 1081 m.Bind(&expected_fail); |
1072 m.AdvanceCurrentPosition(3); // Skip "xYz" | 1082 m.AdvanceCurrentPosition(3); // Skip "xYz" |
1073 m.CheckNotBackReferenceIgnoreCase(2, &succ); | 1083 m.CheckNotBackReferenceIgnoreCase(2, &succ); |
1074 m.Fail(); | 1084 m.Fail(); |
1075 | 1085 |
1076 m.Bind(&succ); | 1086 m.Bind(&succ); |
1077 m.WriteCurrentPositionToRegister(1, 0); | 1087 m.WriteCurrentPositionToRegister(1, 0); |
1078 m.Succeed(); | 1088 m.Succeed(); |
1079 | 1089 |
1080 Handle<String> source = | 1090 Handle<String> source = |
1081 FACTORY->NewStringFromAscii(CStrVector("^(abc)\1\1(?!\1)...(?!\1)")); | 1091 factory->NewStringFromAscii(CStrVector("^(abc)\1\1(?!\1)...(?!\1)")); |
1082 Handle<Object> code_object = m.GetCode(source); | 1092 Handle<Object> code_object = m.GetCode(source); |
1083 Handle<Code> code = Handle<Code>::cast(code_object); | 1093 Handle<Code> code = Handle<Code>::cast(code_object); |
1084 | 1094 |
1085 Handle<String> input = | 1095 Handle<String> input = |
1086 FACTORY->NewStringFromAscii(CStrVector("aBcAbCABCxYzab")); | 1096 factory->NewStringFromAscii(CStrVector("aBcAbCABCxYzab")); |
1087 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 1097 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
1088 Address start_adr = seq_input->GetCharsAddress(); | 1098 Address start_adr = seq_input->GetCharsAddress(); |
1089 | 1099 |
1090 int output[4]; | 1100 int output[4]; |
1091 NativeRegExpMacroAssembler::Result result = | 1101 NativeRegExpMacroAssembler::Result result = |
1092 Execute(*code, | 1102 Execute(*code, |
1093 *input, | 1103 *input, |
1094 0, | 1104 0, |
1095 start_adr, | 1105 start_adr, |
1096 start_adr + input->length(), | 1106 start_adr + input->length(), |
1097 output); | 1107 output); |
1098 | 1108 |
1099 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 1109 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
1100 CHECK_EQ(0, output[0]); | 1110 CHECK_EQ(0, output[0]); |
1101 CHECK_EQ(12, output[1]); | 1111 CHECK_EQ(12, output[1]); |
1102 CHECK_EQ(0, output[2]); | 1112 CHECK_EQ(0, output[2]); |
1103 CHECK_EQ(3, output[3]); | 1113 CHECK_EQ(3, output[3]); |
1104 } | 1114 } |
1105 | 1115 |
1106 | 1116 |
1107 | 1117 |
1108 TEST(MacroAssemblerNativeRegisters) { | 1118 TEST(MacroAssemblerNativeRegisters) { |
1109 v8::V8::Initialize(); | 1119 v8::V8::Initialize(); |
1110 ContextInitializer initializer; | 1120 ContextInitializer initializer; |
| 1121 Factory* factory = Isolate::Current()->factory(); |
1111 | 1122 |
1112 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 6); | 1123 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 6); |
1113 | 1124 |
1114 uc16 foo_chars[3] = {'f', 'o', 'o'}; | 1125 uc16 foo_chars[3] = {'f', 'o', 'o'}; |
1115 Vector<const uc16> foo(foo_chars, 3); | 1126 Vector<const uc16> foo(foo_chars, 3); |
1116 | 1127 |
1117 enum registers { out1, out2, out3, out4, out5, out6, sp, loop_cnt }; | 1128 enum registers { out1, out2, out3, out4, out5, out6, sp, loop_cnt }; |
1118 Label fail; | 1129 Label fail; |
1119 Label backtrack; | 1130 Label backtrack; |
1120 m.WriteCurrentPositionToRegister(out1, 0); // Output: [0] | 1131 m.WriteCurrentPositionToRegister(out1, 0); // Output: [0] |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1169 m.Bind(&exit_loop3); | 1180 m.Bind(&exit_loop3); |
1170 m.PopCurrentPosition(); | 1181 m.PopCurrentPosition(); |
1171 m.WriteCurrentPositionToRegister(out5, 0); // [0,3,6,9,9,-1] | 1182 m.WriteCurrentPositionToRegister(out5, 0); // [0,3,6,9,9,-1] |
1172 | 1183 |
1173 m.Succeed(); | 1184 m.Succeed(); |
1174 | 1185 |
1175 m.Bind(&fail); | 1186 m.Bind(&fail); |
1176 m.Fail(); | 1187 m.Fail(); |
1177 | 1188 |
1178 Handle<String> source = | 1189 Handle<String> source = |
1179 FACTORY->NewStringFromAscii(CStrVector("<loop test>")); | 1190 factory->NewStringFromAscii(CStrVector("<loop test>")); |
1180 Handle<Object> code_object = m.GetCode(source); | 1191 Handle<Object> code_object = m.GetCode(source); |
1181 Handle<Code> code = Handle<Code>::cast(code_object); | 1192 Handle<Code> code = Handle<Code>::cast(code_object); |
1182 | 1193 |
1183 // String long enough for test (content doesn't matter). | 1194 // String long enough for test (content doesn't matter). |
1184 Handle<String> input = | 1195 Handle<String> input = |
1185 FACTORY->NewStringFromAscii(CStrVector("foofoofoofoofoo")); | 1196 factory->NewStringFromAscii(CStrVector("foofoofoofoofoo")); |
1186 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 1197 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
1187 Address start_adr = seq_input->GetCharsAddress(); | 1198 Address start_adr = seq_input->GetCharsAddress(); |
1188 | 1199 |
1189 int output[6]; | 1200 int output[6]; |
1190 NativeRegExpMacroAssembler::Result result = | 1201 NativeRegExpMacroAssembler::Result result = |
1191 Execute(*code, | 1202 Execute(*code, |
1192 *input, | 1203 *input, |
1193 0, | 1204 0, |
1194 start_adr, | 1205 start_adr, |
1195 start_adr + input->length(), | 1206 start_adr + input->length(), |
1196 output); | 1207 output); |
1197 | 1208 |
1198 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 1209 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
1199 CHECK_EQ(0, output[0]); | 1210 CHECK_EQ(0, output[0]); |
1200 CHECK_EQ(3, output[1]); | 1211 CHECK_EQ(3, output[1]); |
1201 CHECK_EQ(6, output[2]); | 1212 CHECK_EQ(6, output[2]); |
1202 CHECK_EQ(9, output[3]); | 1213 CHECK_EQ(9, output[3]); |
1203 CHECK_EQ(9, output[4]); | 1214 CHECK_EQ(9, output[4]); |
1204 CHECK_EQ(-1, output[5]); | 1215 CHECK_EQ(-1, output[5]); |
1205 } | 1216 } |
1206 | 1217 |
1207 | 1218 |
1208 TEST(MacroAssemblerStackOverflow) { | 1219 TEST(MacroAssemblerStackOverflow) { |
1209 v8::V8::Initialize(); | 1220 v8::V8::Initialize(); |
1210 ContextInitializer initializer; | 1221 ContextInitializer initializer; |
| 1222 Isolate* isolate = Isolate::Current(); |
| 1223 Factory* factory = isolate->factory(); |
1211 | 1224 |
1212 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); | 1225 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0); |
1213 | 1226 |
1214 Label loop; | 1227 Label loop; |
1215 m.Bind(&loop); | 1228 m.Bind(&loop); |
1216 m.PushBacktrack(&loop); | 1229 m.PushBacktrack(&loop); |
1217 m.GoTo(&loop); | 1230 m.GoTo(&loop); |
1218 | 1231 |
1219 Handle<String> source = | 1232 Handle<String> source = |
1220 FACTORY->NewStringFromAscii(CStrVector("<stack overflow test>")); | 1233 factory->NewStringFromAscii(CStrVector("<stack overflow test>")); |
1221 Handle<Object> code_object = m.GetCode(source); | 1234 Handle<Object> code_object = m.GetCode(source); |
1222 Handle<Code> code = Handle<Code>::cast(code_object); | 1235 Handle<Code> code = Handle<Code>::cast(code_object); |
1223 | 1236 |
1224 // String long enough for test (content doesn't matter). | 1237 // String long enough for test (content doesn't matter). |
1225 Handle<String> input = | 1238 Handle<String> input = |
1226 FACTORY->NewStringFromAscii(CStrVector("dummy")); | 1239 factory->NewStringFromAscii(CStrVector("dummy")); |
1227 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 1240 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
1228 Address start_adr = seq_input->GetCharsAddress(); | 1241 Address start_adr = seq_input->GetCharsAddress(); |
1229 | 1242 |
1230 NativeRegExpMacroAssembler::Result result = | 1243 NativeRegExpMacroAssembler::Result result = |
1231 Execute(*code, | 1244 Execute(*code, |
1232 *input, | 1245 *input, |
1233 0, | 1246 0, |
1234 start_adr, | 1247 start_adr, |
1235 start_adr + input->length(), | 1248 start_adr + input->length(), |
1236 NULL); | 1249 NULL); |
1237 | 1250 |
1238 CHECK_EQ(NativeRegExpMacroAssembler::EXCEPTION, result); | 1251 CHECK_EQ(NativeRegExpMacroAssembler::EXCEPTION, result); |
1239 CHECK(Isolate::Current()->has_pending_exception()); | 1252 CHECK(isolate->has_pending_exception()); |
1240 Isolate::Current()->clear_pending_exception(); | 1253 isolate->clear_pending_exception(); |
1241 } | 1254 } |
1242 | 1255 |
1243 | 1256 |
1244 TEST(MacroAssemblerNativeLotsOfRegisters) { | 1257 TEST(MacroAssemblerNativeLotsOfRegisters) { |
1245 v8::V8::Initialize(); | 1258 v8::V8::Initialize(); |
1246 ContextInitializer initializer; | 1259 ContextInitializer initializer; |
| 1260 Isolate* isolate = Isolate::Current(); |
| 1261 Factory* factory = isolate->factory(); |
1247 | 1262 |
1248 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 2); | 1263 ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 2); |
1249 | 1264 |
1250 // At least 2048, to ensure the allocated space for registers | 1265 // At least 2048, to ensure the allocated space for registers |
1251 // span one full page. | 1266 // span one full page. |
1252 const int large_number = 8000; | 1267 const int large_number = 8000; |
1253 m.WriteCurrentPositionToRegister(large_number, 42); | 1268 m.WriteCurrentPositionToRegister(large_number, 42); |
1254 m.WriteCurrentPositionToRegister(0, 0); | 1269 m.WriteCurrentPositionToRegister(0, 0); |
1255 m.WriteCurrentPositionToRegister(1, 1); | 1270 m.WriteCurrentPositionToRegister(1, 1); |
1256 Label done; | 1271 Label done; |
1257 m.CheckNotBackReference(0, &done); // Performs a system-stack push. | 1272 m.CheckNotBackReference(0, &done); // Performs a system-stack push. |
1258 m.Bind(&done); | 1273 m.Bind(&done); |
1259 m.PushRegister(large_number, RegExpMacroAssembler::kNoStackLimitCheck); | 1274 m.PushRegister(large_number, RegExpMacroAssembler::kNoStackLimitCheck); |
1260 m.PopRegister(1); | 1275 m.PopRegister(1); |
1261 m.Succeed(); | 1276 m.Succeed(); |
1262 | 1277 |
1263 Handle<String> source = | 1278 Handle<String> source = |
1264 FACTORY->NewStringFromAscii(CStrVector("<huge register space test>")); | 1279 factory->NewStringFromAscii(CStrVector("<huge register space test>")); |
1265 Handle<Object> code_object = m.GetCode(source); | 1280 Handle<Object> code_object = m.GetCode(source); |
1266 Handle<Code> code = Handle<Code>::cast(code_object); | 1281 Handle<Code> code = Handle<Code>::cast(code_object); |
1267 | 1282 |
1268 // String long enough for test (content doesn't matter). | 1283 // String long enough for test (content doesn't matter). |
1269 Handle<String> input = | 1284 Handle<String> input = |
1270 FACTORY->NewStringFromAscii(CStrVector("sample text")); | 1285 factory->NewStringFromAscii(CStrVector("sample text")); |
1271 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); | 1286 Handle<SeqAsciiString> seq_input = Handle<SeqAsciiString>::cast(input); |
1272 Address start_adr = seq_input->GetCharsAddress(); | 1287 Address start_adr = seq_input->GetCharsAddress(); |
1273 | 1288 |
1274 int captures[2]; | 1289 int captures[2]; |
1275 NativeRegExpMacroAssembler::Result result = | 1290 NativeRegExpMacroAssembler::Result result = |
1276 Execute(*code, | 1291 Execute(*code, |
1277 *input, | 1292 *input, |
1278 0, | 1293 0, |
1279 start_adr, | 1294 start_adr, |
1280 start_adr + input->length(), | 1295 start_adr + input->length(), |
1281 captures); | 1296 captures); |
1282 | 1297 |
1283 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); | 1298 CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result); |
1284 CHECK_EQ(0, captures[0]); | 1299 CHECK_EQ(0, captures[0]); |
1285 CHECK_EQ(42, captures[1]); | 1300 CHECK_EQ(42, captures[1]); |
1286 | 1301 |
1287 Isolate::Current()->clear_pending_exception(); | 1302 isolate->clear_pending_exception(); |
1288 } | 1303 } |
1289 | 1304 |
1290 #else // V8_INTERPRETED_REGEXP | 1305 #else // V8_INTERPRETED_REGEXP |
1291 | 1306 |
1292 TEST(MacroAssembler) { | 1307 TEST(MacroAssembler) { |
1293 V8::Initialize(NULL); | 1308 V8::Initialize(NULL); |
1294 byte codes[1024]; | 1309 byte codes[1024]; |
1295 RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024)); | 1310 RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024)); |
1296 // ^f(o)o. | 1311 // ^f(o)o. |
1297 Label fail, fail2, start; | 1312 Label fail, fail2, start; |
(...skipping 22 matching lines...) Expand all Loading... |
1320 m.Succeed(); | 1335 m.Succeed(); |
1321 | 1336 |
1322 m.Bind(&fail); | 1337 m.Bind(&fail); |
1323 m.Backtrack(); | 1338 m.Backtrack(); |
1324 m.Succeed(); | 1339 m.Succeed(); |
1325 | 1340 |
1326 m.Bind(&fail2); | 1341 m.Bind(&fail2); |
1327 m.PopRegister(0); | 1342 m.PopRegister(0); |
1328 m.Fail(); | 1343 m.Fail(); |
1329 | 1344 |
1330 v8::HandleScope scope; | 1345 Isolate* isolate = Isolate::Current(); |
| 1346 Factory* factory = isolate->factory(); |
| 1347 HandleScope scope(isolate); |
1331 | 1348 |
1332 Handle<String> source = FACTORY->NewStringFromAscii(CStrVector("^f(o)o")); | 1349 Handle<String> source = factory->NewStringFromAscii(CStrVector("^f(o)o")); |
1333 Handle<ByteArray> array = Handle<ByteArray>::cast(m.GetCode(source)); | 1350 Handle<ByteArray> array = Handle<ByteArray>::cast(m.GetCode(source)); |
1334 int captures[5]; | 1351 int captures[5]; |
1335 | 1352 |
1336 const uc16 str1[] = {'f', 'o', 'o', 'b', 'a', 'r'}; | 1353 const uc16 str1[] = {'f', 'o', 'o', 'b', 'a', 'r'}; |
1337 Handle<String> f1_16 = | 1354 Handle<String> f1_16 = |
1338 FACTORY->NewStringFromTwoByte(Vector<const uc16>(str1, 6)); | 1355 factory->NewStringFromTwoByte(Vector<const uc16>(str1, 6)); |
1339 | 1356 |
1340 CHECK(IrregexpInterpreter::Match(array, f1_16, captures, 0)); | 1357 CHECK(IrregexpInterpreter::Match(isolate, array, f1_16, captures, 0)); |
1341 CHECK_EQ(0, captures[0]); | 1358 CHECK_EQ(0, captures[0]); |
1342 CHECK_EQ(3, captures[1]); | 1359 CHECK_EQ(3, captures[1]); |
1343 CHECK_EQ(1, captures[2]); | 1360 CHECK_EQ(1, captures[2]); |
1344 CHECK_EQ(2, captures[3]); | 1361 CHECK_EQ(2, captures[3]); |
1345 CHECK_EQ(84, captures[4]); | 1362 CHECK_EQ(84, captures[4]); |
1346 | 1363 |
1347 const uc16 str2[] = {'b', 'a', 'r', 'f', 'o', 'o'}; | 1364 const uc16 str2[] = {'b', 'a', 'r', 'f', 'o', 'o'}; |
1348 Handle<String> f2_16 = | 1365 Handle<String> f2_16 = |
1349 FACTORY->NewStringFromTwoByte(Vector<const uc16>(str2, 6)); | 1366 factory->NewStringFromTwoByte(Vector<const uc16>(str2, 6)); |
1350 | 1367 |
1351 CHECK(!IrregexpInterpreter::Match(array, f2_16, captures, 0)); | 1368 CHECK(!IrregexpInterpreter::Match(isolate, array, f2_16, captures, 0)); |
1352 CHECK_EQ(42, captures[0]); | 1369 CHECK_EQ(42, captures[0]); |
1353 } | 1370 } |
1354 | 1371 |
1355 #endif // V8_INTERPRETED_REGEXP | 1372 #endif // V8_INTERPRETED_REGEXP |
1356 | 1373 |
1357 | 1374 |
1358 TEST(AddInverseToTable) { | 1375 TEST(AddInverseToTable) { |
1359 v8::internal::V8::Initialize(NULL); | 1376 v8::internal::V8::Initialize(NULL); |
1360 static const int kLimit = 1000; | 1377 static const int kLimit = 1000; |
1361 static const int kRangeCount = 16; | 1378 static const int kRangeCount = 16; |
(...skipping 438 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1800 bool in_second = CharacterInSet(&l2, i); | 1817 bool in_second = CharacterInSet(&l2, i); |
1801 CHECK((in_first || in_second) == CharacterInSet(&all, i)); | 1818 CHECK((in_first || in_second) == CharacterInSet(&all, i)); |
1802 } | 1819 } |
1803 } | 1820 } |
1804 | 1821 |
1805 | 1822 |
1806 TEST(Graph) { | 1823 TEST(Graph) { |
1807 V8::Initialize(NULL); | 1824 V8::Initialize(NULL); |
1808 Execute("\\b\\w+\\b", false, true, true); | 1825 Execute("\\b\\w+\\b", false, true, true); |
1809 } | 1826 } |
OLD | NEW |