clang-format runtime/bin

runtime/bin/dartutils.h

 // 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.
 
 #ifndef RUNTIME_BIN_DARTUTILS_H_
 #define RUNTIME_BIN_DARTUTILS_H_
 
 #include "bin/isolate_data.h"
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
@@ skipping 29 matching lines @@
 // The caller is responsible for free()ing [kernel_file] if `true` was returned.
 bool TryReadKernel(const char* script_uri,
                    const uint8_t** kernel_file,
                    intptr_t* kernel_length);
 
 class CommandLineOptions {
  public:
   explicit CommandLineOptions(int max_count)
       : count_(0), max_count_(max_count), arguments_(NULL) {
     static const int kWordSize = sizeof(intptr_t);
-    arguments_ = reinterpret_cast<const char **>(malloc(max_count * kWordSize));
+    arguments_ = reinterpret_cast<const char**>(malloc(max_count * kWordSize));
     if (arguments_ == NULL) {
       max_count_ = 0;
     }
   }
   ~CommandLineOptions() {
     free(arguments_);
     count_ = 0;
     max_count_ = 0;
     arguments_ = NULL;
   }
@@ skipping 27 matching lines @@
 
 
 class DartUtils {
  public:
   // Returns the integer value of a Dart object. If the object is not
   // an integer value an API error is propagated.
   static int64_t GetIntegerValue(Dart_Handle value_obj);
   // Returns the integer value of a Dart object. If the object is not
   // an integer value or outside the requested range an API error is
   // propagated.
-  static int64_t GetInt64ValueCheckRange(
-      Dart_Handle value_obj, int64_t lower, int64_t upper);
+  static int64_t GetInt64ValueCheckRange(Dart_Handle value_obj,
+                                         int64_t lower,
+                                         int64_t upper);
   // Returns the intptr_t value of a Dart object. If the object is not
   // an integer value or the value is outside the intptr_t range an
   // API error is propagated.
   static intptr_t GetIntptrValue(Dart_Handle value_obj);
   // Checks that the value object is an integer object that fits in a
   // signed 64-bit integer. If it is, the value is returned in the
   // value out parameter and true is returned. Otherwise, false is
   // returned.
   static bool GetInt64Value(Dart_Handle value_obj, int64_t* value);
   // Returns the string value of a Dart object. If the object is not
@@ skipping 60 matching lines @@
   // Create a new Dart String object from a C String.
   static Dart_Handle NewString(const char* str) {
     ASSERT(str != NULL);
     return Dart_NewStringFromUTF8(reinterpret_cast<const uint8_t*>(str),
                                   strlen(str));
   }
 
   // Allocate length bytes for a C string with Dart_ScopeAllocate.
   static char* ScopedCString(intptr_t length) {
     char* result = NULL;
-    result = reinterpret_cast<char*>(
-        Dart_ScopeAllocate(length * sizeof(*result)));
+    result =
+        reinterpret_cast<char*>(Dart_ScopeAllocate(length * sizeof(*result)));
     return result;
   }
 
   // Copy str into a buffer allocated with Dart_ScopeAllocate.
   static char* ScopedCopyCString(const char* str) {
     size_t str_len = strlen(str);
     char* result = ScopedCString(str_len + 1);
     memmove(result, str, str_len);
     result[str_len] = '\0';
     return result;
@@ skipping 57 matching lines @@
 
   static Dart_Handle LibraryFilePath(Dart_Handle library_uri);
 
  private:
   static Dart_Handle SetWorkingDirectory();
   static Dart_Handle PrepareBuiltinLibrary(Dart_Handle builtin_lib,
                                            Dart_Handle internal_lib,
                                            bool is_service_isolate,
                                            bool trace_loading);
   static Dart_Handle PrepareCoreLibrary(Dart_Handle core_lib,
-                                 Dart_Handle builtin_lib,
-                                 bool is_service_isolate);
+                                        Dart_Handle builtin_lib,
+                                        bool is_service_isolate);
   static Dart_Handle PrepareAsyncLibrary(Dart_Handle async_lib,
-                                  Dart_Handle isolate_lib);
+                                         Dart_Handle isolate_lib);
   static Dart_Handle PrepareIOLibrary(Dart_Handle io_lib);
   static Dart_Handle PrepareIsolateLibrary(Dart_Handle isolate_lib);
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(DartUtils);
 };
 
 
 class CObject {
  public:
   // These match the constants in sdk/lib/io/common.dart.
   static const int kSuccess = 0;
   static const int kArgumentError = 1;
   static const int kOSError = 2;
   static const int kFileClosedError = 3;
 
-  explicit CObject(Dart_CObject *cobject) : cobject_(cobject) {}
+  explicit CObject(Dart_CObject* cobject) : cobject_(cobject) {}
   Dart_CObject_Type type() { return cobject_->type; }
   Dart_TypedData_Type byte_array_type() {
     ASSERT(type() == Dart_CObject_kTypedData ||
            type() == Dart_CObject_kExternalTypedData);
     return cobject_->value.as_typed_data.type;
   }
 
   bool IsNull() { return type() == Dart_CObject_kNull; }
   bool IsBool() { return type() == Dart_CObject_kBool; }
   bool IsInt32() { return type() == Dart_CObject_kInt32; }
@@ skipping 12 matching lines @@
   bool IsSendPort() { return type() == Dart_CObject_kSendPort; }
 
   bool IsTrue() {
     return type() == Dart_CObject_kBool && cobject_->value.as_bool;
   }
 
   bool IsFalse() {
     return type() == Dart_CObject_kBool && !cobject_->value.as_bool;
   }
 
-  void* operator new(size_t size) {
-    return Dart_ScopeAllocate(size);
-  }
+  void* operator new(size_t size) { return Dart_ScopeAllocate(size); }
 
   static CObject* Null();
   static CObject* True();
   static CObject* False();
   static CObject* Bool(bool value);
   static Dart_CObject* NewInt32(int32_t value);
   static Dart_CObject* NewInt64(int64_t value);
   static Dart_CObject* NewIntptr(intptr_t value);
   static Dart_CObject* NewBigint(const char* hex_value);
   static char* BigintToHexValue(Dart_CObject* bigint);
   static Dart_CObject* NewDouble(double value);
   static Dart_CObject* NewString(intptr_t length);
   static Dart_CObject* NewString(const char* str);
   static Dart_CObject* NewArray(intptr_t length);
   static Dart_CObject* NewUint8Array(intptr_t length);
   static Dart_CObject* NewUint32Array(intptr_t length);
   static Dart_CObject* NewExternalUint8Array(
-      intptr_t length, uint8_t* data, void* peer,
+      intptr_t length,
+      uint8_t* data,
+      void* peer,
       Dart_WeakPersistentHandleFinalizer callback);
 
   static Dart_CObject* NewIOBuffer(int64_t length);
   static void FreeIOBufferData(Dart_CObject* object);
 
   Dart_CObject* AsApiCObject() { return cobject_; }
 
   // Create a new CObject array with an illegal arguments error.
   static CObject* IllegalArgumentError();
   // Create a new CObject array with a file closed error.
@@ skipping 16 matching lines @@
   static CObject null_;
   static CObject true_;
   static CObject false_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObject);
 };
 
 
 #define DECLARE_COBJECT_CONSTRUCTORS(t)                                        \
-  explicit CObject##t(Dart_CObject *cobject) : CObject(cobject) {              \
+  explicit CObject##t(Dart_CObject* cobject) : CObject(cobject) {              \
     ASSERT(type() == Dart_CObject_k##t);                                       \
     cobject_ = cobject;                                                        \
   }                                                                            \
   explicit CObject##t(CObject* cobject) : CObject() {                          \
     ASSERT(cobject != NULL);                                                   \
     ASSERT(cobject->type() == Dart_CObject_k##t);                              \
     cobject_ = cobject->AsApiCObject();                                        \
-  }                                                                            \
+  }
 
 
 #define DECLARE_COBJECT_TYPED_DATA_CONSTRUCTORS(t)                             \
-  explicit CObject##t##Array(Dart_CObject *cobject) : CObject(cobject) {       \
+  explicit CObject##t##Array(Dart_CObject* cobject) : CObject(cobject) {       \
     ASSERT(type() == Dart_CObject_kTypedData);                                 \
     ASSERT(byte_array_type() == Dart_TypedData_k##t);                          \
     cobject_ = cobject;                                                        \
   }                                                                            \
   explicit CObject##t##Array(CObject* cobject) : CObject() {                   \
     ASSERT(cobject != NULL);                                                   \
     ASSERT(cobject->type() == Dart_CObject_kTypedData);                        \
     ASSERT(cobject->byte_array_type() == Dart_TypedData_k##t);                 \
     cobject_ = cobject->AsApiCObject();                                        \
-  }                                                                            \
+  }
 
 
 #define DECLARE_COBJECT_EXTERNAL_TYPED_DATA_CONSTRUCTORS(t)                    \
