/*

 * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc.  All rights reserved.

 * Copyright (C) 2007-2009 Torch Mobile, Inc.

 * Copyright (C) Research In Motion Limited 2010. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef WTF_Platform_h

#define WTF_Platform_h

/* ==== PLATFORM handles OS, operating environment, graphics API, and

   CPU. This macro will be phased out in favor of platform adaptation

   macros, policy decision macros, and top-level port definitions. ==== */

#define PLATFORM(WTF_FEATURE) (defined WTF_PLATFORM_##WTF_FEATURE  && WTF_PLATFORM_##WTF_FEATURE)

/* ==== Platform adaptation macros: these describe properties of the target environment. ==== */

/* COMPILER() - the compiler being used to build the project */

#define COMPILER(WTF_FEATURE) (defined WTF_COMPILER_##WTF_FEATURE  && WTF_COMPILER_##WTF_FEATURE)

/* CPU() - the target CPU architecture */

#define CPU(WTF_FEATURE) (defined WTF_CPU_##WTF_FEATURE  && WTF_CPU_##WTF_FEATURE)

/* HAVE() - specific system features (headers, functions or similar) that are present or not */

#define HAVE(WTF_FEATURE) (defined HAVE_##WTF_FEATURE  && HAVE_##WTF_FEATURE)

/* OS() - underlying operating system; only to be used for mandated low-level services like 

   virtual memory, not to choose a GUI toolkit */

#define OS(WTF_FEATURE) (defined WTF_OS_##WTF_FEATURE  && WTF_OS_##WTF_FEATURE)

/* ==== Policy decision macros: these define policy choices for a particular port. ==== */

/* USE() - use a particular third-party library or optional OS service */

#define USE(WTF_FEATURE) (defined WTF_USE_##WTF_FEATURE  && WTF_USE_##WTF_FEATURE)

/* ENABLE() - turn on a specific feature of WebKit */

#define ENABLE(WTF_FEATURE) (defined ENABLE_##WTF_FEATURE  && ENABLE_##WTF_FEATURE)

/* ==== COMPILER() - the compiler being used to build the project ==== */

/* COMPILER(MSVC) Microsoft Visual C++ */

/* COMPILER(MSVC7_OR_LOWER) Microsoft Visual C++ 2003 or lower*/

/* COMPILER(MSVC9_OR_LOWER) Microsoft Visual C++ 2008 or lower*/

#if defined(_MSC_VER)

#define WTF_COMPILER_MSVC 1

#if _MSC_VER < 1400

#define WTF_COMPILER_MSVC7_OR_LOWER 1

#elif _MSC_VER < 1600

#define WTF_COMPILER_MSVC9_OR_LOWER 1

#endif

#endif

/* COMPILER(RVCT)  - ARM RealView Compilation Tools */

#if defined(__CC_ARM) || defined(__ARMCC__)

#define WTF_COMPILER_RVCT 1

#endif

/* COMPILER(GCC) - GNU Compiler Collection */

/* --gnu option of the RVCT compiler also defines __GNUC__ */

#if defined(__GNUC__) && !COMPILER(RVCT)

#define WTF_COMPILER_GCC 1

#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)

#endif

/* COMPILER(MINGW) - MinGW GCC */

/* COMPILER(MINGW64) - mingw-w64 GCC - only used as additional check to exclude mingw.org specific functions */

#if defined(__MINGW32__)

#define WTF_COMPILER_MINGW 1

#include <_mingw.h> /* private MinGW header */

    #if defined(__MINGW64_VERSION_MAJOR) /* best way to check for mingw-w64 vs mingw.org */

        #define WTF_COMPILER_MINGW64 1

    #endif /* __MINGW64_VERSION_MAJOR */

#endif /* __MINGW32__ */

/* COMPILER(WINSCW) - CodeWarrior for Symbian emulator */

#if defined(__WINSCW__)

#define WTF_COMPILER_WINSCW 1

/* cross-compiling, it is not really windows */

#undef WIN32

#undef _WIN32

#endif

/* COMPILER(INTEL) - Intel C++ Compiler */

#if defined(__INTEL_COMPILER)

#define WTF_COMPILER_INTEL 1

#endif

/* ==== CPU() - the target CPU architecture ==== */

/* This also defines CPU(BIG_ENDIAN) or CPU(MIDDLE_ENDIAN) or neither, as appropriate. */

/* CPU(ALPHA) - DEC Alpha */

#if defined(__alpha__)

#define WTF_CPU_ALPHA 1

#endif

/* CPU(IA64) - Itanium / IA-64 */

#if defined(__ia64__)

#define WTF_CPU_IA64 1

/* 32-bit mode on Itanium */

#if !defined(__LP64__)

#define WTF_CPU_IA64_32 1

#endif

#endif

/* CPU(MIPS) - MIPS 32-bit */

/* Note: Only O32 ABI is tested, so we enable it for O32 ABI for now.  */

#if (defined(mips) || defined(__mips__)) \

    && defined(_ABIO32)

#define WTF_CPU_MIPS 1

#if defined(__MIPSEB__)

#define WTF_CPU_BIG_ENDIAN 1

#endif

#define WTF_MIPS_PIC (defined __PIC__)

#define WTF_MIPS_ARCH __mips

#define WTF_MIPS_ISA(v) (defined WTF_MIPS_ARCH && WTF_MIPS_ARCH == v)

#define WTF_MIPS_ISA_AT_LEAST(v) (defined WTF_MIPS_ARCH && WTF_MIPS_ARCH >= v)

#define WTF_MIPS_ARCH_REV __mips_isa_rev

#define WTF_MIPS_ISA_REV(v) (defined WTF_MIPS_ARCH_REV && WTF_MIPS_ARCH_REV == v)

#define WTF_MIPS_DOUBLE_FLOAT (defined __mips_hard_float && !defined __mips_single_float)

#endif /* MIPS */

/* CPU(PPC) - PowerPC 32-bit */

#if   defined(__ppc__)     \

    || defined(__PPC__)     \

    || defined(__powerpc__) \

    || defined(__powerpc)   \

    || defined(__POWERPC__) \

    || defined(_M_PPC)      \

    || defined(__PPC)

#define WTF_CPU_PPC 1

#define WTF_CPU_BIG_ENDIAN 1

#endif

/* CPU(PPC64) - PowerPC 64-bit */

#if   defined(__ppc64__) \

    || defined(__PPC64__)

#define WTF_CPU_PPC64 1

#define WTF_CPU_BIG_ENDIAN 1

#endif

/* CPU(SH4) - SuperH SH-4 */

#if defined(__SH4__)

#define WTF_CPU_SH4 1

#endif

/* CPU(SPARC32) - SPARC 32-bit */

#if defined(__sparc) && !defined(__arch64__) || defined(__sparcv8)

#define WTF_CPU_SPARC32 1

#define WTF_CPU_BIG_ENDIAN 1

#endif

/* CPU(SPARC64) - SPARC 64-bit */

#if defined(__sparc__) && defined(__arch64__) || defined (__sparcv9)

#define WTF_CPU_SPARC64 1

#define WTF_CPU_BIG_ENDIAN 1

#endif

/* CPU(SPARC) - any SPARC, true for CPU(SPARC32) and CPU(SPARC64) */

#if CPU(SPARC32) || CPU(SPARC64)

#define WTF_CPU_SPARC 1

#endif

/* CPU(X86) - i386 / x86 32-bit */

#if   defined(__i386__) \

    || defined(i386)     \

    || defined(_M_IX86)  \

    || defined(_X86_)    \

    || defined(__THW_INTEL)

#define WTF_CPU_X86 1

#endif

/* CPU(X86_64) - AMD64 / Intel64 / x86_64 64-bit */

#if   defined(__x86_64__) \

    || defined(_M_X64)

#define WTF_CPU_X86_64 1

#endif

/* CPU(ARM) - ARM, any version*/

#if   defined(arm) \

    || defined(__arm__) \

    || defined(ARM) \

    || defined(_ARM_)

#define WTF_CPU_ARM 1

#if defined(__ARMEB__)

#define WTF_CPU_BIG_ENDIAN 1

#elif !defined(__ARM_EABI__) \

    && !defined(__EABI__) \

    && !defined(__VFP_FP__) \

    && !defined(_WIN32_WCE) \

    && !defined(ANDROID)

