Rename codegen to macro-assembler....

src/assembler-re2k.cc

 // 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
@@ skipping 13 matching lines @@
 // 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.
 
 // A light-weight assembler for the Regexp2000 byte code.
 
 
 #include "v8.h"
 #include "ast.h"
 #include "bytecodes-re2k.h"
-#include "regexp-codegen.h"
 #include "assembler-re2k.h"
 
 #include "assembler-re2k-inl.h"
 
 
 namespace v8 { namespace internal {
 
 
 Re2kAssembler::Re2kAssembler(Vector<byte> buffer)
   : buffer_(buffer),
@@ skipping 19 matching lines @@
 }
 
 
 void Re2kAssembler::PushRegister(int index) {
   ASSERT(index >= 0);
   Emit(BC_PUSH_REGISTER);
   Emit(index);
 }
 
 
-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_TO_CP);
+  Emit(index);
+  Emit32(cp_offset);
+}
+
+
+void Re2kAssembler::SetRegister(int index, int value) {
+  ASSERT(index >= 0);
   Emit(BC_SET_REGISTER);
   Emit(index);
-  Emit32(cp_offset);
+  Emit32(value);
 }
 
 
 void Re2kAssembler::PopCurrentPosition() {
   Emit(BC_POP_CP);
 }
 
 
 void Re2kAssembler::PopBacktrack() {
   Emit(BC_POP_BT);
 }
 
 
 void Re2kAssembler::PopRegister(int index) {
   Emit(BC_POP_REGISTER);
   Emit(index);
 }
 
 
 void Re2kAssembler::Fail() {
   Emit(BC_FAIL);
 }
 
 
+void Re2kAssembler::Break() {
+  Emit(BC_BREAK);
+}
+
+
 void Re2kAssembler::FailIfWithin(int distance_from_end) {
   Emit(BC_FAIL_IF_WITHIN);
   Emit32(distance_from_end);
 }
 
 
 void Re2kAssembler::Succeed() {
   Emit(BC_SUCCEED);
 }
 
@@ skipping 37 matching lines @@
 }
 
 
 void Re2kAssembler::CheckNotChar(uc16 c, Label* on_match) {
   Emit(BC_CHECK_NOT_CHAR);
   Emit16(c);
   EmitOrLink(on_match);
 }
 
 
+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);
   Emit16(end);
   EmitOrLink(on_mismatch);
 }
 
 
 void Re2kAssembler::CheckNotRange(uc16 start, uc16 end, Label* on_match) {
   Emit(BC_CHECK_NOT_RANGE);
@@ skipping 27 matching lines @@
                                   int reg_index,
                                   uint16_t vs,
                                   Label* on_true) {
   Emit(byte_code);
   Emit(reg_index);
   Emit16(vs);
   EmitOrLink(on_true);
 }
 
 
-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) {
   CheckRegister(BC_CHECK_REGISTER_LT, reg_index, vs, on_less_than);
 }
 
 
 void Re2kAssembler::CheckRegisterGe(int reg_index,
                                     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);
-}
-
-
 int Re2kAssembler::length() {
   return pc_;
 }
 
 
 void Re2kAssembler::Copy(Address a) {
   memcpy(a, buffer_.start(), length());
 }
 
 } }  // namespace v8::internal