Support allocating and calling closures in the new non-optimizing compiler.

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 94 matching lines @@
   UnhandledException& excp = UnhandledException::Handle();
   excp ^= obj.raw();
   const Instance& exception = Instance::ZoneHandle(excp.exception());
   const Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
+void ParsedFunction::AllocateVariables() {
+  LocalScope* scope = node_sequence()->scope();
+  const int fixed_parameter_count = function().num_fixed_parameters();
+  const int optional_parameter_count = function().num_optional_parameters();
+  const int parameter_count = fixed_parameter_count + optional_parameter_count;
+  // Compute start indices to parameters and locals, and the number of
+  // parameters to copy.
+  if (optional_parameter_count == 0) {
+    // Parameter i will be at fp[1 + parameter_count - i] and local variable
+    // j will be at fp[-1 - j].
+    first_parameter_index_ = 1 + parameter_count;
+    first_stack_local_index_ = -1;
+    copied_parameter_count_ = 0;
+  } else {
+    // Parameter i will be at fp[-1 - i] and local variable j will be at
+    // fp[-1 - parameter_count - j].
+    first_parameter_index_ = -1;
+    first_stack_local_index_ = -1 - parameter_count;
+    copied_parameter_count_ = parameter_count;
+  }
+
+  // Allocate parameters and local variables, either in the local frame or
+  // in the context(s).
+  LocalScope* context_owner = NULL;  // No context needed yet.
+  int next_free_frame_index =
+      scope->AllocateVariables(first_parameter_index_,
+                               parameter_count,
+                               first_stack_local_index_,
+                               scope,
+                               &context_owner);
+  // Frame indices are relative to the frame pointer and are decreasing.
+  ASSERT(next_free_frame_index <= first_stack_local_index_);
+  stack_local_count_ = first_stack_local_index_ - next_free_frame_index;
+}
+
+
 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 8042 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart