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

runtime/bin/sync_socket.cc

 // Copyright (c) 2017, 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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "bin/sync_socket.h"
 
 #include "bin/dartutils.h"
 #include "bin/io_buffer.h"
@@ skipping 82 matching lines @@
     error = Dart_ListSetAt(entry, 2, data);
     DART_CHECK_ERROR_AND_CLEANUP(error, addresses);
     error = Dart_ListSetAt(array, i, entry);
     DART_CHECK_ERROR_AND_CLEANUP(error, addresses);
   }
   delete addresses;
   Dart_SetReturnValue(args, array);
   return;
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_CreateConnectSync)(
     Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   DART_CHECK_ERROR(port_arg);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
   SocketAddress::SetAddrPort(&addr, static_cast<intptr_t>(port));
   intptr_t socket = SynchronousSocket::CreateConnect(addr);
   if (socket >= 0) {
     Dart_Handle error = SynchronousSocket::SetSocketIdNativeField(
         Dart_GetNativeArgument(args, 0), new SynchronousSocket(socket));
     DART_CHECK_ERROR(error);
     Dart_SetBooleanReturnValue(args, true);
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_WriteList)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   Dart_Handle buffer_obj = Dart_GetNativeArgument(args, 1);
   if (!Dart_IsList(buffer_obj)) {
     Dart_SetReturnValue(args, DartUtils::NewDartArgumentError(
                                   "First parameter must be a List<int>"));
@@ skipping 13 matching lines @@
       SynchronousSocket::Write(socket->fd(), buffer, length);
   if (bytes_written >= 0) {
     Dart_SetIntegerReturnValue(args, bytes_written);
   } else {
     OSError os_error;
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&os_error));
   }
   Dart_TypedDataReleaseData(buffer_obj);
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_ReadList)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   Dart_Handle buffer_obj = Dart_GetNativeArgument(args, 1);
   if (!Dart_IsList(buffer_obj)) {
     Dart_SetReturnValue(args, DartUtils::NewDartArgumentError(
                                   "First parameter must be a List<int>"));
@@ skipping 12 matching lines @@
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
     return;
   }
   if (bytes_read > 0) {
     result = Dart_ListSetAsBytes(buffer_obj, offset, buffer, bytes_read);
     DART_CHECK_ERROR(result);
   }
   Dart_SetIntegerReturnValue(args, bytes_read);
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_Available)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   intptr_t available = SynchronousSocket::Available(socket->fd());
   if (available >= 0) {
     Dart_SetIntegerReturnValue(args, available);
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_CloseSync)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   SynchronousSocket::Close(socket->fd());
   socket->SetClosedFd();
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_Read)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   int64_t length = 0;
   if (!DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 1), &length)) {
     Dart_SetReturnValue(args, DartUtils::NewDartArgumentError(
                                   "First parameter must be an integer."));
     return;
   }
   uint8_t* buffer = NULL;
   result = IOBuffer::Allocate(length, &buffer);
   ASSERT(buffer != NULL);
   intptr_t bytes_read = SynchronousSocket::Read(socket->fd(), buffer, length);
   if (bytes_read == length) {
     Dart_SetReturnValue(args, result);
   } else if (bytes_read > 0) {
     uint8_t* new_buffer = NULL;
     Dart_Handle new_result = IOBuffer::Allocate(bytes_read, &new_buffer);
     ASSERT(new_buffer != NULL);
     memmove(new_buffer, buffer, bytes_read);
     Dart_SetReturnValue(args, new_result);
   } else if (bytes_read == -1) {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_ShutdownRead)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   SynchronousSocket::ShutdownRead(socket->fd());
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_ShutdownWrite)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   SynchronousSocket::ShutdownWrite(socket->fd());
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_GetPort)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   intptr_t port = SynchronousSocket::GetPort(socket->fd());
   if (port > 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(port));
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(SynchronousSocket_GetRemotePeer)(Dart_NativeArguments args) {
   SynchronousSocket* socket = NULL;
   Dart_Handle result = SynchronousSocket::GetSocketIdNativeField(
       Dart_GetNativeArgument(args, 0), &socket);
   DART_CHECK_ERROR(result);
 
   intptr_t port = 0;
   SocketAddress* addr = SynchronousSocket::GetRemotePeer(socket->fd(), &port);
   if (addr == NULL) {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
@@ skipping 17 matching lines @@
   DART_CHECK_ERROR_AND_CLEANUP(error, addr);
 
   error = Dart_ListSetAt(list, 0, entry);
   DART_CHECK_ERROR_AND_CLEANUP(error, addr);
   error = Dart_ListSetAt(list, 1, Dart_NewInteger(port));
   DART_CHECK_ERROR_AND_CLEANUP(error, addr);
   Dart_SetReturnValue(args, list);
   delete addr;
 }
 
-
 static void SynchronousSocketFinalizer(void* isolate_data,
                                        Dart_WeakPersistentHandle handle,
                                        void* data) {
   SynchronousSocket* socket = reinterpret_cast<SynchronousSocket*>(data);
   if (socket->fd() >= 0) {
     SynchronousSocket::Close(socket->fd());
     socket->SetClosedFd();
   }
   delete socket;
 }
 
-
 Dart_Handle SynchronousSocket::SetSocketIdNativeField(
     Dart_Handle handle,
     SynchronousSocket* socket) {
   Dart_Handle error = Dart_SetNativeInstanceField(
       handle, kSocketIdNativeField, reinterpret_cast<intptr_t>(socket));
   if (Dart_IsError(error)) {
     delete socket;
     return error;
   }
 
   Dart_NewWeakPersistentHandle(handle, reinterpret_cast<void*>(socket),
                                sizeof(SynchronousSocket),
                                SynchronousSocketFinalizer);
   return error;
 }
 
-
 Dart_Handle SynchronousSocket::GetSocketIdNativeField(
     Dart_Handle socket_obj,
     SynchronousSocket** socket) {
   ASSERT(socket != NULL);
   intptr_t id;
   Dart_Handle result =
       Dart_GetNativeInstanceField(socket_obj, kSocketIdNativeField, &id);
   if (Dart_IsError(result)) {
     return result;
   }
   *socket = reinterpret_cast<SynchronousSocket*>(id);
   return result;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // !defined(DART_IO_DISABLED)