More automaton translation

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 25 matching lines @@
 #include "parser.h"
 #include "ast.h"
 #include "jsregexp-inl.h"
 #include "assembler-re2k.h"
 #include "interpreter-re2k.h"
 
 
 using namespace v8::internal;
 
 
-class RegExpTestCase {
- public:
-  RegExpTestCase()
-    : pattern_(NULL),
-      flags_(NULL),
-      input_(NULL),
-      compile_error_(NULL) { }
-  RegExpTestCase(const char* pattern,
-                 const char* flags,
-                 const char* input,
-                 const char* compile_error)
-    : pattern_(pattern),
-      flags_(flags),
-      input_(input),
-      compile_error_(compile_error) { }
-  const char* pattern() const { return pattern_; }
-  bool expect_error() const { return compile_error_ != NULL; }
- private:
-  const char* pattern_;
-  const char* flags_;
-  const char* input_;
-  const char* compile_error_;
-};
-
-
 static SmartPointer<char> Parse(const char* input) {
   v8::HandleScope scope;
   unibrow::Utf8InputBuffer<> buffer(input, strlen(input));
   ZoneScope zone_scope(DELETE_ON_EXIT);
-  Handle<String> error;
-  RegExpTree* node = v8::internal::ParseRegExp(&buffer, &error, NULL);
-  CHECK(node != NULL);
-  CHECK(error.is_null());
-  SmartPointer<char> output = node->ToString();
+  RegExpParseResult result;
+  CHECK(v8::internal::ParseRegExp(&buffer, &result));
+  CHECK(result.tree != NULL);
+  CHECK(result.error.is_null());
+  SmartPointer<char> output = result.tree->ToString();
   return output;
 }
 
 static bool ParseEscapes(const char* input) {
   v8::HandleScope scope;
   unibrow::Utf8InputBuffer<> buffer(input, strlen(input));
   ZoneScope zone_scope(DELETE_ON_EXIT);
-  Handle<String> error;
-  bool has_escapes;
-  RegExpTree* node = v8::internal::ParseRegExp(&buffer, &error, &has_escapes);
-  CHECK(node != NULL);
-  CHECK(error.is_null());
-  return has_escapes;
+  RegExpParseResult result;
+  CHECK(v8::internal::ParseRegExp(&buffer, &result));
+  CHECK(result.tree != NULL);
+  CHECK(result.error.is_null());
+  return result.has_character_escapes;
 }
 
 
 #define CHECK_PARSE_EQ(input, expected) CHECK_EQ(expected, *Parse(input))
 #define CHECK_ESCAPES(input, has_escapes) CHECK_EQ(has_escapes, \
                                                    ParseEscapes(input));
 
 TEST(Parser) {
   V8::Initialize(NULL);
   CHECK_PARSE_EQ("abc", "'abc'");
@@ skipping 135 matching lines @@
   CHECK_ESCAPES("\\0", true);
   CHECK_ESCAPES("(a)\\1", false);
 }
 
 
 static void ExpectError(const char* input,
                         const char* expected) {
   v8::HandleScope scope;
   unibrow::Utf8InputBuffer<> buffer(input, strlen(input));
   ZoneScope zone_scope(DELETE_ON_EXIT);
-  Handle<String> error;
-  RegExpTree* node = v8::internal::ParseRegExp(&buffer, &error, NULL);
-  CHECK(node == NULL);
-  CHECK(!error.is_null());
-  SmartPointer<char> str = error->ToCString(ALLOW_NULLS);
+  RegExpParseResult result;
+  CHECK_EQ(false, v8::internal::ParseRegExp(&buffer, &result));
+  CHECK(result.tree == NULL);
+  CHECK(!result.error.is_null());
+  SmartPointer<char> str = result.error->ToCString(ALLOW_NULLS);
   CHECK_EQ(expected, *str);
 }
 
 
 TEST(Errors) {
   V8::Initialize(NULL);
   const char* kEndBackslash = "\\ at end of pattern";
   ExpectError("\\", kEndBackslash);
   const char* kInvalidQuantifier = "Invalid quantifier";
   ExpectError("a{}", kInvalidQuantifier);
@@ skipping 80 matching lines @@
   TestCharacterClassEscapes('.', Dot);
   TestCharacterClassEscapes('d', IsDigit);
   TestCharacterClassEscapes('D', NotDigit);
   TestCharacterClassEscapes('s', IsWhiteSpace);
   TestCharacterClassEscapes('S', NotWhiteSpace);
   TestCharacterClassEscapes('w', IsWord);
   TestCharacterClassEscapes('W', NotWord);
 }
 
 
-static void Execute(bool expected, const char* input, const char* str) {
+static void Execute(const char* input,
+                    const char* str,
+                    bool dot_output = false) {
   v8::HandleScope scope;
   unibrow::Utf8InputBuffer<> buffer(input, strlen(input));
   ZoneScope zone_scope(DELETE_ON_EXIT);
-  Handle<String> error;
-  RegExpTree* tree = v8::internal::ParseRegExp(&buffer, &error, NULL);
-  CHECK(tree != NULL);
-  CHECK(error.is_null());
-  RegExpNode<const char>* node = RegExpEngine::Compile<const char>(tree);
-  bool outcome = RegExpEngine::Execute(node, CStrVector(str));
-  CHECK_EQ(outcome, expected);
+  RegExpParseResult result;
+  if (!v8::internal::ParseRegExp(&buffer, &result))
+    return;
+  RegExpNode* node = RegExpEngine::Compile(&result);
+  if (dot_output) {
+    RegExpEngine::DotPrint(input, node);
+    exit(0);
+  }
 }
 
 
 TEST(Execution) {
   V8::Initialize(NULL);
-  Execute(true, ".*?(?:a[bc]d|e[fg]h)", "xxxabbegh");
-  Execute(true, ".*?(?:a[bc]d|e[fg]h)", "xxxabbefh");
-  Execute(false, ".*?(?:a[bc]d|e[fg]h)", "xxxabbefd");
+  Execute(".*?(?:a[bc]d|e[fg]h)", "xxxabbegh");
+  Execute(".*?(?:a[bc]d|e[fg]h)", "xxxabbefh");
+  Execute(".*?(?:a[bc]d|e[fg]h)", "xxxabbefd");
 }
 
 
 class TestConfig {
  public:
   typedef int Key;
   typedef int Value;
   static const int kNoKey;
   static const int kNoValue;
   static inline int Compare(int a, int b) {
@@ skipping 113 matching lines @@
       for (int k = 0; !is_on && (k < 2 * kRangeSize); k += 2)
         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));
 #define __ assembler.
   Label advance;
   Label look_for_foo;
   __ GoTo(&look_for_foo);
   __ Bind(&advance);
   __ AdvanceCP();
   __ Bind(&look_for_foo);
   __ FailIfWithin(3);
@@ skipping 18 matching lines @@
   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(3, captures[0]);
   CHECK_EQ(5, captures[1]);
 }
-
-
-