Author: [EMAIL PROTECTED]
Date: Fri Nov 7 04:00:59 2008
New Revision: 711
Added:
branches/experimental/regexp2000/src/regexp-macro-assembler-re2k.cc
(contents, props changed)
- copied, changed from r706,
/branches/experimental/regexp2000/src/regexp-codegen-re2k.cc
branches/experimental/regexp2000/src/regexp-macro-assembler-re2k.h
branches/experimental/regexp2000/src/regexp-macro-assembler.h
(contents, props changed)
- copied, changed from r707,
/branches/experimental/regexp2000/src/regexp-codegen.h
Removed:
branches/experimental/regexp2000/src/regexp-codegen-re2k.cc
branches/experimental/regexp2000/src/regexp-codegen.h
Modified:
branches/experimental/regexp2000/src/SConscript
branches/experimental/regexp2000/src/assembler-re2k-inl.h
branches/experimental/regexp2000/src/assembler-re2k.cc
branches/experimental/regexp2000/src/assembler-re2k.h
branches/experimental/regexp2000/src/bytecodes-re2k.h
branches/experimental/regexp2000/src/flag-definitions.h
branches/experimental/regexp2000/src/interpreter-re2k.cc
branches/experimental/regexp2000/test/cctest/test-regexp.cc
Log:
Rename codegen to macro-assembler.
Remove unneeded byte codes accidentally not removed after feedback from
last review
More tests.
New instructions to check for end of input.
Rename captures array to registers array.
Review URL: http://codereview.chromium.org/9690
Modified: branches/experimental/regexp2000/src/SConscript
==============================================================================
--- branches/experimental/regexp2000/src/SConscript (original)
+++ branches/experimental/regexp2000/src/SConscript Fri Nov 7 04:00:59 2008
@@ -43,8 +43,8 @@
'factory.cc', 'flags.cc', 'frames.cc', 'global-handles.cc', 'handles.cc',
'hashmap.cc', 'heap.cc', 'ic.cc', 'interpreter-re2k.cc', 'jsregexp.cc',
'log.cc', 'mark-compact.cc', 'messages.cc', 'objects.cc', 'parser.cc',
- 'property.cc', 'regexp-codegen-re2k.cc', 'rewriter.cc', 'runtime.cc',
- 'scanner.cc', 'scopeinfo.cc', 'scopes.cc', 'serialize.cc',
+ 'property.cc', 'regexp-macro-assembler-re2k.cc', 'rewriter.cc',
+ 'runtime.cc', 'scanner.cc', 'scopeinfo.cc', 'scopes.cc', 'serialize.cc',
'snapshot-common.cc', 'spaces.cc', 'string-stream.cc', 'stub-cache.cc',
'token.cc', 'top.cc', 'unicode.cc', 'usage-analyzer.cc', 'utils.cc',
'v8-counters.cc', 'v8.cc', 'v8threads.cc', 'variables.cc', 'zone.cc'
Modified: branches/experimental/regexp2000/src/assembler-re2k-inl.h
==============================================================================
--- branches/experimental/regexp2000/src/assembler-re2k-inl.h (original)
+++ branches/experimental/regexp2000/src/assembler-re2k-inl.h Fri Nov 7
04:00:59 2008
@@ -31,7 +31,6 @@
#include "v8.h"
#include "ast.h"
#include "bytecodes-re2k.h"
-#include "regexp-codegen.h"
#include "assembler-re2k.h"
@@ -65,7 +64,6 @@
}
l->link_to(pc_);
Emit32(pos);
- pc_ += 4;
}
}
Modified: branches/experimental/regexp2000/src/assembler-re2k.cc
==============================================================================
--- branches/experimental/regexp2000/src/assembler-re2k.cc (original)
+++ branches/experimental/regexp2000/src/assembler-re2k.cc Fri Nov 7
04:00:59 2008
@@ -31,7 +31,6 @@
#include "v8.h"
#include "ast.h"
#include "bytecodes-re2k.h"
-#include "regexp-codegen.h"
#include "assembler-re2k.h"
#include "assembler-re2k-inl.h"
@@ -71,15 +70,23 @@
}
-void Re2kAssembler::SetRegister(int index, int cp_offset) {
+void Re2kAssembler::SetRegisterToCurrentPosition(int index, int cp_offset)
{
ASSERT(cp_offset >= 0);
ASSERT(index >= 0);
- Emit(BC_SET_REGISTER);
+ Emit(BC_SET_REGISTER_TO_CP);
Emit(index);
Emit32(cp_offset);
}
+void Re2kAssembler::SetRegister(int index, int value) {
+ ASSERT(index >= 0);
+ Emit(BC_SET_REGISTER);
+ Emit(index);
+ Emit32(value);
+}
+
+
void Re2kAssembler::PopCurrentPosition() {
Emit(BC_POP_CP);
}
@@ -101,6 +108,11 @@
}
+void Re2kAssembler::Break() {
+ Emit(BC_BREAK);
+}
+
+
void Re2kAssembler::FailIfWithin(int distance_from_end) {
Emit(BC_FAIL_IF_WITHIN);
Emit32(distance_from_end);
@@ -158,6 +170,18 @@
}
+void Re2kAssembler::CheckEnd(Label* on_not_end) {
+ Emit(BC_CHECK_END);
+ EmitOrLink(on_not_end);
+}
+
+
+void Re2kAssembler::CheckNotEnd(Label* on_end) {
+ Emit(BC_CHECK_NOT_END);
+ EmitOrLink(on_end);
+}
+
+
void Re2kAssembler::CheckRange(uc16 start, uc16 end, Label* on_mismatch) {
Emit(BC_CHECK_RANGE);
Emit16(start);
@@ -205,20 +229,6 @@
}
-void Re2kAssembler::CheckRegisterEq(int reg_index,
- uint16_t vs,
- Label* on_equal) {
- CheckRegister(BC_CHECK_REGISTER_EQ, reg_index, vs, on_equal);
-}
-
-
-void Re2kAssembler::CheckRegisterLe(int reg_index,
- uint16_t vs,
- Label* on_less_than_equal) {
- CheckRegister(BC_CHECK_REGISTER_LE, reg_index, vs, on_less_than_equal);
-}
-
-
void Re2kAssembler::CheckRegisterLt(int reg_index,
uint16_t vs,
Label* on_less_than) {
@@ -230,20 +240,6 @@
uint16_t vs,
Label* on_greater_than_equal) {
CheckRegister(BC_CHECK_REGISTER_GE, reg_index, vs,
on_greater_than_equal);
-}
-
-
-void Re2kAssembler::CheckRegisterGt(int reg_index,
- uint16_t vs,
- Label* on_greater_than) {
- CheckRegister(BC_CHECK_REGISTER_GT, reg_index, vs, on_greater_than);
-}
-
-
-void Re2kAssembler::CheckRegisterNe(int reg_index,
- uint16_t vs,
- Label* on_not_equal) {
- CheckRegister(BC_CHECK_REGISTER_NE, reg_index, vs, on_not_equal);
}
Modified: branches/experimental/regexp2000/src/assembler-re2k.h
==============================================================================
--- branches/experimental/regexp2000/src/assembler-re2k.h (original)
+++ branches/experimental/regexp2000/src/assembler-re2k.h Fri Nov 7
04:00:59 2008
@@ -33,7 +33,8 @@
void PushCurrentPosition(int cp_offset = 0);
void PushBacktrack(Label* l);
void PushRegister(int index);
- void SetRegister(int index, int cp_offset = 0);
+ void SetRegisterToCurrentPosition(int index, int cp_offset = 0);
+ void SetRegister(int index, int value);
void PopCurrentPosition();
void PopBacktrack();
@@ -43,6 +44,8 @@
void FailIfWithin(int distance_from_end);
void Succeed();
+ void Break(); // This instruction will cause a fatal VM error if hit.
+
void Bind(Label* l); // binds an unbound label L to the current code
position
void AdvanceCP(int cp_offset = 1);
@@ -56,11 +59,14 @@
void CheckChar(uc16 c, Label* on_mismatch);
void CheckNotChar(uc16 c, Label* on_match);
+ // Checks current char register against the magic end-of-input symbol.
+ void CheckEnd(Label* on_not_end);
+ void CheckNotEnd(Label* on_end);
+
// Checks current char register against a range.
void CheckRange(uc16 start, uc16 end, Label* on_mismatch);
void CheckNotRange(uc16 start, uc16 end, Label* on_match);
-
// Checks that the current char is in the range and that the
corresponding bit
// is set in the bitmap.
void CheckBitmap(uc16 start, uc16 end, const byte* bits, Label*
on_mismatch);
@@ -75,12 +81,8 @@
// Checks a register for equal, less than or equal, less than, greater
than
// or equal, greater than, not equal.
- void CheckRegisterEq(int reg_index, uint16_t vs, Label* on_equal);
- void CheckRegisterLe(int reg_index, uint16_t vs, Label* on_less_equal);
void CheckRegisterLt(int reg_index, uint16_t vs, Label* on_less_than);
void CheckRegisterGe(int reg_index, uint16_t vs, Label*
on_greater_equal);
- void CheckRegisterGt(int reg_index, uint16_t vs, Label* on_greater_than);
- void CheckRegisterNe(int reg_index, uint16_t vs, Label* on_not_equal);
// Code and bitmap emission.
inline void Emit32(uint32_t x);
Modified: branches/experimental/regexp2000/src/bytecodes-re2k.h
==============================================================================
--- branches/experimental/regexp2000/src/bytecodes-re2k.h (original)
+++ branches/experimental/regexp2000/src/bytecodes-re2k.h Fri Nov 7
04:00:59 2008
@@ -36,30 +36,29 @@
V(PUSH_CP, 1, 5) /* push_cp
offset32 */ \
V(PUSH_BT, 2, 5) /* push_bt
addr32 */ \
V(PUSH_REGISTER, 3, 2) /* push_register
register_index */ \
-V(SET_REGISTER, 4, 6) /* set_register register_index
offset32 */ \
-V(POP_CP, 5, 1) /*
pop_cp */ \
-V(POP_BT, 6, 1) /*
pop_bt */ \
-V(POP_REGISTER, 7, 2) /* pop_register
register_index */ \
-V(FAIL, 8, 1) /*
fail */ \
-V(FAIL_IF_WITHIN, 9, 5) /* fail
distance32 */ \
-V(SUCCEED, 10, 1) /*
succeed */ \
-V(ADVANCE_CP, 11, 5) /* advance_cp
offset32 */ \
-V(GOTO, 12, 5) /* goto
addr32 */ \
-V(LOAD_CURRENT_CHAR, 13, 5) /* load
offset32 */ \
-V(CHECK_CHAR, 14, 7) /* check_char uc16
addr32 */ \
-V(CHECK_NOT_CHAR, 15, 7) /* check_not_char uc16
addr32 */ \
-V(CHECK_RANGE, 16, 9) /* check_range uc16 uc16
addr32 */ \
-V(CHECK_NOT_RANGE, 17, 9) /* check_not_range uc16 uc16
addr32 */ \
-V(CHECK_BACKREF, 18, 9) /* check_backref offset32 capture_idx
addr32 */ \
-V(CHECK_NOT_BACKREF, 19, 9) /* check_not_backref offset32 capture_idx
addr32*/ \
-V(CHECK_BITMAP, 20, 13) /* check_bitmap uc16 uc16
addr32 */ \
-V(CHECK_NOT_BITMAP, 21, 13) /* check_not_bitmap uc16 uc16
addr32 */ \
-V(CHECK_REGISTER_EQ, 22, 8) /* check_reg_eq register_index value16
addr32 */ \
-V(CHECK_REGISTER_LE, 23, 8) /* check_reg_le register_index value16
addr32 */ \
-V(CHECK_REGISTER_LT, 24, 8) /* check_reg_lt register_index value16
addr32 */ \
-V(CHECK_REGISTER_GE, 25, 8) /* check_reg_ge register_index value16
addr32 */ \
-V(CHECK_REGISTER_GT, 26, 8) /* check_reg_gt register_index value16
addr32 */ \
-V(CHECK_REGISTER_NE, 27, 8) /* check_reg_ne register_index value16
addr32 */
+V(SET_REGISTER_TO_CP, 4, 6) /* set_register_to_cp register_index
offset32 */ \
+V(SET_REGISTER, 5, 6) /* set_register register_index
value32 */ \
+V(POP_CP, 6, 1) /*
pop_cp */ \
+V(POP_BT, 7, 1) /*
pop_bt */ \
+V(POP_REGISTER, 8, 2) /* pop_register
register_index */ \
+V(FAIL, 9, 1) /*
fail */ \
+V(FAIL_IF_WITHIN, 10, 5) /* fail
distance32 */ \
+V(SUCCEED, 11, 1) /*
succeed */ \
+V(ADVANCE_CP, 12, 5) /* advance_cp
offset32 */ \
+V(GOTO, 13, 5) /* goto
addr32 */ \
+V(LOAD_CURRENT_CHAR, 14, 5) /* load
offset32 */ \
+V(CHECK_CHAR, 15, 7) /* check_char uc16
addr32 */ \
+V(CHECK_NOT_CHAR, 16, 7) /* check_not_char uc16
addr32 */ \
+V(CHECK_END, 17, 7) /* check_end
addr32 */ \
+V(CHECK_NOT_END, 18, 7) /* check_not_end
addr32 */ \
+V(CHECK_RANGE, 19, 9) /* check_range uc16 uc16
addr32 */ \
+V(CHECK_NOT_RANGE, 20, 9) /* check_not_range uc16 uc16
addr32 */ \
+V(CHECK_BACKREF, 21, 9) /* check_backref offset32 capture_idx
addr32 */ \
+V(CHECK_NOT_BACKREF, 22, 9) /* check_not_backref offset32 capture_idx
addr32*/ \
+V(CHECK_BITMAP, 23, 13) /* check_bitmap uc16 uc16
addr32 */ \
+V(CHECK_NOT_BITMAP, 24, 13) /* check_not_bitmap uc16 uc16
addr32 */ \
+V(CHECK_REGISTER_LT, 25, 8) /* check_reg_lt register_index value16
addr32 */ \
+V(CHECK_REGISTER_GE, 26, 8) /* check_reg_ge register_index value16
addr32 */ \
#define DECLARE_BYTECODES(name, code, length) \
static const int BC_##name = code;
Modified: branches/experimental/regexp2000/src/flag-definitions.h
==============================================================================
--- branches/experimental/regexp2000/src/flag-definitions.h (original)
+++ branches/experimental/regexp2000/src/flag-definitions.h Fri Nov 7
04:00:59 2008
@@ -270,6 +270,7 @@
"(requires heap_stats)")
DEFINE_bool(trace_regexps, false, "trace regexp execution")
+DEFINE_bool(trace_regexp_bytecodes, false, "trace regexp bytecode
executon")
//
// Logging and profiling only flags
Modified: branches/experimental/regexp2000/src/interpreter-re2k.cc
==============================================================================
--- branches/experimental/regexp2000/src/interpreter-re2k.cc (original)
+++ branches/experimental/regexp2000/src/interpreter-re2k.cc Fri Nov 7
04:00:59 2008
@@ -38,6 +38,20 @@
namespace v8 { namespace internal {
+#ifdef DEBUG
+# define BYTECODE(name) break; \
+ case BC_##name: \
+ if (FLAG_trace_regexp_bytecodes) { \
+ PrintF("pc = %d, current = %d, bc = " \
+ #name "\n", pc - code_base, current); \
+ }
+#else
+# define BYTECODE(name) break; \
+ case BC_##name:
+#endif
+
+
+
template <typename Char>
static bool RawMatch(const byte* code_base,
Vector<const Char> subject,
@@ -48,71 +62,69 @@
int backtrack_stack_space = 1000;
int* backtrack_sp = backtrack_stack;
int current_char = -1;
+#ifdef DEBUG
+ if (FLAG_trace_regexp_bytecodes) {
+ PrintF("\n\nStart bytecode interpreter\n\n");
+ }
+#endif
while (true) {
switch (*pc) {
- case BC_BREAK:
+ BYTECODE(BREAK)
UNREACHABLE();
return false;
- case BC_PUSH_CP:
+ BYTECODE(PUSH_CP)
if (--backtrack_stack_space < 0) {
return false; // No match on backtrack stack overflow.
}
*backtrack_sp++ = current + Load32(pc + 1);
pc += 5;
- break;
- case BC_PUSH_BT:
+ BYTECODE(PUSH_BT)
if (--backtrack_stack_space < 0) {
return false; // No match on backtrack stack overflow.
}
*backtrack_sp++ = Load32(pc + 1);
pc += 5;
- break;
- case BC_PUSH_REGISTER:
+ BYTECODE(PUSH_REGISTER)
if (--backtrack_stack_space < 0) {
return false; // No match on backtrack stack overflow.
}
*backtrack_sp++ = registers[pc[1]];
pc += 2;
- break;
- case BC_SET_REGISTER:
+ BYTECODE(SET_REGISTER)
+ registers[pc[1]] = Load32(pc + 2);
+ pc += 6;
+ BYTECODE(SET_REGISTER_TO_CP)
registers[pc[1]] = current + Load32(pc + 2);
pc += 6;
- break;
- case BC_POP_CP:
+ BYTECODE(POP_CP)
backtrack_stack_space++;
--backtrack_sp;
current = *backtrack_sp;
pc += 1;
- break;
- case BC_POP_BT:
+ BYTECODE(POP_BT)
backtrack_stack_space++;
--backtrack_sp;
pc = code_base + *backtrack_sp;
- break;
- case BC_POP_REGISTER:
+ BYTECODE(POP_REGISTER)
backtrack_stack_space++;
--backtrack_sp;
registers[pc[1]] = *backtrack_sp;
pc += 2;
- break;
- case BC_FAIL:
+ BYTECODE(FAIL)
return false;
- case BC_FAIL_IF_WITHIN:
+ BYTECODE(FAIL_IF_WITHIN)
if (current + Load32(pc + 1) >= subject.length()) {
return false;
}
pc += 5;
- break;
- case BC_SUCCEED:
+ BYTECODE(SUCCEED)
return true;
- case BC_ADVANCE_CP:
+ BYTECODE(ADVANCE_CP)
current += Load32(pc + 1);
pc += 5;
- break;
- case BC_GOTO:
+ BYTECODE(GOTO)
pc = code_base + Load32(pc + 1);
- break;
- case BC_LOAD_CURRENT_CHAR: {
+ BYTECODE(LOAD_CURRENT_CHAR) {
int pos = current + Load32(pc + 1);
if (pos >= subject.length()) {
current_char = -1;
@@ -120,27 +132,38 @@
current_char = subject[pos];
}
pc += 5;
- break;
}
- case BC_CHECK_CHAR: {
+ BYTECODE(CHECK_CHAR) {
int c = Load16(pc + 1);
if (c != current_char) {
pc = code_base + Load32(pc + 3);
} else {
pc += 7;
}
- break;
}
- case BC_CHECK_NOT_CHAR: {
+ BYTECODE(CHECK_NOT_CHAR) {
int c = Load16(pc + 1);
- if (c == current_char || current_char == -1) {
+ if (c == current_char) {
pc = code_base + Load32(pc + 3);
} else {
pc += 7;
}
- break;
}
- case BC_CHECK_RANGE: {
+ BYTECODE(CHECK_END) {
+ if (current_char != -1) {
+ pc = code_base + Load32(pc + 1);
+ } else {
+ pc += 5;
+ }
+ }
+ BYTECODE(CHECK_NOT_END) {
+ if (current_char == -1) {
+ pc = code_base + Load32(pc + 1);
+ } else {
+ pc += 5;
+ }
+ }
+ BYTECODE(CHECK_RANGE) {
int start = Load16(pc + 1);
int end = Load16(pc + 3);
if (current_char >= start && current_char <= end) {
@@ -148,9 +171,8 @@
} else {
pc += 9;
}
- break;
}
- case BC_CHECK_NOT_RANGE: {
+ BYTECODE(CHECK_NOT_RANGE) {
int start = Load16(pc + 1);
int end = Load16(pc + 3);
if (current_char < start || current_char > end || current_char ==
-1) {
@@ -158,54 +180,28 @@
} else {
pc += 9;
}
- break;
}
- case BC_CHECK_REGISTER_EQ:
- if (registers[pc[1]] == Load16(pc + 2)) {
- pc = code_base + Load32(pc + 4);
- } else {
- pc += 8;
- }
- break;
- case BC_CHECK_REGISTER_LE:
- if (registers[pc[1]] <= Load16(pc + 2)) {
- pc = code_base + Load32(pc + 4);
- } else {
- pc += 8;
- }
- break;
- case BC_CHECK_REGISTER_LT:
+ BYTECODE(CHECK_REGISTER_LT)
if (registers[pc[1]] < Load16(pc + 2)) {
pc = code_base + Load32(pc + 4);
} else {
pc += 8;
}
- break;
- case BC_CHECK_REGISTER_GE:
+ BYTECODE(CHECK_REGISTER_GE)
if (registers[pc[1]] >= Load16(pc + 2)) {
pc = code_base + Load32(pc + 4);
} else {
pc += 8;
}
- break;
- case BC_CHECK_REGISTER_GT:
- if (registers[pc[1]] > Load16(pc + 2)) {
- pc = code_base + Load32(pc + 4);
- } else {
- pc += 8;
- }
- break;
- case BC_CHECK_REGISTER_NE:
- if (registers[pc[1]] != Load16(pc + 2)) {
- pc = code_base + Load32(pc + 4);
- } else {
- pc += 8;
- }
- break;
- case BC_CHECK_BACKREF:
- case BC_CHECK_NOT_BACKREF:
- case BC_CHECK_BITMAP:
- case BC_CHECK_NOT_BITMAP:
+ BYTECODE(CHECK_BACKREF)
+ UNREACHABLE();
+ BYTECODE(CHECK_NOT_BACKREF)
+ UNREACHABLE();
+ BYTECODE(CHECK_BITMAP)
+ UNREACHABLE();
+ BYTECODE(CHECK_NOT_BITMAP)
+ UNREACHABLE();
+ break; // Last one doesn't have break in macro.
default:
UNREACHABLE();
break;
Copied: branches/experimental/regexp2000/src/regexp-macro-assembler-re2k.cc
(from r706, /branches/experimental/regexp2000/src/regexp-codegen-re2k.cc)
==============================================================================
--- /branches/experimental/regexp2000/src/regexp-codegen-re2k.cc
(original)
+++ branches/experimental/regexp2000/src/regexp-macro-assembler-re2k.cc Fri
Nov 7 04:00:59 2008
@@ -28,6 +28,7 @@
#include "v8.h"
#include "ast.h"
#include "bytecodes-re2k.h"
-#include "regexp-codegen.h"
+#include "regexp-macro-assembler.h"
+#include "regexp-macro-assembler-re2k.h"
Added: branches/experimental/regexp2000/src/regexp-macro-assembler-re2k.h
==============================================================================
--- (empty file)
+++ branches/experimental/regexp2000/src/regexp-macro-assembler-re2k.h Fri
Nov 7 04:00:59 2008
@@ -0,0 +1,35 @@
+// Copyright 2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following
+// disclaimer in the documentation and/or other materials provided
+// with the distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef V8_REGEXP_MACRO_ASSEMBLER_RE2K_H_
+#define V8_REGEXP_MACRO_ASSEMBLER_RE2K_H_
+
+namespace v8 { namespace internal {
+
+} } // namespace v8::internal
+
+#endif // V8_REGEXP_MACRO_ASSEMBLER_RE2K_H_
Copied: branches/experimental/regexp2000/src/regexp-macro-assembler.h (from
r707, /branches/experimental/regexp2000/src/regexp-codegen.h)
==============================================================================
--- /branches/experimental/regexp2000/src/regexp-codegen.h (original)
+++ branches/experimental/regexp2000/src/regexp-macro-assembler.h Fri Nov
7 04:00:59 2008
@@ -25,8 +25,8 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#ifndef V8_REGEXP_CODEGEN_H_
-#define V8_REGEXP_CODEGEN_H_
+#ifndef V8_REGEXP_MACRO_ASSEMBLER_H_
+#define V8_REGEXP_MACRO_ASSEMBLER_H_
namespace v8 { namespace internal {
@@ -63,16 +63,16 @@
template <typename SubjectChar>
-class RegexpCodeGenerator {
+class RegexpMacroAssembler {
public:
- RegexpCodeGenerator() { }
- virtual ~RegexpCodeGenerator() { }
+ RegexpMacroAssembler() { }
+ virtual ~RegexpMacroAssembler() { }
virtual void Bind(Label* label) = 0;
// Writes the current position in the subject string into the given
index of
// the captures array. The old value is pushed to the stack.
- virtual void WriteCaptureInfo(int index) = 0;
+ virtual void WriteCurrentPositionToRegister(int index) = 0;
// Pops the the given index of the capture array from the stack.
- virtual void PopCaptureInfo(int index) = 0;
+ virtual void PopRegister(int index) = 0;
// Pushes the current position in the subject string onto the stack for
later
// retrieval.
virtual void PushCurrentPosition() = 0;
@@ -112,4 +112,4 @@
} } // namespace v8::internal
-#endif // V8_REGEXP_CODEGEN_H_
+#endif // V8_REGEXP_MACRO_ASSEMBLER_H_
Modified: branches/experimental/regexp2000/test/cctest/test-regexp.cc
==============================================================================
--- branches/experimental/regexp2000/test/cctest/test-regexp.cc (original)
+++ branches/experimental/regexp2000/test/cctest/test-regexp.cc Fri Nov 7
04:00:59 2008
@@ -495,8 +495,8 @@
__ CheckChar('o', &advance);
__ LoadCurrentChar(2);
__ CheckChar('o', &advance);
- __ SetRegister(0);
- __ SetRegister(1, 2);
+ __ SetRegisterToCurrentPosition(0);
+ __ SetRegisterToCurrentPosition(1, 2);
__ Succeed();
v8::HandleScope scope;
@@ -517,4 +517,87 @@
CHECK(Re2kInterpreter::Match(*array, *f3, captures, 0));
CHECK_EQ(3, captures[0]);
CHECK_EQ(5, captures[1]);
+}
+
+
+TEST(Assembler2) {
+ V8::Initialize(NULL);
+ byte codes[1024];
+ Re2kAssembler assembler(Vector<byte>(codes, 1024));
+#define __ assembler.
+ // /^.*foo/
+ Label more_dots;
+ Label unwind_dot;
+ Label failure;
+ Label foo;
+ Label foo_failed;
+ Label dot_match;
+ // ^
+ __ PushCurrentPosition();
+ __ PushRegister(0);
+ __ SetRegisterToCurrentPosition(0);
+ __ PushBacktrack(&failure);
+ __ GoTo(&dot_match);
+ // .*
+ __ Bind(&more_dots);
+ __ AdvanceCP();
+ __ Bind(&dot_match);
+ __ PushCurrentPosition();
+ __ PushBacktrack(&unwind_dot);
+ __ LoadCurrentChar();
+ __ CheckNotEnd(&foo);
+ __ CheckChar('\n', &more_dots);
+ // foo
+ __ Bind(&foo);
+ __ CheckChar('f', &foo_failed);
+ __ LoadCurrentChar(1);
+ __ CheckChar('o', &foo_failed);
+ __ LoadCurrentChar(2);
+ __ CheckChar('o', &foo_failed);
+ __ SetRegisterToCurrentPosition(1, 2);
+ __ Succeed();
+ __ Break();
+
+ __ Bind(&foo_failed);
+ __ PopBacktrack();
+ __ Break();
+
+ __ Bind(&unwind_dot);
+ __ PopCurrentPosition();
+ __ LoadCurrentChar();
+ __ GoTo(&foo);
+
+ __ Bind(&failure);
+ __ PopRegister(0);
+ __ PopCurrentPosition();
+ __ Fail();
+
+ v8::HandleScope scope;
+ Handle<ByteArray> array = Factory::NewByteArray(assembler.length());
+ assembler.Copy(array->GetDataStartAddress());
+ int captures[2];
+
+ Handle<String> f1 =
+ Factory::NewStringFromAscii(CStrVector("Now is the time"));
+ CHECK(!Re2kInterpreter::Match(*array, *f1, captures, 0));
+
+ Handle<String> f2 = Factory::NewStringFromAscii(CStrVector("foo bar
baz"));
+ CHECK(Re2kInterpreter::Match(*array, *f2, captures, 0));
+ CHECK_EQ(0, captures[0]);
+ CHECK_EQ(2, captures[1]);
+
+ Handle<String> f3 =
Factory::NewStringFromAscii(CStrVector("tomfoolery"));
+ CHECK(Re2kInterpreter::Match(*array, *f3, captures, 0));
+ CHECK_EQ(0, captures[0]);
+ CHECK_EQ(5, captures[1]);
+
+ Handle<String> f4 =
+ Factory::NewStringFromAscii(CStrVector("football buffoonery"));
+ CHECK(Re2kInterpreter::Match(*array, *f4, captures, 0));
+ CHECK_EQ(0, captures[0]);
+ CHECK_EQ(14, captures[1]);
+
+ Handle<String> f5 =
+ Factory::NewStringFromAscii(CStrVector("walking\nbarefoot"));
+ CHECK(!Re2kInterpreter::Match(*array, *f5, captures, 0));
}
--~--~---------~--~----~------------~-------~--~----~
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
-~----------~----~----~----~------~----~------~--~---
