Introduce runtime/platform directory for code shared between vm

runtime/vm/globals.h

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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 VM_GLOBALS_H_
 #define VM_GLOBALS_H_
 
-// __STDC_FORMAT_MACROS has to be defined to enable platform independent printf.
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
-#endif
+// This file contains global definitions for the VM library only. Anything that
+// is more globally useful should be added to 'vm/globals.h'.
+
+#include "platform/globals.h"
 
 #if defined(_WIN32)
-// Cut down on the amount of stuff that gets included via windows.h.
-#define WIN32_LEAN_AND_MEAN
-#define NOMINMAX
-#define NOKERNEL
-#define NOUSER
-#define NOSERVICE
-#define NOSOUND
-#define NOMCX
-
-#include <windows.h>
-
 // Undef conflicting defines.
 #undef PARITY_EVEN
 #undef PARITY_ODD
 #undef near
 #endif
 
-#if !defined(_WIN32)
-#include <inttypes.h>
-#include <stdint.h>
-#endif
-
-#include <float.h>
-#include <limits.h>
-#include <math.h>
-#include <openssl/bn.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-
-#if defined(_WIN32)
-#include "vm/c99_support_win.h"
-#include "vm/inttypes_support_win.h"
-#endif
-
 // The following #defines are invalidated.
 #undef OVERFLOW  // From math.h conflicts in constants_ia32.h
 
 namespace dart {
 
 // Processor architecture detection.  For more info on what's defined, see:
 //   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
 //   http://www.agner.org/optimize/calling_conventions.pdf
 //   or with gcc, run: "echo | gcc -E -dM -"
 #if defined(_M_X64) || defined(__x86_64__)
@@ skipping 32 matching lines @@
 #if !defined(ARCH_IS_64_BIT)
 #error Mismatched Host/Target architectures.
 #endif
 #elif defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
 #if !defined(ARCH_IS_32_BIT)
 #error Mismatched Host/Target architectures.
 #endif
 #endif
 
 
-// Target OS detection.
-// for more information on predefined macros:
-//   - http://msdn.microsoft.com/en-us/library/b0084kay.aspx
-//   - with gcc, run: "echo | gcc -E -dM -"
-#if defined(__linux__) || defined(__FreeBSD__)
-#define TARGET_OS_LINUX 1
-#elif defined(__APPLE__)
-#define TARGET_OS_MACOS 1
-#elif defined(_WIN32)
-#define TARGET_OS_WINDOWS 1
-#else
-#error Automatic target os detection failed.
-#endif
-
-
 // Printf format for intptr_t on Windows.
 #if !defined(PRIxPTR) && defined(TARGET_OS_WINDOWS)
 #if defined(ARCH_IS_32_BIT)
 #define PRIxPTR "x"
 #else
 #define PRIxPTR "llx"
 #endif  // defined(ARCH_IS_32_BIT)
 #endif  // !defined(PRIxPTR) && defined(TARGET_OS_WINDOWS)
 
 
@@ skipping 48 matching lines @@
 const int kMillisecondsPerSecond = 1000;
 const int kMicrosecondsPerMillisecond = 1000;
 const int kMicrosecondsPerSecond = (kMicrosecondsPerMillisecond *
                                     kMillisecondsPerSecond);
 const int kNanosecondsPerMicrosecond = 1000;
 const int kNanosecondsPerMillisecond = (kNanosecondsPerMicrosecond *
                                         kMicrosecondsPerMillisecond);
 const int kNanosecondsPerSecond = (kNanosecondsPerMicrosecond *
                                    kMicrosecondsPerSecond);
 
-// A macro to disallow the copy constructor and operator= functions.
-// This should be used in the private: declarations for a class.
-#define DISALLOW_COPY_AND_ASSIGN(TypeName)                                     \
-private:                                                                       \
-  TypeName(const TypeName&);                                                   \
-  void operator=(const TypeName&)
-
-
-// A macro to disallow all the implicit constructors, namely the default
-// constructor, copy constructor and operator= functions. This should be
-// used in the private: declarations for a class that wants to prevent
-// anyone from instantiating it. This is especially useful for classes
-// containing only static methods.
-#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName)                               \
-private:                                                                       \
-  TypeName();                                                                  \
-  DISALLOW_COPY_AND_ASSIGN(TypeName)
-
-
-// Macro to disallow allocation in the C++ heap. This should be used
-// in the private section for a class.
-#define DISALLOW_ALLOCATION()                                                  \
-public:                                                                        \
-  void operator delete(void* pointer) { UNREACHABLE(); }                       \
-private:                                                                       \
-  void* operator new(size_t size);
-
-
 // The expression ARRAY_SIZE(array) is a compile-time constant of type
 // size_t which represents the number of elements of the given
 // array. You should only use ARRAY_SIZE on statically allocated
 // arrays.
 #define ARRAY_SIZE(array)                                       \
   ((sizeof(array) / sizeof(*(array))) /                         \
   static_cast<intptr_t>(!(sizeof(array) % sizeof(*(array)))))
 
 
 // The expression OFFSET_OF(type, field) computes the byte-offset of
 // the specified field relative to the containing type.
 //
 // The expression OFFSET_OF_RETURNED_VALUE(type, accessor) computes the
 // byte-offset of the return value of the accessor to the containing type.
 //
 // None of these use 0 or NULL, which causes a problem with the compiler
 // warnings we have enabled (which is also why 'offsetof' doesn't seem to work).
 // The workaround is to use the non-zero value kOffsetOfPtr.
 const intptr_t kOffsetOfPtr = 32;
 
 #define OFFSET_OF(type, field)                                                 \
   (reinterpret_cast<intptr_t>(&(reinterpret_cast<type*>(kOffsetOfPtr)->field)) \
       - kOffsetOfPtr)
 
 #define OFFSET_OF_RETURNED_VALUE(type, accessor)                            \
   (reinterpret_cast<intptr_t>(                                              \
       (reinterpret_cast<type*>(kOffsetOfPtr)->accessor())) - kOffsetOfPtr)
 
 
-// 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 convertable to a target type.
 //
 // The From type can be inferred, so the preferred syntax for using
@@ skipping 95 matching lines @@
 // contants are 16 byte aligned.
 #if defined(TARGET_OS_WINDOWS)
 #define ALIGN16 __declspec(align(16))
 #else
 #define ALIGN16 __attribute__((aligned(16)))
 #endif
 
 }  // namespace dart
 
 #endif  // VM_GLOBALS_H_