#define WTF_CPU_MIDDLE_ENDIAN 1

#endif

#define WTF_ARM_ARCH_AT_LEAST(N) (CPU(ARM) && WTF_ARM_ARCH_VERSION >= N)

/* Set WTF_ARM_ARCH_VERSION */

#if   defined(__ARM_ARCH_4__) \

    || defined(__ARM_ARCH_4T__) \

    || defined(__MARM_ARMV4__) \

    || defined(_ARMV4I_)

#define WTF_ARM_ARCH_VERSION 4

#elif defined(__ARM_ARCH_5__) \

    || defined(__ARM_ARCH_5T__) \

    || defined(__MARM_ARMV5__)

#define WTF_ARM_ARCH_VERSION 5

#elif defined(__ARM_ARCH_5E__) \

    || defined(__ARM_ARCH_5TE__) \

    || defined(__ARM_ARCH_5TEJ__)

#define WTF_ARM_ARCH_VERSION 5

/*ARMv5TE requires allocators to use aligned memory*/

#define WTF_USE_ARENA_ALLOC_ALIGNMENT_INTEGER 1

#elif defined(__ARM_ARCH_6__) \

    || defined(__ARM_ARCH_6J__) \

    || defined(__ARM_ARCH_6K__) \

    || defined(__ARM_ARCH_6Z__) \

    || defined(__ARM_ARCH_6ZK__) \

    || defined(__ARM_ARCH_6T2__) \

    || defined(__ARMV6__)

#define WTF_ARM_ARCH_VERSION 6

#elif defined(__ARM_ARCH_7A__) \

    || defined(__ARM_ARCH_7R__)

#define WTF_ARM_ARCH_VERSION 7

/* RVCT sets _TARGET_ARCH_ARM */

#elif defined(__TARGET_ARCH_ARM)

#define WTF_ARM_ARCH_VERSION __TARGET_ARCH_ARM

#if defined(__TARGET_ARCH_5E) \

    || defined(__TARGET_ARCH_5TE) \

    || defined(__TARGET_ARCH_5TEJ)

/*ARMv5TE requires allocators to use aligned memory*/

#define WTF_USE_ARENA_ALLOC_ALIGNMENT_INTEGER 1

#endif

#else

#define WTF_ARM_ARCH_VERSION 0

#endif

/* Set WTF_THUMB_ARCH_VERSION */

#if   defined(__ARM_ARCH_4T__)

#define WTF_THUMB_ARCH_VERSION 1

#elif defined(__ARM_ARCH_5T__) \

    || defined(__ARM_ARCH_5TE__) \

    || defined(__ARM_ARCH_5TEJ__)

#define WTF_THUMB_ARCH_VERSION 2

#elif defined(__ARM_ARCH_6J__) \

    || defined(__ARM_ARCH_6K__) \

    || defined(__ARM_ARCH_6Z__) \

    || defined(__ARM_ARCH_6ZK__) \

    || defined(__ARM_ARCH_6M__)

#define WTF_THUMB_ARCH_VERSION 3

#elif defined(__ARM_ARCH_6T2__) \

    || defined(__ARM_ARCH_7__) \

    || defined(__ARM_ARCH_7A__) \

    || defined(__ARM_ARCH_7R__) \

    || defined(__ARM_ARCH_7M__)

#define WTF_THUMB_ARCH_VERSION 4

/* RVCT sets __TARGET_ARCH_THUMB */

#elif defined(__TARGET_ARCH_THUMB)

#define WTF_THUMB_ARCH_VERSION __TARGET_ARCH_THUMB

#else

#define WTF_THUMB_ARCH_VERSION 0

#endif

/* CPU(ARMV5_OR_LOWER) - ARM instruction set v5 or earlier */

/* On ARMv5 and below the natural alignment is required. 

   And there are some other differences for v5 or earlier. */

#if !defined(ARMV5_OR_LOWER) && !WTF_ARM_ARCH_AT_LEAST(6)

#define WTF_CPU_ARMV5_OR_LOWER 1

#endif

/* CPU(ARM_TRADITIONAL) - Thumb2 is not available, only traditional ARM (v4 or greater) */

/* CPU(ARM_THUMB2) - Thumb2 instruction set is available */

