* We want to be able to find atoms and character classes without advancing th...

test/cctest/test-regexp.cc

 // Copyright 2006-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 19 matching lines @@
 #include <set>
 
 #include "v8.h"
 
 #include "cctest.h"
 #include "zone-inl.h"
 #include "parser.h"
 #include "ast.h"
 #include "jsregexp-inl.h"
 #include "assembler-re2k.h"
+#include "regexp-macro-assembler.h"
+#include "regexp-macro-assembler-re2k.h"
 #include "interpreter-re2k.h"
 
 
 using namespace v8::internal;
 
 
 static SmartPointer<char> Parse(const char* input) {
   v8::HandleScope scope;
   unibrow::Utf8InputBuffer<> buffer(input, strlen(input));
   ZoneScope zone_scope(DELETE_ON_EXIT);
@@ skipping 286 matching lines @@
   RegExpParseResult result;
   if (!v8::internal::ParseRegExp(&buffer, &result))
     return;
   RegExpNode* node = RegExpEngine::Compile(&result);
   USE(node);
 #ifdef DEBUG
   if (dot_output) {
     RegExpEngine::DotPrint(input, node);
     exit(0);
   }
-#endif // DEBUG
+#endif  // DEBUG
 }
 
 
 TEST(Execution) {
   V8::Initialize(NULL);
   // Execute(".*?(?:a[bc]d|e[fg]h)", "xxxabbegh");
   // Execute(".*?(?:a[bc]d|e[fg]h)", "xxxabbefh");
   // Execute(".*?(?:a[bc]d|e[fg]h)", "xxxabbefd");
 }
 
@@ skipping 126 matching lines @@
 }
 
 
 TEST(Assembler) {
   V8::Initialize(NULL);
   byte codes[1024];
   Re2kAssembler assembler(Vector<byte>(codes, 1024));
 #define __ assembler.
   Label advance;
   Label look_for_foo;
+  Label fail;
   __ GoTo(&look_for_foo);
   __ Bind(&advance);
-  __ AdvanceCP();
+  __ AdvanceCP(1);
   __ Bind(&look_for_foo);
-  __ FailIfWithin(3);
-  __ LoadCurrentChar(0);
+  __ LoadCurrentChar(0, &fail);
   __ CheckChar('f', &advance);
-  __ LoadCurrentChar(1);
+  __ LoadCurrentChar(1, &fail);
   __ CheckChar('o', &advance);
-  __ LoadCurrentChar(2);
+  __ LoadCurrentChar(2, &fail);
   __ CheckChar('o', &advance);
   __ SetRegisterToCurrentPosition(0);
   __ SetRegisterToCurrentPosition(1, 2);
   __ Succeed();
+  __ Bind(&fail);
+  __ 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));
+  CHECK(!Re2kInterpreter::Match(array, f1, captures, 0));
 
   Handle<String> f2 = Factory::NewStringFromAscii(CStrVector("foo bar baz"));
-  CHECK(Re2kInterpreter::Match(*array, *f2, captures, 0));
+  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(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();
+  __ AdvanceCP(1);
   __ Bind(&dot_match);
   __ PushCurrentPosition();
   __ PushBacktrack(&unwind_dot);
-  __ LoadCurrentChar();
-  __ CheckNotEnd(&foo);
+  __ LoadCurrentChar(0, &foo);
   __ CheckChar('\n', &more_dots);
   // foo
   __ Bind(&foo);
   __ CheckChar('f', &foo_failed);
-  __ LoadCurrentChar(1);
+  __ LoadCurrentChar(1, &foo_failed);
   __ CheckChar('o', &foo_failed);
-  __ LoadCurrentChar(2);
+  __ LoadCurrentChar(2, &foo_failed);
   __ CheckChar('o', &foo_failed);
   __ SetRegisterToCurrentPosition(1, 2);
   __ Succeed();
   __ Break();
 
   __ Bind(&foo_failed);
   __ PopBacktrack();
   __ Break();
 
   __ Bind(&unwind_dot);
   __ PopCurrentPosition();
-  __ LoadCurrentChar();
+  __ LoadCurrentChar(0, &foo_failed);
   __ 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));
