Integrate the Irregexp Regular Expression Engine.

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
 #include "vm/native_arguments.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
+#include "vm/regexp_assembler.h"
 #include "vm/report.h"
 #include "vm/resolver.h"
 #include "vm/scanner.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/timer.h"
 #include "vm/zone.h"
 
@@ skipping 104 matching lines @@
 }
 
 
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
 }
 
 
+void ParsedFunction::SetRegExpCompileData(
+    RegExpCompileData* regexp_compile_data) {
+  ASSERT(regexp_compile_data_ == NULL);
+  ASSERT(regexp_compile_data != NULL);
+  regexp_compile_data_ = regexp_compile_data;
+}
+
+
 void ParsedFunction::AddDeferredPrefix(const LibraryPrefix& prefix) {
   ASSERT(prefix.is_deferred_load());
   ASSERT(!prefix.is_loaded());
   for (intptr_t i = 0; i < deferred_prefixes_->length(); i++) {
     if ((*deferred_prefixes_)[i]->raw() == prefix.raw()) {
       return;
     }
   }
   deferred_prefixes_->Add(&LibraryPrefix::ZoneHandle(I, prefix.raw()));
 }
 
 
 void ParsedFunction::AllocateVariables() {
+  ASSERT(!function().IsIrregexpFunction());
   LocalScope* scope = node_sequence()->scope();
   const intptr_t num_fixed_params = function().num_fixed_parameters();
   const intptr_t num_opt_params = function().NumOptionalParameters();
   const intptr_t num_params = num_fixed_params + num_opt_params;
   // Compute start indices to parameters and locals, and the number of
   // parameters to copy.
   if (num_opt_params == 0) {
     // Parameter i will be at fp[kParamEndSlotFromFp + num_params - i] and
     // local variable j will be at fp[kFirstLocalSlotFromFp - j].
     first_parameter_index_ = kParamEndSlotFromFp + num_params;
@@ skipping 28 matching lines @@
 struct CatchParamDesc {
   CatchParamDesc()
       : token_pos(0), type(NULL), name(NULL), var(NULL) { }
   intptr_t token_pos;
   const AbstractType* type;
   const String* name;
   LocalVariable* var;
 };
 
 
+void ParsedFunction::AllocateIrregexpVariables(intptr_t num_stack_locals) {
+  ASSERT(function().IsIrregexpFunction());
+  ASSERT(function().NumOptionalParameters() == 0);
+  const intptr_t num_params = function().num_fixed_parameters();
+  ASSERT(num_params == RegExpMacroAssembler::kParamCount);
+  // Compute start indices to parameters and locals, and the number of
+  // parameters to copy.
+  // Parameter i will be at fp[kParamEndSlotFromFp + num_params - i] and
+  // local variable j will be at fp[kFirstLocalSlotFromFp - j].
+  first_parameter_index_ = kParamEndSlotFromFp + num_params;
+  first_stack_local_index_ = kFirstLocalSlotFromFp;
+  num_copied_params_ = 0;
+
+  // Frame indices are relative to the frame pointer and are decreasing.
+  num_stack_locals_ = num_stack_locals;
+}
+
+
 struct Parser::Block : public ZoneAllocated {
   Block(Block* outer_block, LocalScope* local_scope, SequenceNode* seq)
     : parent(outer_block), scope(local_scope), statements(seq) {
     ASSERT(scope != NULL);
     ASSERT(statements != NULL);
   }
   Block* parent;  // Enclosing block, or NULL if outermost.
   LocalScope* scope;
   SequenceNode* statements;
 };
@@ skipping 600 matching lines @@
       node_sequence = parser.ParseMethodExtractor(func);
       break;
     case RawFunction::kNoSuchMethodDispatcher:
       node_sequence =
           parser.ParseNoSuchMethodDispatcher(func, &default_parameter_values);
       break;
     case RawFunction::kInvokeFieldDispatcher:
       node_sequence =
           parser.ParseInvokeFieldDispatcher(func, &default_parameter_values);
       break;
+    case RawFunction::kIrregexpFunction:
+      UNREACHABLE();  // Irregexp functions have their own parser.
     default:
       UNREACHABLE();
   }
 
   if (!HasReturnNode(node_sequence)) {
     // Add implicit return node.
     node_sequence->Add(new ReturnNode(func.end_token_pos()));
   }
   if (parsed_function->has_expression_temp_var()) {
     node_sequence->scope()->AddVariable(parsed_function->expression_temp_var());
@@ skipping 11050 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart