VM: Re-format to use at most one newline between functions

runtime/vm/flags.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/flags.h"
 
 #include "platform/assert.h"
 #include "vm/json_stream.h"
 #include "vm/os.h"
 
@@ skipping 42 matching lines @@
 #else  // !PRODUCT && !PRECOMPILED
 #define RELEASE_FLAG_MARCO(name, product_value, type, default_value, comment)  \
   type FLAG_##name =                                                           \
       Flags::Register_##type(&FLAG_##name, #name, default_value, comment);
 #define PRECOMPILE_FLAG_MARCO(name, pre_value, product_value, type,            \
                               default_value, comment)                          \
   type FLAG_##name =                                                           \
       Flags::Register_##type(&FLAG_##name, #name, default_value, comment);
 #endif
 
-
 // Define all of the non-product flags here.
 FLAG_LIST(PRODUCT_FLAG_MARCO,
           RELEASE_FLAG_MARCO,
           DEBUG_FLAG_MARCO,
           PRECOMPILE_FLAG_MARCO)
 
 #undef RELEASE_FLAG_MARCO
 #undef DEBUG_FLAG_MARCO
 #undef PRODUCT_FLAG_MARCO
 #undef PRECOMPILE_FLAG_MARCO
 
-
 bool Flags::initialized_ = false;
 
 // List of registered flags.
 Flag** Flags::flags_ = NULL;
 intptr_t Flags::capacity_ = 0;
 intptr_t Flags::num_flags_ = 0;
 
 class Flag {
  public:
   enum FlagType { kBoolean, kInteger, kUint64, kString, kFunc, kNumFlagTypes };
@@ skipping 51 matching lines @@
     bool* bool_ptr_;
     int* int_ptr_;
     uint64_t* uint64_ptr_;
     charp* charp_ptr_;
     FlagHandler handler_;
   };
   FlagType type_;
   bool changed_;
 };
 
-
 Flag* Flags::Lookup(const char* name) {
   for (intptr_t i = 0; i < num_flags_; i++) {
     Flag* flag = flags_[i];
     if (strcmp(flag->name_, name) == 0) {
       return flag;
     }
   }
   return NULL;
 }
 
-
 bool Flags::IsSet(const char* name) {
   Flag* flag = Lookup(name);
   return (flag != NULL) && (flag->type_ == Flag::kBoolean) &&
          (flag->bool_ptr_ != NULL) && (*flag->bool_ptr_ == true);
 }
 
-
 void Flags::AddFlag(Flag* flag) {
   ASSERT(!initialized_);
   if (num_flags_ == capacity_) {
     if (flags_ == NULL) {
       capacity_ = 256;
       flags_ = new Flag*[capacity_];
     } else {
       intptr_t new_capacity = capacity_ * 2;
       Flag** new_flags = new Flag*[new_capacity];
       for (intptr_t i = 0; i < num_flags_; i++) {
         new_flags[i] = flags_[i];
       }
       delete[] flags_;
       flags_ = new_flags;
       capacity_ = new_capacity;
     }
   }
   flags_[num_flags_++] = flag;
 }
 
-
 bool Flags::Register_bool(bool* addr,
                           const char* name,
                           bool default_value,
                           const char* comment) {
   Flag* flag = Lookup(name);
   if (flag != NULL) {
     ASSERT(flag->IsUnrecognized());
     return default_value;
   }
   flag = new Flag(name, comment, addr, Flag::kBoolean);
   AddFlag(flag);
   return default_value;
 }
 
-
 int Flags::Register_int(int* addr,
                         const char* name,
                         int default_value,
                         const char* comment) {
   ASSERT(Lookup(name) == NULL);
 
   Flag* flag = new Flag(name, comment, addr, Flag::kInteger);
   AddFlag(flag);
 
   return default_value;
 }
 
-
 uint64_t Flags::Register_uint64_t(uint64_t* addr,
                                   const char* name,
                                   uint64_t default_value,
                                   const char* comment) {
   ASSERT(Lookup(name) == NULL);
 
   Flag* flag = new Flag(name, comment, addr, Flag::kUint64);
   AddFlag(flag);
 
   return default_value;
 }
 
-
 const char* Flags::Register_charp(charp* addr,
                                   const char* name,
                                   const char* default_value,
                                   const char* comment) {
   ASSERT(Lookup(name) == NULL);
   Flag* flag = new Flag(name, comment, addr, Flag::kString);
   AddFlag(flag);
   return default_value;
 }
 