+  CHECK(!Re2kInterpreter::Match(array, f1, captures, 0));
 
   Handle<String> f2 = Factory::NewStringFromAscii(CStrVector("foo bar baz"));
-  CHECK(Re2kInterpreter::Match(*array, *f2, captures, 0));
+  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(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(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));
+  CHECK(!Re2kInterpreter::Match(array, f5, captures, 0));
+}
+
+
+TEST(MacroAssembler) {
+  V8::Initialize(NULL);
+  byte codes[1024];
+  Re2kAssembler assembler(Vector<byte>(codes, 1024));
+  RegExpMacroAssemblerRe2k m(&assembler);
+  // ^f(o)o.
+  Label fail, fail2, start;
+  uc16 foo_chars[3];
+  foo_chars[0] = 'f';
+  foo_chars[1] = 'o';
+  foo_chars[2] = 'o';
+  Vector<const uc16> foo(foo_chars, 3);
+  m.SetRegister(4, 42);
+  m.PushRegister(4);
+  m.AdvanceRegister(4, 42);
+  m.GoTo(&start);
+  m.Fail();
+  m.Bind(&start);
+  m.PushBacktrack(&fail2);
+  m.CheckCharacters(foo, 0, &fail);
+  m.WriteCurrentPositionToRegister(0);
+  m.PushCurrentPosition();
+  m.AdvanceCurrentPosition(3);
+  m.WriteCurrentPositionToRegister(1);
+  m.PopCurrentPosition();
+  m.AdvanceCurrentPosition(1);
+  m.WriteCurrentPositionToRegister(2);
+  m.AdvanceCurrentPosition(1);
+  m.WriteCurrentPositionToRegister(3);
+  m.Succeed();
+
+  m.Bind(&fail);
+  m.Backtrack();
+  m.Succeed();
+
+  m.Bind(&fail2);
+  m.PopRegister(0);
+  m.Fail();
+
+  v8::HandleScope scope;
+
+  Handle<ByteArray> array = Factory::NewByteArray(assembler.length());
+  assembler.Copy(array->GetDataStartAddress());
+  int captures[5];
+
+  Handle<String> f1 =
+      Factory::NewStringFromAscii(CStrVector("foobar"));
+  CHECK(Re2kInterpreter::Match(array, f1, captures, 0));
+  CHECK_EQ(0, captures[0]);
+  CHECK_EQ(3, captures[1]);
+  CHECK_EQ(1, captures[2]);
+  CHECK_EQ(2, captures[3]);
+  CHECK_EQ(84, captures[4]);
+
+  Handle<String> f2 =
+      Factory::NewStringFromAscii(CStrVector("barfoo"));
+  CHECK(!Re2kInterpreter::Match(array, f2, captures, 0));
+  CHECK_EQ(42, captures[0]);
 }
 
 
 TEST(AddInverseToTable) {
   static const int kLimit = 1000;
   static const int kRangeCount = 16;
   ZoneScope zone_scope(DELETE_ON_EXIT);
   ZoneList<CharacterRange>* range = new ZoneList<CharacterRange>(kRangeCount);
   for (int i = 0; i < kRangeCount; i++) {
     int from = PseudoRandom(87, i + 25) % kLimit;
     int to = PseudoRandom(i + 87, 25) % (kLimit / 20);
     if (to > kLimit) to = kLimit;
     range->Add(CharacterRange(from, to));
   }
   DispatchTable table;
   // CharacterClassNode::AddInverseToTable(range, &table, 0);
 }
 
 
 TEST(Graph) {
   Execute("([^a]|\\w)", "", true);
 }