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

runtime/lib/isolate.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 "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
@@ skipping 23 matching lines @@
                                  intptr_t old_size,
                                  intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 static void malloc_deallocator(uint8_t* ptr) {
   free(reinterpret_cast<void*>(ptr));
 }
 
-
 DEFINE_NATIVE_ENTRY(CapabilityImpl_factory, 1) {
   ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull());
   uint64_t id = isolate->random()->NextUInt64();
   return Capability::New(id);
 }
 
-
 DEFINE_NATIVE_ENTRY(CapabilityImpl_equals, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Capability, recv, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Capability, other, arguments->NativeArgAt(1));
   return (recv.Id() == other.Id()) ? Bool::True().raw() : Bool::False().raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(CapabilityImpl_get_hashcode, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(Capability, cap, arguments->NativeArgAt(0));
   int64_t id = cap.Id();
   int32_t hi = static_cast<int32_t>(id >> 32);
   int32_t lo = static_cast<int32_t>(id);
   int32_t hash = (hi ^ lo) & kSmiMax;
   return Smi::New(hash);
 }
 
-
 DEFINE_NATIVE_ENTRY(RawReceivePortImpl_factory, 1) {
   ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull());
   Dart_Port port_id = PortMap::CreatePort(isolate->message_handler());
   return ReceivePort::New(port_id, false /* not control port */);
 }
 
-
 DEFINE_NATIVE_ENTRY(RawReceivePortImpl_get_id, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(ReceivePort, port, arguments->NativeArgAt(0));
   return Integer::NewFromUint64(port.Id());
 }
 
-
 DEFINE_NATIVE_ENTRY(RawReceivePortImpl_get_sendport, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(ReceivePort, port, arguments->NativeArgAt(0));
   return port.send_port();
 }
 
-
 DEFINE_NATIVE_ENTRY(RawReceivePortImpl_closeInternal, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(ReceivePort, port, arguments->NativeArgAt(0));
   Dart_Port id = port.Id();
   PortMap::ClosePort(id);
   return Integer::NewFromUint64(id);
 }
 
-
 DEFINE_NATIVE_ENTRY(SendPortImpl_get_id, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
   return Integer::NewFromUint64(port.Id());
 }
 
-
 DEFINE_NATIVE_ENTRY(SendPortImpl_get_hashcode, 1) {
   GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
   int64_t id = port.Id();
   int32_t hi = static_cast<int32_t>(id >> 32);
   int32_t lo = static_cast<int32_t>(id);
   int32_t hash = (hi ^ lo) & kSmiMax;
   return Smi::New(hash);
 }
 
-
 DEFINE_NATIVE_ENTRY(SendPortImpl_sendInternal_, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
   // TODO(iposva): Allow for arbitrary messages to be sent.
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, obj, arguments->NativeArgAt(1));
 
   const Dart_Port destination_port_id = port.Id();
   const bool can_send_any_object = isolate->origin_id() == port.origin_id();
 
   if (ApiObjectConverter::CanConvert(obj.raw())) {
     PortMap::PostMessage(
         new Message(destination_port_id, obj.raw(), Message::kNormalPriority));
   } else {
     uint8_t* data = NULL;
     MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator,
                          can_send_any_object);
     writer.WriteMessage(obj);
 
     // TODO(turnidge): Throw an exception when the return value is false?
     PortMap::PostMessage(new Message(destination_port_id, data,
                                      writer.BytesWritten(),
                                      Message::kNormalPriority));
   }
   return Object::null();
 }
 
-
 static void ThrowIsolateSpawnException(const String& message) {
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, message);
   Exceptions::ThrowByType(Exceptions::kIsolateSpawn, args);
 }
 
-
 class SpawnIsolateTask : public ThreadPool::Task {
  public:
   explicit SpawnIsolateTask(IsolateSpawnState* state) : state_(state) {}
 
   virtual void Run() {
     // Create a new isolate.
     char* error = NULL;
     Dart_IsolateCreateCallback callback = Isolate::CreateCallback();
     if (callback == NULL) {
       state_->DecrementSpawnCount();
@@ skipping 42 matching lines @@
       // Perhaps the parent isolate died or closed the port before we
       // could report the error.  Ignore.
     }
   }
 
   IsolateSpawnState* state_;
 
   DISALLOW_COPY_AND_ASSIGN(SpawnIsolateTask);
 };
 