-
 bool Flags::Register_func(FlagHandler handler,
                           const char* name,
                           const char* comment) {
   ASSERT(Lookup(name) == NULL);
   Flag* flag = new Flag(name, comment, handler);
   AddFlag(flag);
   return false;
 }
 
-
 static void Normalize(char* s) {
   intptr_t len = strlen(s);
   for (intptr_t i = 0; i < len; i++) {
     if (s[i] == '-') {
       s[i] = '_';
     }
   }
 }
 
-
 bool Flags::SetFlagFromString(Flag* flag, const char* argument) {
   ASSERT(!flag->IsUnrecognized());
   switch (flag->type_) {
     case Flag::kBoolean: {
       if (strcmp(argument, "true") == 0) {
         *flag->bool_ptr_ = true;
       } else if (strcmp(argument, "false") == 0) {
         *flag->bool_ptr_ = false;
       } else {
         return false;
@@ skipping 46 matching lines @@
     }
     default: {
       UNREACHABLE();
       return false;
     }
   }
   flag->changed_ = true;
   return true;
 }
 
-
 void Flags::Parse(const char* option) {
   // Find the beginning of the option argument, if it exists.
   const char* equals = option;
   while ((*equals != '\0') && (*equals != '=')) {
     equals++;
   }
 
   const char* argument = NULL;
 
   // Determine if this is an option argument.
@@ skipping 39 matching lines @@
       if (!SetFlagFromString(flag, argument)) {
         OS::Print("Ignoring flag: %s is an invalid value for flag %s\n",
                   argument, name);
       }
     }
   }
 
   delete[] name;
 }
 
-
 static bool IsValidFlag(const char* name,
                         const char* prefix,
                         intptr_t prefix_length) {
   intptr_t name_length = strlen(name);
   return ((name_length > prefix_length) &&
           (strncmp(name, prefix, prefix_length) == 0));
 }
 
-
 int Flags::CompareFlagNames(const void* left, const void* right) {
   const Flag* left_flag = *reinterpret_cast<const Flag* const*>(left);
   const Flag* right_flag = *reinterpret_cast<const Flag* const*>(right);
   return strcmp(left_flag->name_, right_flag->name_);
 }
 
-
 bool Flags::ProcessCommandLineFlags(int number_of_vm_flags,
                                     const char** vm_flags) {
   if (initialized_) {
     return false;
   }
 
   qsort(flags_, num_flags_, sizeof flags_[0], CompareFlagNames);
 
   const char* const kPrefix = "--";
   const intptr_t kPrefixLen = strlen(kPrefix);
@@ skipping 25 matching lines @@
     }
   }
   if (FLAG_print_flags) {
     PrintFlags();
   }
 
   initialized_ = true;
   return true;
 }
 
-
 bool Flags::SetFlag(const char* name, const char* value, const char** error) {
   Flag* flag = Lookup(name);
   if (flag == NULL) {
     *error = "Cannot set flag: flag not found";
     return false;
   }
   if (!SetFlagFromString(flag, value)) {
     *error = "Cannot set flag: invalid value";
     return false;
   }
   return true;
 }
 
-
 void Flags::PrintFlags() {
   OS::Print("Flag settings:\n");
   for (intptr_t i = 0; i < num_flags_; ++i) {
     flags_[i]->Print();
   }
 }
 
-
 #ifndef PRODUCT
 void Flags::PrintFlagToJSONArray(JSONArray* jsarr, const Flag* flag) {
   if (!FLAG_support_service) {
     return;
   }
   if (flag->IsUnrecognized() || flag->type_ == Flag::kFunc) {
     return;
   }
   JSONObject jsflag(jsarr);
   jsflag.AddProperty("name", flag->name_);
@@ skipping 24 matching lines @@
         // valueAsString missing means NULL.
       }
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
-
 void Flags::PrintJSON(JSONStream* js) {
   if (!FLAG_support_service) {
     return;
   }
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "FlagList");
   JSONArray jsarr(&jsobj, "flags");
   for (intptr_t i = 0; i < num_flags_; ++i) {
     PrintFlagToJSONArray(&jsarr, flags_[i]);
   }
 }
 #endif  // !PRODUCT
 
 }  // namespace dart