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

runtime/platform/globals.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_PLATFORM_GLOBALS_H_
 #define RUNTIME_PLATFORM_GLOBALS_H_
 
 // __STDC_FORMAT_MACROS has to be defined before including <inttypes.h> to
 // enable platform independent printf format specifiers.
 #ifndef __STDC_FORMAT_MACROS
@@ skipping 28 matching lines @@
 
 #if !defined(NOMCX)
 #define NOMCX
 #endif
 
 #if !defined(UNICODE)
 #define _UNICODE
 #define UNICODE
 #endif
 
+#include <Rpc.h>
+#include <VersionHelpers.h>
+#include <shellapi.h>
 #include <windows.h>
 #include <winsock2.h>
-#include <Rpc.h>
-#include <shellapi.h>
-#include <VersionHelpers.h>
 #endif  // defined(_WIN32)
 
 #if !defined(_WIN32)
 #include <arpa/inet.h>
 #include <inttypes.h>
 #include <stdint.h>
 #include <unistd.h>
 #endif  // !defined(_WIN32)
 
 #include <float.h>
 #include <limits.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 
 #if defined(_WIN32)
 #include "platform/c99_support_win.h"
+#include "platform/floating_point_win.h"
 #include "platform/inttypes_support_win.h"
-#include "platform/floating_point_win.h"
 #endif  // defined(_WIN32)
 
 #include "platform/math.h"
 
 #if !defined(_WIN32)
 #include "platform/floating_point.h"
 #endif  // !defined(_WIN32)
 
 // Target OS detection.
 // for more information on predefined macros:
@@ skipping 25 matching lines @@
 // Windows, both 32- and 64-bit, regardless of the check for _WIN32.
 #define HOST_OS_WINDOWS 1
 
 #elif defined(__Fuchsia__)
 #define HOST_OS_FUCHSIA
 
 #elif !defined(HOST_OS_FUCHSIA)
 #error Automatic target os detection failed.
 #endif
 
-
 // Setup product, release or debug build related macros.
 #if defined(PRODUCT) && defined(DEBUG)
 #error Both PRODUCT and DEBUG defined.
 #endif  // defined(PRODUCT) && defined(DEBUG)
 
 #if defined(PRODUCT)
 #define NOT_IN_PRODUCT(code)
 #else  // defined(PRODUCT)
 #define NOT_IN_PRODUCT(code) code
 #endif  // defined(PRODUCT)
@@ skipping 221 matching lines @@
 #else
 #error Unknown architecture.
 #endif
 
 // Disable background threads by default on armv5te. The relevant
 // implementations are uniprocessors.
 #if !defined(TARGET_ARCH_ARM_5TE)
 #define ARCH_IS_MULTI_CORE 1
 #endif
 
-
 #if !defined(TARGET_OS_ANDROID) && !defined(TARGET_OS_FUCHSIA) &&              \
     !defined(TARGET_OS_MACOS_IOS) && !defined(TARGET_OS_LINUX) &&              \
     !defined(TARGET_OS_MACOS) && !defined(TARGET_OS_WINDOWS)
 // No target OS specified; pick the one matching the host OS.
 #if defined(HOST_OS_ANDROID)
 #define TARGET_OS_ANDROID 1
 #elif defined(HOST_OS_FUCHSIA)
 #define TARGET_OS_FUCHSIA 1
 #elif defined(HOST_OS_IOS)
 #define TARGET_OS_MACOS 1
 #define TARGET_OS_MACOS_IOS 1
 #elif defined(HOST_OS_LINUX)
 #define TARGET_OS_LINUX 1
 #elif defined(HOST_OS_MACOS)
 #define TARGET_OS_MACOS 1
 #elif defined(HOST_OS_WINDOWS)
 #define TARGET_OS_WINDOWS 1
 #else
 #error Automatic target OS detection failed.
 #endif
 #endif
 
-
 // Short form printf format specifiers
 #define Pd PRIdPTR
 #define Pu PRIuPTR
 #define Px PRIxPTR
 #define Pd64 PRId64
 #define Pu64 PRIu64
 #define Px64 PRIx64
 
 // Zero-padded pointer
 #if defined(ARCH_IS_32_BIT)
 #define Pp "08" PRIxPTR
 #else
 #define Pp "016" PRIxPTR
 #endif
 
-
 // Suffixes for 64-bit integer literals.
 #ifdef _MSC_VER
 #define DART_INT64_C(x) x##I64
 #define DART_UINT64_C(x) x##UI64
 #else
 #define DART_INT64_C(x) x##LL
 #define DART_UINT64_C(x) x##ULL
 #endif
 
 // Replace calls to strtoll with _strtoi64 on Windows.
@@ skipping 133 matching lines @@
                                                                                \
  private:                                                                      \
   void* operator new(size_t size);
 #endif  // !defined(DISALLOW_ALLOCATION)
 
 // The USE(x) template is used to silence C++ compiler warnings issued
 // for unused variables.
 template <typename T>
 static inline void USE(T) {}
 
