* Add support for positive lookahead assertions and negative...

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 55 matching lines @@
 }
 
 
 void Re2kAssembler::PushRegister(int index) {
   ASSERT(index >= 0);
   Emit(BC_PUSH_REGISTER);
   Emit(index);
 }
 
 
-void Re2kAssembler::SetRegisterToCurrentPosition(int index, int cp_offset) {
+void Re2kAssembler::WriteCurrentPositionToRegister(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::SetCurrentPositionFromRegister(int index) {

[Lasse Reichstein, 2008/11/20 10:32:11]

You have "Write..To" but "Set..From". Wouldn't it be more nicely symmetric if it
was "Read...From"?

[Erik Corry, 2008/11/20 11:37:34]

Done

+  ASSERT(index >= 0);
+  Emit(BC_SET_CP_TO_REGISTER);
+  Emit(index);
+}
+
+
+void Re2kAssembler::WriteStackPointerToRegister(int index) {
+  ASSERT(index >= 0);
+  Emit(BC_SET_REGISTER_TO_SP);
+  Emit(index);
+}
+
+
+void Re2kAssembler::SetStackPointerFromRegister(int index) {
+  ASSERT(index >= 0);
+  Emit(BC_SET_SP_TO_REGISTER);
+  Emit(index);
+}
+
+
 void Re2kAssembler::SetRegister(int index, int value) {
   ASSERT(index >= 0);
   Emit(BC_SET_REGISTER);
   Emit(index);
   Emit32(value);
 }
 
 
 void Re2kAssembler::AdvanceRegister(int index, int by) {
   ASSERT(index >= 0);
@@ skipping 60 matching lines @@
 }
 
 
 void Re2kAssembler::LoadCurrentChar(int cp_offset, Label* on_end) {
   Emit(BC_LOAD_CURRENT_CHAR);
   Emit32(cp_offset);
   EmitOrLink(on_end);
 }
 
 
-void Re2kAssembler::CheckChar(uc16 c, Label* on_mismatch) {
+void Re2kAssembler::CheckCharacter(uc16 c, Label* on_match) {
   Emit(BC_CHECK_CHAR);
   Emit16(c);
+  EmitOrLink(on_match);
+}
+
+
+void Re2kAssembler::CheckNotCharacter(uc16 c, Label* on_mismatch) {
+  Emit(BC_CHECK_NOT_CHAR);
+  Emit16(c);
   EmitOrLink(on_mismatch);
 }
 
 
-void Re2kAssembler::CheckNotChar(uc16 c, Label* on_match) {
-  Emit(BC_CHECK_NOT_CHAR);
-  Emit16(c);
-  EmitOrLink(on_match);
-}
-
-
 void Re2kAssembler::CheckCharacterLT(uc16 limit, Label* on_less) {
   Emit(BC_CHECK_LT);
   Emit16(limit);
   EmitOrLink(on_less);
 }
 
 
 void Re2kAssembler::CheckCharacterGT(uc16 limit, Label* on_greater) {
   Emit(BC_CHECK_GT);
   Emit16(limit);
@@ skipping 101 matching lines @@
   buffer_ = Vector<byte>::New(old_buffer.length() * 2);
   own_buffer_ = true;
   memcpy(buffer_.start(), old_buffer.start(), old_buffer.length());
   if (old_buffer_was_our_own) {
     old_buffer.Dispose();
   }
 }
 
 
 } }  // namespace v8::internal