More automaton translation

src/parser.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 447 matching lines @@
   // on the input stream. After pushing it back, it becomes the character
   // returned by current(). There is a limited amount of push-back buffer.
   // A function using PushBack should check that it doesn't push back more
   // than kMaxPushback characters, and it should not push back more characters
   // than it has read.
   void PushBack(uc32 character);
   bool CanPushBack();
 
   bool HasCharacterEscapes();
 
+  int captures_started() { return captures_started_; }
+
   static const uc32 kEndMarker = unibrow::Utf8::kBadChar;
  private:
   uc32 current() { return current_; }
   uc32 next() { return next_; }
   bool has_more() { return has_more_; }
   bool has_next() { return has_next_; }
   unibrow::CharacterStream* in() { return in_; }
   uc32 current_;
   uc32 next_;
   bool has_more_;
@@ skipping 3661 matching lines @@
   PreParser parser(no_script, allow_natives_syntax, extension);
   if (!parser.PreParseProgram(stream)) return NULL;
   // The list owns the backing store so we need to clone the vector.
   // That way, the result will be exactly the right size rather than
   // the expected 50% too large.
   Vector<unsigned> store = parser.recorder()->store()->ToVector().Clone();
   return new ScriptDataImpl(store);
 }
 
 
-RegExpTree* ParseRegExp(unibrow::CharacterStream* stream,
-                        Handle<String>* error,
-                        bool* has_character_escapes) {
-  ASSERT(error->is_null());
-  RegExpParser parser(stream, error, false);  // Get multiline flag somehow
+bool ParseRegExp(unibrow::CharacterStream* stream, RegExpParseResult* result) {
+  ASSERT(result != NULL);
+  // Get multiline flag somehow
+  RegExpParser parser(stream, &result->error, false);
   bool ok = true;
-  RegExpTree* result = parser.ParsePattern(&ok);
+  result->tree = parser.ParsePattern(&ok);
   if (!ok) {
-    ASSERT(result == NULL);
-    ASSERT(!error->is_null());
+    ASSERT(result->tree == NULL);
+    ASSERT(!result->error.is_null());
   } else {
-    ASSERT(result != NULL);
-    ASSERT(error->is_null());
+    ASSERT(result->tree != NULL);
+    ASSERT(result->error.is_null());
   }
-  if (ok && has_character_escapes != NULL) {
-    *has_character_escapes = parser.HasCharacterEscapes();
+  if (ok) {
+    result->has_character_escapes = parser.HasCharacterEscapes();
+    result->capture_count = parser.captures_started();
   }
-  return result;
+  return ok;
 }
 
 
 FunctionLiteral* MakeAST(bool compile_in_global_context,
                          Handle<Script> script,
                          v8::Extension* extension,
                          ScriptDataImpl* pre_data) {
   bool allow_natives_syntax =
       always_allow_natives_syntax ||
       FLAG_allow_natives_syntax ||
@@ skipping 35 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal