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

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 15 matching lines @@
  * functions can also be nested without this error check, since all
  * API functions return any error handles passed in as arguments, unchanged.
  */
 static inline Dart_Handle ThrowIfError(Dart_Handle handle) {
   if (Dart_IsError(handle)) {
     Dart_PropagateError(handle);
   }
   return handle;
 }
 
-
 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));
     if (arguments_ == NULL) {
       max_count_ = 0;
     }
   }
@@ skipping 24 matching lines @@
  private:
   void* operator new(size_t size);
 
   int count_;
   int max_count_;
   const char** arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandLineOptions);
 };
 
-
 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,
@@ skipping 162 matching lines @@
                                         bool is_service_isolate);
   static Dart_Handle PrepareAsyncLibrary(Dart_Handle async_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) {}
   Dart_CObject_Type type() { return cobject_->type; }
@@ skipping 76 matching lines @@
   static Dart_CObject api_true_;
   static Dart_CObject api_false_;
   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) {              \
     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) {       \
     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)                    \
       : 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);
 };
 
-
 class CObjectInt32 : public CObject {
  public:
   DECLARE_COBJECT_CONSTRUCTORS(Int32)
 
   int32_t Value() const { return cobject_->value.as_int32; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectInt32);
 };
 
-
 class CObjectInt64 : public CObject {
  public:
   DECLARE_COBJECT_CONSTRUCTORS(Int64)
 
   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) {
     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 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) {
     ASSERT(type() == Dart_CObject_kBigint);
     cobject_ = cobject;
     hex_value_ = NULL;
   }
   explicit CObjectBigint(CObject* cobject) : CObject() {
     ASSERT(cobject != NULL);
@@ skipping 10 matching lines @@
     return hex_value_;
   }
 
   ~CObjectBigint() { free(hex_value_); }
 
  private:
   char* hex_value_;
   DISALLOW_COPY_AND_ASSIGN(CObjectBigint);
 };
 
-
 class CObjectDouble : public CObject {
  public:
   DECLARE_COBJECT_CONSTRUCTORS(Double)
 
   double Value() const { return cobject_->value.as_double; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectDouble);
 };
 
-
 class CObjectString : public CObject {
  public:
   DECLARE_COBJECT_CONSTRUCTORS(String)
 
   intptr_t Length() const { return strlen(cobject_->value.as_string); }
   char* CString() const { return cobject_->value.as_string; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectString);
 };
 
-
 class CObjectArray : public CObject {
  public:
   DECLARE_COBJECT_CONSTRUCTORS(Array)
 
   intptr_t Length() const { return cobject_->value.as_array.length; }
   CObject* operator[](intptr_t index) const {
     return new CObject(cobject_->value.as_array.values[index]);
   }
   void SetAt(intptr_t index, CObject* value) {
     cobject_->value.as_array.values[index] = value->AsApiCObject();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectArray);
 };
 
-
 class CObjectSendPort : public CObject {
  public:
   DECLARE_COBJECT_CONSTRUCTORS(SendPort)
 
   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) {
     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 {
     return cobject_->value.as_typed_data.type;
   }
   intptr_t Length() const { return cobject_->value.as_typed_data.length; }
   uint8_t* Buffer() const { return cobject_->value.as_typed_data.values; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectTypedData);
 };
 
-
 class CObjectUint8Array : public CObject {
  public:
   DECLARE_COBJECT_TYPED_DATA_CONSTRUCTORS(Uint8)
 
   intptr_t Length() const { return cobject_->value.as_typed_data.length; }
   uint8_t* Buffer() const { return cobject_->value.as_typed_data.values; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectUint8Array);
 };
 
-
 class CObjectExternalUint8Array : public CObject {
  public:
   DECLARE_COBJECT_EXTERNAL_TYPED_DATA_CONSTRUCTORS(Uint8)
 
   intptr_t Length() const {
     return cobject_->value.as_external_typed_data.length;
   }
   void SetLength(intptr_t length) {
     cobject_->value.as_external_typed_data.length = length;
   }
   uint8_t* Data() const { return cobject_->value.as_external_typed_data.data; }
   void* Peer() const { return cobject_->value.as_external_typed_data.peer; }
   Dart_WeakPersistentHandleFinalizer Callback() const {
     return cobject_->value.as_external_typed_data.callback;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CObjectExternalUint8Array);
 };
 
-
 class ScopedBlockingCall {
  public:
   ScopedBlockingCall() { Dart_ThreadDisableProfiling(); }
 
   ~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)) {
@@ skipping 39 matching lines @@
   bool is_typed_data_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(ScopedMemBuffer);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // RUNTIME_BIN_DARTUTILS_H_