-
 // Use implicit_cast as a safe version of static_cast or const_cast
 // for upcasting in the type hierarchy (i.e. casting a pointer to Foo
 // to a pointer to SuperclassOfFoo or casting a pointer to Foo to
 // a const pointer to Foo).
 // When you use implicit_cast, the compiler checks that the cast is safe.
 // Such explicit implicit_casts are necessary in surprisingly many
 // situations where C++ demands an exact type match instead of an
 // argument type convertible to a target type.
 //
 // The From type can be inferred, so the preferred syntax for using
 // implicit_cast is the same as for static_cast etc.:
 //
 //   implicit_cast<ToType>(expr)
 //
 // implicit_cast would have been part of the C++ standard library,
 // but the proposal was submitted too late.  It will probably make
 // its way into the language in the future.
 template <typename To, typename From>
 inline To implicit_cast(From const& f) {
   return f;
 }
 
-
 // Use like this: down_cast<T*>(foo);
 template <typename To, typename From>  // use like this: down_cast<T*>(foo);
 inline To down_cast(From* f) {         // so we only accept pointers
   // Ensures that To is a sub-type of From *.  This test is here only
   // for compile-time type checking, and has no overhead in an
   // optimized build at run-time, as it will be optimized away completely.
   if (false) {
     implicit_cast<From, To>(0);
   }
   return static_cast<To>(f);
 }
 
-
 // The type-based aliasing rule allows the compiler to assume that
 // pointers of different types (for some definition of different)
 // never alias each other. Thus the following code does not work:
 //
 // float f = foo();
 // int fbits = *(int*)(&f);
 //
 // The compiler 'knows' that the int pointer can't refer to f since
 // the types don't match, so the compiler may cache f in a register,
 // leaving random data in fbits.  Using C++ style casts makes no
@@ skipping 17 matching lines @@
   // Compile time assertion: sizeof(D) == sizeof(S). A compile error
   // here means your D and S have different sizes.
   DART_UNUSED typedef char VerifySizesAreEqual[sizeof(D) == sizeof(S) ? 1 : -1];
 
   D destination;
   // This use of memcpy is safe: source and destination cannot overlap.
   memcpy(&destination, &source, sizeof(destination));
   return destination;
 }
 
-
 // Similar to bit_cast, but allows copying from types of unrelated
 // sizes. This method was introduced to enable the strict aliasing
 // optimizations of GCC 4.4. Basically, GCC mindlessly relies on
 // obscure details in the C++ standard that make reinterpret_cast
 // virtually useless.
 template <class D, class S>
 inline D bit_copy(const S& source) {
   D destination;
   // This use of memcpy is safe: source and destination cannot overlap.
   memcpy(&destination, reinterpret_cast<const void*>(&source),
          sizeof(destination));
   return destination;
 }
 
-
 #if defined(HOST_ARCH_ARM) || defined(HOST_ARCH_ARM64)
 // Similar to bit_copy and bit_cast, but does take the type from the argument.
 template <typename T>
 static inline T ReadUnaligned(const T* ptr) {
   T value;
   memcpy(reinterpret_cast<void*>(&value), reinterpret_cast<const void*>(ptr),
          sizeof(value));
   return value;
 }
 
-
 // Similar to bit_copy and bit_cast, but does take the type from the argument.
 template <typename T>
 static inline void StoreUnaligned(T* ptr, T value) {
   memcpy(reinterpret_cast<void*>(ptr), reinterpret_cast<const void*>(&value),
          sizeof(value));
 }
 #else   // !(HOST_ARCH_ARM || HOST_ARCH_ARM64)
 // Similar to bit_copy and bit_cast, but does take the type from the argument.
 template <typename T>
 static inline T ReadUnaligned(const T* ptr) {
   return *ptr;
 }
 
-
 // Similar to bit_copy and bit_cast, but does take the type from the argument.
 template <typename T>
 static inline void StoreUnaligned(T* ptr, T value) {
   *ptr = value;
 }
 #endif  // !(HOST_ARCH_ARM || HOST_ARCH_ARM64)
 
-
 // On Windows the reentrent version of strtok is called
 // strtok_s. Unify on the posix name strtok_r.
 #if defined(HOST_OS_WINDOWS)
 #define snprintf _snprintf
 #define strtok_r strtok_s
 #endif
 
 #if !defined(HOST_OS_WINDOWS)
 #if defined(TEMP_FAILURE_RETRY)
 // TEMP_FAILURE_RETRY is defined in unistd.h on some platforms. We should
@@ skipping 27 matching lines @@
 // tag in the ICData and check it when recreating the flow graph in
 // optimizing compiler. Enable it for other modes (product, release) if needed
 // for debugging.
 #if defined(DEBUG)
 #define TAG_IC_DATA
 #endif
 
 }  // namespace dart
 
 #endif  // RUNTIME_PLATFORM_GLOBALS_H_