-  explicit CObjectExternal##t##Array(Dart_CObject *cobject)                    \
+  explicit CObjectExternal##t##Array(Dart_CObject* cobject)                    \
       : CObject(cobject) {                                                     \
     ASSERT(type() == Dart_CObject_kExternalTypedData);                         \
     ASSERT(byte_array_type() == Dart_TypedData_k##t);                          \
     cobject_ = cobject;                                                        \
   }                                                                            \
   explicit CObjectExternal##t##Array(CObject* cobject) : CObject() {           \
     ASSERT(cobject != NULL);                                                   \
     ASSERT(cobject->type() == Dart_CObject_kExternalTypedData);                \
     ASSERT(cobject->byte_array_type() == Dart_TypedData_k##t);                 \
     cobject_ = cobject->AsApiCObject();                                        \
-  }                                                                            \
+  }
 
 
 class CObjectBool : public CObject {
  public:
   DECLARE_COBJECT_CONSTRUCTORS(Bool)
 
   bool Value() const { return cobject_->value.as_bool; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectBool);
@@ skipping 17 matching lines @@
 
   int64_t Value() const { return cobject_->value.as_int64; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectInt64);
 };
 
 
 class CObjectIntptr : public CObject {
  public:
-  explicit CObjectIntptr(Dart_CObject *cobject) : CObject(cobject) {
+  explicit CObjectIntptr(Dart_CObject* cobject) : CObject(cobject) {
     ASSERT(type() == Dart_CObject_kInt32 || type() == Dart_CObject_kInt64);
     cobject_ = cobject;
   }
   explicit CObjectIntptr(CObject* cobject) : CObject() {
     ASSERT(cobject != NULL);
     ASSERT(cobject->type() == Dart_CObject_kInt64 ||
            cobject->type() == Dart_CObject_kInt32);
     cobject_ = cobject->AsApiCObject();
   }
 
-  intptr_t Value()  {
+  intptr_t Value() {
     intptr_t result;
     if (type() == Dart_CObject_kInt32) {
       result = cobject_->value.as_int32;
     } else {
       ASSERT(sizeof(result) == 8);
       result = static_cast<intptr_t>(cobject_->value.as_int64);
     }
     return result;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectIntptr);
 };
 
 
 class CObjectBigint : public CObject {
  public:
   // DECLARE_COBJECT_CONSTRUCTORS(Bigint) would miss hex_value_ initialization.
-  explicit CObjectBigint(Dart_CObject *cobject) : CObject(cobject) {
+  explicit CObjectBigint(Dart_CObject* cobject) : CObject(cobject) {
     ASSERT(type() == Dart_CObject_kBigint);
     cobject_ = cobject;
     hex_value_ = NULL;
   }
   explicit CObjectBigint(CObject* cobject) : CObject() {
     ASSERT(cobject != NULL);
     ASSERT(cobject->type() == Dart_CObject_kBigint);
     cobject_ = cobject->AsApiCObject();
     hex_value_ = NULL;
   }
 
   char* Value() {
     if (hex_value_ == NULL) {
       hex_value_ = BigintToHexValue(cobject_);
     }
     ASSERT(hex_value_ != NULL);
     return hex_value_;
   }
 
-  ~CObjectBigint() {
-    free(hex_value_);
-  }
+  ~CObjectBigint() { free(hex_value_); }
 
  private:
   char* hex_value_;
   DISALLOW_COPY_AND_ASSIGN(CObjectBigint);
 };
 
 
 class CObjectDouble : public CObject {
  public:
   DECLARE_COBJECT_CONSTRUCTORS(Double)
@@ skipping 41 matching lines @@
   Dart_Port Value() const { return cobject_->value.as_send_port.id; }
   Dart_Port OriginId() const { return cobject_->value.as_send_port.origin_id; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectSendPort);
 };
 
 
 class CObjectTypedData : public CObject {
  public:
-  explicit CObjectTypedData(Dart_CObject *cobject) : CObject(cobject) {
+  explicit CObjectTypedData(Dart_CObject* cobject) : CObject(cobject) {
     ASSERT(type() == Dart_CObject_kTypedData);
     cobject_ = cobject;
   }
   explicit CObjectTypedData(CObject* cobject) : CObject() {
     ASSERT(cobject != NULL);
     ASSERT(cobject->type() == Dart_CObject_kTypedData);
     cobject_ = cobject->AsApiCObject();
   }
 
   Dart_TypedData_Type Type() const {
@@ skipping 35 matching lines @@
     return cobject_->value.as_external_typed_data.callback;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectExternalUint8Array);
 };
 
 
 class ScopedBlockingCall {
  public:
-  ScopedBlockingCall() {
-    Dart_ThreadDisableProfiling();
-  }
+  ScopedBlockingCall() { Dart_ThreadDisableProfiling(); }
 
-  ~ScopedBlockingCall() {
-    Dart_ThreadEnableProfiling();
-  }
+  ~ScopedBlockingCall() { Dart_ThreadEnableProfiling(); }
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(ScopedBlockingCall);
 };
 
 
 // Where the argument to the constructor is the handle for an object
 // implementing List<int>, this class creates a scope in which the memory
 // backing the list can be accessed.
 //
 // Do not make Dart_ API calls while in a ScopedMemBuffer.
 // Do not call Dart_PropagateError while in a ScopedMemBuffer.
 class ScopedMemBuffer {
  public:
   explicit ScopedMemBuffer(Dart_Handle object) {
     if (!Dart_IsTypedData(object) && !Dart_IsList(object)) {
-      Dart_ThrowException(DartUtils::NewDartArgumentError(
-          "Argument is not a List<int>"));
+      Dart_ThrowException(
+          DartUtils::NewDartArgumentError("Argument is not a List<int>"));
     }
 
     uint8_t* bytes = NULL;
     intptr_t bytes_len = 0;
     bool is_typed_data = false;
     if (Dart_IsTypedData(object)) {
       is_typed_data = true;
       Dart_TypedData_Type typ;
       ThrowIfError(Dart_TypedDataAcquireData(
-          object,
-          &typ,
-          reinterpret_cast<void**>(&bytes),
-          &bytes_len));
+          object, &typ, reinterpret_cast<void**>(&bytes), &bytes_len));
     } else {
       ASSERT(Dart_IsList(object));
       ThrowIfError(Dart_ListLength(object, &bytes_len));
       bytes = Dart_ScopeAllocate(bytes_len);
       ASSERT(bytes != NULL);
       ThrowIfError(Dart_ListGetAsBytes(object, 0, bytes, bytes_len));
     }
 
     object_ = object;
     bytes_ = bytes;
@@ skipping 17 matching lines @@
   bool is_typed_data_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(ScopedMemBuffer);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // RUNTIME_BIN_DARTUTILS_H_