/* Only one of these will be defined. */

#if !defined(WTF_CPU_ARM_TRADITIONAL) && !defined(WTF_CPU_ARM_THUMB2)

#  if defined(thumb2) || defined(__thumb2__) \

    || ((defined(__thumb) || defined(__thumb__)) && WTF_THUMB_ARCH_VERSION == 4)

#    define WTF_CPU_ARM_TRADITIONAL 0

#    define WTF_CPU_ARM_THUMB2 1

#  elif WTF_ARM_ARCH_AT_LEAST(4)

#    define WTF_CPU_ARM_TRADITIONAL 1

#    define WTF_CPU_ARM_THUMB2 0

#  else

#    error "Not supported ARM architecture"

#  endif

#elif CPU(ARM_TRADITIONAL) && CPU(ARM_THUMB2) /* Sanity Check */

#  error "Cannot use both of WTF_CPU_ARM_TRADITIONAL and WTF_CPU_ARM_THUMB2 platforms"

#endif /* !defined(WTF_CPU_ARM_TRADITIONAL) && !defined(WTF_CPU_ARM_THUMB2) */

#endif /* ARM */

/* ==== OS() - underlying operating system; only to be used for mandated low-level services like 

   virtual memory, not to choose a GUI toolkit ==== */

/* OS(ANDROID) - Android */

#ifdef ANDROID

#define WTF_OS_ANDROID 1

#endif

/* OS(AIX) - AIX */

#ifdef _AIX

#define WTF_OS_AIX 1

#endif

/* OS(DARWIN) - Any Darwin-based OS, including Mac OS X and iPhone OS */

#ifdef __APPLE__

#define WTF_OS_DARWIN 1

/* FIXME: BUILDING_ON_.., and TARGETING... macros should be folded into the OS() system */

#include <AvailabilityMacros.h>

#if !defined(MAC_OS_X_VERSION_10_5) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5

#define BUILDING_ON_TIGER 1

#elif !defined(MAC_OS_X_VERSION_10_6) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6

#define BUILDING_ON_LEOPARD 1

#elif !defined(MAC_OS_X_VERSION_10_7) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7

#define BUILDING_ON_SNOW_LEOPARD 1

#endif

#if !defined(MAC_OS_X_VERSION_10_5) || MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5

#define TARGETING_TIGER 1

#elif !defined(MAC_OS_X_VERSION_10_6) || MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_6

#define TARGETING_LEOPARD 1

#elif !defined(MAC_OS_X_VERSION_10_7) || MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_7

#define TARGETING_SNOW_LEOPARD 1

#endif

#include <TargetConditionals.h>

#endif

/* OS(IPHONE_OS) - iPhone OS */

/* OS(MAC_OS_X) - Mac OS X (not including iPhone OS) */

#if OS(DARWIN) && ((defined(TARGET_OS_EMBEDDED) && TARGET_OS_EMBEDDED)  \

    || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)                   \

    || (defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR))

#define WTF_OS_IPHONE_OS 1

#elif OS(DARWIN) && defined(TARGET_OS_MAC) && TARGET_OS_MAC

#define WTF_OS_MAC_OS_X 1

#endif

/* OS(FREEBSD) - FreeBSD */

#ifdef __FreeBSD__

#define WTF_OS_FREEBSD 1

#endif

/* OS(HAIKU) - Haiku */

#ifdef __HAIKU__

#define WTF_OS_HAIKU 1

#endif

/* OS(LINUX) - Linux */

#ifdef __linux__

#define WTF_OS_LINUX 1

#endif

/* OS(NETBSD) - NetBSD */

#if defined(__NetBSD__)

#define WTF_PLATFORM_NETBSD 1

#endif

/* OS(OPENBSD) - OpenBSD */

#ifdef __OpenBSD__

#define WTF_OS_OPENBSD 1

#endif

/* OS(QNX) - QNX */

#if defined(__QNXNTO__)

#define WTF_OS_QNX 1

#endif

/* OS(SOLARIS) - Solaris */

#if defined(sun) || defined(__sun)

#define WTF_OS_SOLARIS 1

#endif

/* OS(WINCE) - Windows CE; note that for this platform OS(WINDOWS) is also defined */