-
 static const char* String2UTF8(const String& str) {
   intptr_t len = Utf8::Length(str);
   char* result = new char[len + 1];
   str.ToUTF8(reinterpret_cast<uint8_t*>(result), len);
   result[len] = 0;
 
   return result;
 }
 
-
 DEFINE_NATIVE_ENTRY(Isolate_spawnFunction, 10) {
   GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(String, script_uri, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, closure, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, message, arguments->NativeArgAt(3));
   GET_NON_NULL_NATIVE_ARGUMENT(Bool, paused, arguments->NativeArgAt(4));
   GET_NATIVE_ARGUMENT(Bool, fatalErrors, arguments->NativeArgAt(5));
   GET_NATIVE_ARGUMENT(SendPort, onExit, arguments->NativeArgAt(6));
   GET_NATIVE_ARGUMENT(SendPort, onError, arguments->NativeArgAt(7));
   GET_NATIVE_ARGUMENT(String, packageRoot, arguments->NativeArgAt(8));
@@ skipping 58 matching lines @@
       }
       return Object::null();
     }
   }
   const String& msg = String::Handle(String::New(
       "Isolate.spawn expects to be passed a static or top-level function"));
   Exceptions::ThrowArgumentError(msg);
   return Object::null();
 }
 
-
 static const char* CanonicalizeUri(Thread* thread,
                                    const Library& library,
                                    const String& uri,
                                    char** error) {
   const char* result = NULL;
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   Dart_LibraryTagHandler handler = isolate->library_tag_handler();
   if (handler != NULL) {
     TransitionVMToNative transition(thread);
@@ skipping 17 matching lines @@
     }
     Dart_ExitScope();
   } else {
     *error = zone->PrintToString(
         "Unable to canonicalize uri '%s': no library tag handler found.",
         uri.ToCString());
   }
   return result;
 }
 
-
 DEFINE_NATIVE_ENTRY(Isolate_spawnUri, 12) {
   GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(String, uri, arguments->NativeArgAt(1));
 
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, args, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, message, arguments->NativeArgAt(3));
 
   GET_NON_NULL_NATIVE_ARGUMENT(Bool, paused, arguments->NativeArgAt(4));
   GET_NATIVE_ARGUMENT(SendPort, onExit, arguments->NativeArgAt(5));
   GET_NATIVE_ARGUMENT(SendPort, onError, arguments->NativeArgAt(6));
@@ skipping 82 matching lines @@
     // Running on the thread pool failed. Clean up everything.
     state->DecrementSpawnCount();
     delete state;
     state = NULL;
     delete spawn_task;
     spawn_task = NULL;
   }
   return Object::null();
 }
 
-
 DEFINE_NATIVE_ENTRY(Isolate_getPortAndCapabilitiesOfCurrentIsolate, 0) {
   const Array& result = Array::Handle(Array::New(3));
   result.SetAt(0, SendPort::Handle(SendPort::New(isolate->main_port())));
   result.SetAt(
       1, Capability::Handle(Capability::New(isolate->pause_capability())));
   result.SetAt(
       2, Capability::Handle(Capability::New(isolate->terminate_capability())));
   return result.raw();
 }
 
-
 DEFINE_NATIVE_ENTRY(Isolate_getCurrentRootUriStr, 0) {
   const Library& root_lib =
       Library::Handle(zone, isolate->object_store()->root_library());
   return root_lib.url();
 }
 
-
 DEFINE_NATIVE_ENTRY(Isolate_sendOOB, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(SendPort, port, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Array, msg, arguments->NativeArgAt(1));
 
   // Make sure to route this request to the isolate library OOB mesage handler.
   msg.SetAt(0, Smi::Handle(Smi::New(Message::kIsolateLibOOBMsg)));
 
   uint8_t* data = NULL;
   MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
   writer.WriteMessage(msg);
 
   PortMap::PostMessage(new Message(port.Id(), data, writer.BytesWritten(),
                                    Message::kOOBPriority));
   return Object::null();
 }
 
 }  // namespace dart