clang-format runtime/vm

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"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_flags, false, "Print flags as they are being parsed.");
-DEFINE_FLAG(bool, ignore_unrecognized_flags, false,
-    "Ignore unrecognized flags.");
+DEFINE_FLAG(bool,
+            ignore_unrecognized_flags,
+            false,
+            "Ignore unrecognized flags.");
 
-#define PRODUCT_FLAG_MARCO(name, type, default_value, comment) \
-  type FLAG_##name = Flags::Register_##type(&FLAG_##name,                      \
-                                            #name,                             \
-                                            default_value,                     \
-                                            comment);
+#define PRODUCT_FLAG_MARCO(name, type, default_value, comment)                 \
+  type FLAG_##name =                                                           \
+      Flags::Register_##type(&FLAG_##name, #name, default_value, comment);
 
 #if defined(DEBUG)
-#define DEBUG_FLAG_MARCO(name, type, default_value, comment) \
-  type FLAG_##name = Flags::Register_##type(&FLAG_##name,                      \
-                                            #name,                             \
-                                            default_value,                     \
-                                            comment);
+#define DEBUG_FLAG_MARCO(name, type, default_value, comment)                   \
+  type FLAG_##name =                                                           \
+      Flags::Register_##type(&FLAG_##name, #name, default_value, comment);
 #else  // defined(DEBUG)
 #define DEBUG_FLAG_MARCO(name, type, default_value, comment)
 #endif  // defined(DEBUG)
 
 #if defined(PRODUCT) && defined(DART_PRECOMPILED_RUNTIME)
 // Nothing to be done for the product flag definitions.
 #define RELEASE_FLAG_MARCO(name, product_value, type, default_value, comment)
 // Nothing to be done for the precompilation flag definitions.
 #define PRECOMPILE_FLAG_MARCO(name, pre_value, product_value, type,            \
                               default_value, comment)
 
 #elif defined(PRODUCT)  // !PRECOMPILED
 // Nothing to be done for the product flag definitions.
 #define RELEASE_FLAG_MARCO(name, product_value, type, default_value, comment)
 // Nothing to be done for the precompilation flag definitions.
 #define PRECOMPILE_FLAG_MARCO(name, pre_value, product_value, type,            \
                               default_value, comment)
 
 #elif defined(DART_PRECOMPILED_RUNTIME)  // !PRODUCT
 #define RELEASE_FLAG_MARCO(name, product_value, type, default_value, comment)  \
-  type FLAG_##name = Flags::Register_##type(&FLAG_##name,                      \
-                                            #name,                             \
-                                            default_value,                     \
-                                            comment);
+  type FLAG_##name =                                                           \
+      Flags::Register_##type(&FLAG_##name, #name, default_value, comment);
 // Nothing to be done for the precompilation flag definitions.
 #define PRECOMPILE_FLAG_MARCO(name, pre_value, product_value, type,            \
                               default_value, comment)
 
 #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);
+  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);
+  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
-  };
+  enum FlagType { kBoolean, kInteger, kUint64, kString, kFunc, kNumFlagTypes };
 
   Flag(const char* name, const char* comment, void* addr, FlagType type)
-      : name_(name), comment_(comment), addr_(addr), type_(type) {
-  }
+      : name_(name), comment_(comment), addr_(addr), type_(type) {}
   Flag(const char* name, const char* comment, FlagHandler handler)
-      : name_(name), comment_(comment), handler_(handler), type_(kFunc) {
-  }
+      : name_(name), comment_(comment), handler_(handler), type_(kFunc) {}
 
   void Print() {
     if (IsUnrecognized()) {
       OS::Print("%s: unrecognized\n", name_);
       return;
     }
     switch (type_) {
       case kBoolean: {
-        OS::Print("%s: %s (%s)\n",
-            name_, *this->bool_ptr_ ? "true" : "false", comment_);
+        OS::Print("%s: %s (%s)\n", name_, *this->bool_ptr_ ? "true" : "false",
+                  comment_);
         break;
       }
       case kInteger: {
         OS::Print("%s: %d (%s)\n", name_, *this->int_ptr_, comment_);
         break;
       }
       case kUint64: {
         OS::Print("%s: %" Pu64 " (%s)\n", name_, *this->uint64_ptr_, comment_);
         break;
       }
@@ skipping 40 matching lines @@
     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);
+  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_;
+      delete[] flags_;
       flags_ = new_flags;
       capacity_ = new_capacity;
     }
   }
   flags_[num_flags_++] = flag;
 }
 
 
 bool Flags::Register_bool(bool* addr,
                           const char* name,
@@ skipping 197 matching lines @@
 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);
+  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;
   }
 
@@ skipping 29 matching lines @@
     }
   }
   if (FLAG_print_flags) {
     PrintFlags();
   }
 
   initialized_ = true;
   return true;
 }
 
-bool Flags::SetFlag(const char* name,
-                    const char* value,
-                    const char** error) {
+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;
@@ skipping 60 matching lines @@
   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