#if defined(_WIN32_WCE)

#define WTF_OS_WINCE 1

#endif

/* OS(WINDOWS) - Any version of Windows */

#if defined(WIN32) || defined(_WIN32)

#define WTF_OS_WINDOWS 1

#endif

/* OS(SYMBIAN) - Symbian */

#if defined (__SYMBIAN32__)

#define WTF_OS_SYMBIAN 1

#endif

/* OS(UNIX) - Any Unix-like system */

#if   OS(AIX)              \

    || OS(ANDROID)          \

    || OS(DARWIN)           \

    || OS(FREEBSD)          \

    || OS(HAIKU)            \

    || OS(LINUX)            \

    || OS(NETBSD)           \

    || OS(OPENBSD)          \

    || OS(QNX)              \

    || OS(SOLARIS)          \

    || OS(SYMBIAN)          \

    || defined(unix)        \

    || defined(__unix)      \

    || defined(__unix__)

#define WTF_OS_UNIX 1

#endif

/* Operating environments */

/* FIXME: these are all mixes of OS, operating environment and policy choices. */

/* PLATFORM(CHROMIUM) */

/* PLATFORM(QT) */

/* PLATFORM(WX) */

/* PLATFORM(GTK) */

/* PLATFORM(HAIKU) */

/* PLATFORM(MAC) */

/* PLATFORM(WIN) */

#if defined(BUILDING_CHROMIUM__)

#define WTF_PLATFORM_CHROMIUM 1

#elif defined(BUILDING_QT__)

#define WTF_PLATFORM_QT 1

#elif defined(BUILDING_WX__)

#define WTF_PLATFORM_WX 1

#elif defined(BUILDING_GTK__)

#define WTF_PLATFORM_GTK 1

#elif defined(BUILDING_HAIKU__)

#define WTF_PLATFORM_HAIKU 1

#elif defined(BUILDING_BREWMP__)

#define WTF_PLATFORM_BREWMP 1

#if defined(AEE_SIMULATOR)

#define WTF_PLATFORM_BREWMP_SIMULATOR 1

#else

#define WTF_PLATFORM_BREWMP_SIMULATOR 0

#endif

#undef WTF_OS_WINDOWS

#undef WTF_PLATFORM_WIN

#elif OS(DARWIN)

#define WTF_PLATFORM_MAC 1

#elif OS(WINDOWS)

#define WTF_PLATFORM_WIN 1

#endif

/* PLATFORM(IPHONE) */

/* FIXME: this is sometimes used as an OS switch and sometimes for higher-level things */

#if (defined(TARGET_OS_EMBEDDED) && TARGET_OS_EMBEDDED) || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)

#define WTF_PLATFORM_IPHONE 1

#endif

/* PLATFORM(IPHONE_SIMULATOR) */

#if defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR

#define WTF_PLATFORM_IPHONE 1

#define WTF_PLATFORM_IPHONE_SIMULATOR 1

#else

#define WTF_PLATFORM_IPHONE_SIMULATOR 0

#endif

#if !defined(WTF_PLATFORM_IPHONE)

#define WTF_PLATFORM_IPHONE 0

#endif

/* PLATFORM(ANDROID) */

/* FIXME: this is sometimes used as an OS() switch, and other times to drive

   policy choices */

#if defined(ANDROID)

#define WTF_PLATFORM_ANDROID 1

#endif

/* Graphics engines */

/* PLATFORM(CG) and PLATFORM(CI) */

#if PLATFORM(MAC) || PLATFORM(IPHONE)

#define WTF_PLATFORM_CG 1

#endif

#if PLATFORM(MAC) && !PLATFORM(IPHONE)

#define WTF_PLATFORM_CI 1

#endif

/* PLATFORM(SKIA) for Win/Linux, CG/CI for Mac */

#if PLATFORM(CHROMIUM)

#define ENABLE_HISTORY_ALWAYS_ASYNC 1

#if OS(DARWIN)

#define WTF_PLATFORM_CG 1

#define WTF_PLATFORM_CI 1

#define WTF_USE_ATSUI 1

#define WTF_USE_CORE_TEXT 1

#else

#define WTF_PLATFORM_SKIA 1

#endif

#endif

#if PLATFORM(BREWMP)