* Rename to Irregexp throughout....

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 18 matching lines @@
 #include <stdlib.h>
 #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 "assembler-irregexp.h"
 #include "regexp-macro-assembler.h"
-#include "regexp-macro-assembler-re2k.h"
+#include "regexp-macro-assembler-irregexp.h"
 #include "regexp-macro-assembler-ia32.h"
-#include "interpreter-re2k.h"
+#include "interpreter-irregexp.h"
 
 
 using namespace v8::internal;
 
 
 static SmartPointer<const char> Parse(const char* input) {
   v8::HandleScope scope;
   ZoneScope zone_scope(DELETE_ON_EXIT);
   FlatStringReader reader(CStrVector(input));
   RegExpParseResult result;
@@ skipping 464 matching lines @@
         is_on = (range[k] <= p && p <= range[k + 1]);
       CHECK_EQ(is_on, outs->Get(j));
     }
   }
 }
 
 
 TEST(Assembler) {
   V8::Initialize(NULL);
   byte codes[1024];
-  Re2kAssembler assembler(Vector<byte>(codes, 1024));
+  IrregexpAssembler assembler(Vector<byte>(codes, 1024));
 #define __ assembler.
   Label advance;
   Label look_for_foo;
   Label fail;
   __ GoTo(&look_for_foo);
   __ Bind(&advance);
   __ AdvanceCP(1);
   __ Bind(&look_for_foo);
   __ LoadCurrentChar(0, &fail);
   __ CheckNotCharacter('f', &advance);
   __ LoadCurrentChar(1, &fail);
   __ CheckNotCharacter('o', &advance);
   __ LoadCurrentChar(2, &fail);
   __ CheckNotCharacter('o', &advance);
   __ WriteCurrentPositionToRegister(0);
   __ WriteCurrentPositionToRegister(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"));
   Handle<String> f1_16 = RegExpImpl::StringToTwoByte(f1);
-  CHECK(!Re2kInterpreter::Match(array, f1_16, captures, 0));
+  CHECK(!IrregexpInterpreter::Match(array, f1_16, captures, 0));
 
   Handle<String> f2 = Factory::NewStringFromAscii(CStrVector("foo bar baz"));
   Handle<String> f2_16 = RegExpImpl::StringToTwoByte(f2);
-  CHECK(Re2kInterpreter::Match(array, f2_16, captures, 0));
+  CHECK(IrregexpInterpreter::Match(array, f2_16, captures, 0));
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(2, captures[1]);
 
   Handle<String> f3 = Factory::NewStringFromAscii(CStrVector("tomfoolery"));
   Handle<String> f3_16 = RegExpImpl::StringToTwoByte(f3);
-  CHECK(Re2kInterpreter::Match(array, f3_16, captures, 0));
+  CHECK(IrregexpInterpreter::Match(array, f3_16, 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));
+  IrregexpAssembler 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();
@@ skipping 35 matching lines @@
   __ 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"));
   Handle<String> f1_16 = RegExpImpl::StringToTwoByte(f1);
-  CHECK(!Re2kInterpreter::Match(array, f1_16, captures, 0));
+  CHECK(!IrregexpInterpreter::Match(array, f1_16, captures, 0));
 
   Handle<String> f2 = Factory::NewStringFromAscii(CStrVector("foo bar baz"));
   Handle<String> f2_16 = RegExpImpl::StringToTwoByte(f2);
-  CHECK(Re2kInterpreter::Match(array, f2_16, captures, 0));
+  CHECK(IrregexpInterpreter::Match(array, f2_16, captures, 0));
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(2, captures[1]);
 
   Handle<String> f3 = Factory::NewStringFromAscii(CStrVector("tomfoolery"));
   Handle<String> f3_16 = RegExpImpl::StringToTwoByte(f3);
-  CHECK(Re2kInterpreter::Match(array, f3_16, captures, 0));
+  CHECK(IrregexpInterpreter::Match(array, f3_16, captures, 0));
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(5, captures[1]);
 
   Handle<String> f4 =
       Factory::NewStringFromAscii(CStrVector("football buffoonery"));
   Handle<String> f4_16 = RegExpImpl::StringToTwoByte(f4);
-  CHECK(Re2kInterpreter::Match(array, f4_16, captures, 0));
+  CHECK(IrregexpInterpreter::Match(array, f4_16, captures, 0));
   CHECK_EQ(0, captures[0]);
   CHECK_EQ(14, captures[1]);
 
   Handle<String> f5 =
       Factory::NewStringFromAscii(CStrVector("walking\nbarefoot"));
   Handle<String> f5_16 = RegExpImpl::StringToTwoByte(f5);
-  CHECK(!Re2kInterpreter::Match(array, f5_16, captures, 0));
+  CHECK(!IrregexpInterpreter::Match(array, f5_16, captures, 0));
 }
 
 
 TEST(MacroAssembler) {
   V8::Initialize(NULL);
   byte codes[1024];
-  Re2kAssembler assembler(Vector<byte>(codes, 1024));
-  RegExpMacroAssemblerRe2k m(&assembler);
+  IrregexpAssembler assembler(Vector<byte>(codes, 1024));
+  RegExpMacroAssemblerIrregexp 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);
@@ skipping 23 matching lines @@
 
   v8::HandleScope scope;
 
   Handle<ByteArray> array = Factory::NewByteArray(assembler.length());
   assembler.Copy(array->GetDataStartAddress());
   int captures[5];
 
   Handle<String> f1 =
       Factory::NewStringFromAscii(CStrVector("foobar"));
   Handle<String> f1_16 = RegExpImpl::StringToTwoByte(f1);
-  CHECK(Re2kInterpreter::Match(array, f1_16, captures, 0));
+  CHECK(IrregexpInterpreter::Match(array, f1_16, 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"));
   Handle<String> f2_16 = RegExpImpl::StringToTwoByte(f2);
-  CHECK(!Re2kInterpreter::Match(array, f2_16, captures, 0));
+  CHECK(!IrregexpInterpreter::Match(array, f2_16, captures, 0));
   CHECK_EQ(42, captures[0]);
 }
 
 
 TEST(AddInverseToTable) {
   static const int kLimit = 1000;
   static const int kRangeCount = 16;
   for (int t = 0; t < 10; t++) {
     ZoneScope zone_scope(DELETE_ON_EXIT);
     ZoneList<CharacterRange>* ranges =
@@ skipping 190 matching lines @@
   // whole block at a time.
   TestSimpleRangeCaseIndependence(CharacterRange('A', 'k'),
                                   CharacterRange('a', 'z'));
 }
 
 
 TEST(Graph) {
   V8::Initialize(NULL);
   Execute("(x)?\\1y", "", true);
 }