clang-format runtime/vm

runtime/vm/scopes.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/scopes.h"
 
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, share_enclosing_context, true,
+DEFINE_FLAG(bool,
+            share_enclosing_context,
+            true,
             "Allocate captured variables in the existing context of an "
             "enclosing scope (up to innermost loop) and spare the allocation "
             "of a local context.");
 
 int SourceLabel::FunctionLevel() const {
   ASSERT(owner() != NULL);
   return owner()->function_level();
 }
 
 
@@ skipping 170 matching lines @@
                                   int num_parameters,
                                   int first_frame_index,
                                   LocalScope* context_owner,
                                   bool* found_captured_variables) {
   // We should not allocate variables of nested functions while compiling an
   // enclosing function.
   ASSERT(function_level() == 0);
   ASSERT(num_parameters >= 0);
   // Parameters must be listed first and must all appear in the top scope.
   ASSERT(num_parameters <= num_variables());
-  int pos = 0;  // Current variable position.
+  int pos = 0;                              // Current variable position.
   int frame_index = first_parameter_index;  // Current free frame index.
   while (pos < num_parameters) {
     LocalVariable* parameter = VariableAt(pos);
     pos++;
     // Parsing formal parameter default values may add local variable aliases
     // to the local scope before the formal parameters are added. However,
     // the parameters get inserted in front of the aliases, therefore, no
     // aliases can be encountered among the first num_parameters variables.
     ASSERT(parameter->owner() == this);
     if (parameter->is_captured()) {
@@ skipping 19 matching lines @@
         *found_captured_variables = true;
       } else {
         variable->set_index(frame_index--);
       }
     }
   }
   // Allocate variables of all children.
   int min_frame_index = frame_index;  // Frame index decreases with allocations.
   LocalScope* child = this->child();
   while (child != NULL) {
-    int const dummy_parameter_index = 0;  // Ignored, since no parameters.
+    int const dummy_parameter_index = 0;    // Ignored, since no parameters.
     int const num_parameters_in_child = 0;  // No parameters in children scopes.
-    int child_frame_index = child->AllocateVariables(dummy_parameter_index,
-                                                     num_parameters_in_child,
-                                                     frame_index,
-                                                     context_owner,
-                                                     found_captured_variables);
+    int child_frame_index = child->AllocateVariables(
+        dummy_parameter_index, num_parameters_in_child, frame_index,
+        context_owner, found_captured_variables);
     if (child_frame_index < min_frame_index) {
       min_frame_index = child_frame_index;
     }
     child = child->sibling();
   }
   return min_frame_index;
 }
 
 
 // The parser creates internal variables that start with ":"
@@ skipping 194 matching lines @@
 SourceLabel* LocalScope::LookupInnermostLabel(Token::Kind jump_kind) {
   ASSERT((jump_kind == Token::kCONTINUE) || (jump_kind == Token::kBREAK));
   LocalScope* current_scope = this;
   while (current_scope != NULL) {
     for (intptr_t i = 0; i < current_scope->labels_.length(); i++) {
       SourceLabel* label = current_scope->labels_[i];
       if ((label->kind() == SourceLabel::kWhile) ||
           (label->kind() == SourceLabel::kFor) ||
           (label->kind() == SourceLabel::kDoWhile) ||
           ((jump_kind == Token::kBREAK) &&
-              (label->kind() == SourceLabel::kSwitch))) {
+           (label->kind() == SourceLabel::kSwitch))) {
         return label;
       }
     }
     current_scope = current_scope->parent();
   }
   return NULL;
 }
 
 
 LocalScope* LocalScope::LookupSwitchScope() {
@@ skipping 50 matching lines @@
     if (variable->owner()->function_level() != 1) {
       ASSERT(variable->is_captured());
       ASSERT(variable->owner()->function_level() == 0);
       num_captured++;
     }
   }
   return num_captured;
 }
 
 
-RawContextScope* LocalScope::PreserveOuterScope(int current_context_level)
-    const {
+RawContextScope* LocalScope::PreserveOuterScope(
+    int current_context_level) const {
   // Since code generation for nested functions is postponed until first
   // invocation, the function level of the closure scope can only be 1.
   ASSERT(function_level() == 1);
 
   // Count the number of referenced captured variables.
   intptr_t num_captured_vars = NumCapturedVariables();
 
   // Create a ContextScope with space for num_captured_vars descriptors.
   const ContextScope& context_scope =
       ContextScope::Handle(ContextScope::New(num_captured_vars, false));
@@ skipping 32 matching lines @@
 
 
 LocalScope* LocalScope::RestoreOuterScope(const ContextScope& context_scope) {
   // The function level of the outer scope is one less than the function level
   // of the current function, which is 0.
   LocalScope* outer_scope = new LocalScope(NULL, -1, 0);
   // Add all variables as aliases to the outer scope.
   for (int i = 0; i < context_scope.num_variables(); i++) {
     LocalVariable* variable;
     if (context_scope.IsConstAt(i)) {
-      variable = new LocalVariable(
-          context_scope.DeclarationTokenIndexAt(i),
-          context_scope.TokenIndexAt(i),
-          String::ZoneHandle(context_scope.NameAt(i)),
-          Object::dynamic_type());
+      variable = new LocalVariable(context_scope.DeclarationTokenIndexAt(i),
+                                   context_scope.TokenIndexAt(i),
+                                   String::ZoneHandle(context_scope.NameAt(i)),
+                                   Object::dynamic_type());
       variable->SetConstValue(
           Instance::ZoneHandle(context_scope.ConstValueAt(i)));
     } else {
-      variable = new LocalVariable(
-          context_scope.DeclarationTokenIndexAt(i),
-          context_scope.TokenIndexAt(i),
-          String::ZoneHandle(context_scope.NameAt(i)),
-          AbstractType::ZoneHandle(context_scope.TypeAt(i)));
+      variable =
+          new LocalVariable(context_scope.DeclarationTokenIndexAt(i),
+                            context_scope.TokenIndexAt(i),
+                            String::ZoneHandle(context_scope.NameAt(i)),
+                            AbstractType::ZoneHandle(context_scope.TypeAt(i)));
     }
     variable->set_is_captured();
     variable->set_index(context_scope.ContextIndexAt(i));
     if (context_scope.IsFinalAt(i)) {
       variable->set_is_final();
     }
     // Create a fake owner scope describing the index and context level of the
     // variable. Function level and loop level are unused (set to 0), since
     // context level has already been assigned.
     LocalScope* owner_scope = new LocalScope(NULL, 0, 0);
@@ skipping 74 matching lines @@
     return fixed_parameter_count - (index() - kParamEndSlotFromFp);
   } else {
     // Shift negative indexes so that the lowest one is 0 (they are still
     // non-positive).
     return fixed_parameter_count - (index() - kFirstLocalSlotFromFp);
   }
 }
 
 
 }  // namespace dart