R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity
r5sdk/r5dev/thirdparty/ea/EABase/config/eacompiler.h
Kawe Mazidjatari b3a68ed095 Add EABase, EAThread and DirtySDK to R5sdk 
DirtySDK (EA's Dirty Sockets library) will be used for the LiveAPI implementation, and depends on: EABase, EAThread.
2024-04-05 18:29:03 +02:00

1779 lines
75 KiB
C++
Raw Blame History

/*-----------------------------------------------------------------------------
* config/eacompiler.h
*
* Copyright (c) Electronic Arts Inc. All rights reserved.
*-----------------------------------------------------------------------------
* Currently supported defines include:
* EA_COMPILER_GNUC
* EA_COMPILER_ARM
* EA_COMPILER_EDG
* EA_COMPILER_SN
* EA_COMPILER_MSVC
* EA_COMPILER_METROWERKS
* EA_COMPILER_INTEL
* EA_COMPILER_BORLANDC
* EA_COMPILER_IBM
* EA_COMPILER_QNX
* EA_COMPILER_GREEN_HILLS
* EA_COMPILER_CLANG
* EA_COMPILER_CLANG_CL
*
* EA_COMPILER_VERSION = <integer>
* EA_COMPILER_NAME = <string>
* EA_COMPILER_STRING = <string>
*
* EA_COMPILER_VA_COPY_REQUIRED
*
* C++98/03 functionality
* EA_COMPILER_NO_STATIC_CONSTANTS
* EA_COMPILER_NO_TEMPLATE_SPECIALIZATION
* EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION
* EA_COMPILER_NO_MEMBER_TEMPLATES
* EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION
* EA_COMPILER_NO_TEMPLATE_TEMPLATES
* EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS
* EA_COMPILER_NO_VOID_RETURNS
* EA_COMPILER_NO_COVARIANT_RETURN_TYPE
* EA_COMPILER_NO_DEDUCED_TYPENAME
* EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP
* EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE
* EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
* EA_COMPILER_NO_RTTI
* EA_COMPILER_NO_EXCEPTIONS
* EA_COMPILER_NO_NEW_THROW_SPEC
* EA_THROW_SPEC_NEW / EA_THROW_SPEC_DELETE
* EA_COMPILER_NO_UNWIND
* EA_COMPILER_NO_STANDARD_CPP_LIBRARY
* EA_COMPILER_NO_STATIC_VARIABLE_INIT
* EA_COMPILER_NO_STATIC_FUNCTION_INIT
* EA_COMPILER_NO_VARIADIC_MACROS
*
* C++11 functionality
* EA_COMPILER_NO_RVALUE_REFERENCES
* EA_COMPILER_NO_EXTERN_TEMPLATE
* EA_COMPILER_NO_RANGE_BASED_FOR_LOOP
* EA_COMPILER_NO_CONSTEXPR
* EA_COMPILER_NO_OVERRIDE
* EA_COMPILER_NO_INHERITANCE_FINAL
* EA_COMPILER_NO_NULLPTR
* EA_COMPILER_NO_AUTO
* EA_COMPILER_NO_DECLTYPE
* EA_COMPILER_NO_DEFAULTED_FUNCTIONS
* EA_COMPILER_NO_DELETED_FUNCTIONS
* EA_COMPILER_NO_LAMBDA_EXPRESSIONS
* EA_COMPILER_NO_TRAILING_RETURN_TYPES
* EA_COMPILER_NO_STRONGLY_TYPED_ENUMS
* EA_COMPILER_NO_FORWARD_DECLARED_ENUMS
* EA_COMPILER_NO_VARIADIC_TEMPLATES
* EA_COMPILER_NO_TEMPLATE_ALIASES
* EA_COMPILER_NO_INITIALIZER_LISTS
* EA_COMPILER_NO_NORETURN
* EA_COMPILER_NO_CARRIES_DEPENDENCY
* EA_COMPILER_NO_FALLTHROUGH
* EA_COMPILER_NO_NODISCARD
* EA_COMPILER_NO_MAYBE_UNUSED
* EA_COMPILER_NO_NONSTATIC_MEMBER_INITIALIZERS
* EA_COMPILER_NO_RIGHT_ANGLE_BRACKETS
* EA_COMPILER_NO_ALIGNOF
* EA_COMPILER_NO_ALIGNAS
* EA_COMPILER_NO_DELEGATING_CONSTRUCTORS
* EA_COMPILER_NO_INHERITING_CONSTRUCTORS
* EA_COMPILER_NO_USER_DEFINED_LITERALS
* EA_COMPILER_NO_STANDARD_LAYOUT_TYPES
* EA_COMPILER_NO_EXTENDED_SIZEOF
* EA_COMPILER_NO_INLINE_NAMESPACES
* EA_COMPILER_NO_UNRESTRICTED_UNIONS
* EA_COMPILER_NO_EXPLICIT_CONVERSION_OPERATORS
* EA_COMPILER_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
* EA_COMPILER_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
* EA_COMPILER_NO_NOEXCEPT
* EA_COMPILER_NO_RAW_LITERALS
* EA_COMPILER_NO_UNICODE_STRING_LITERALS
* EA_COMPILER_NO_NEW_CHARACTER_TYPES
* EA_COMPILER_NO_UNICODE_CHAR_NAME_LITERALS
* EA_COMPILER_NO_UNIFIED_INITIALIZATION_SYNTAX
* EA_COMPILER_NO_EXTENDED_FRIEND_DECLARATIONS
*
* C++14 functionality
* EA_COMPILER_NO_VARIABLE_TEMPLATES
*
* C++17 functionality
* EA_COMPILER_NO_INLINE_VARIABLES
* EA_COMPILER_NO_ALIGNED_NEW
*
* C++20 functionality
* EA_COMPILER_NO_DESIGNATED_INITIALIZERS
*
*-----------------------------------------------------------------------------
*
* Supplemental documentation
* EA_COMPILER_NO_STATIC_CONSTANTS
* Code such as this is legal, but some compilers fail to compile it:
* struct A{ static const a = 1; };
*
* EA_COMPILER_NO_TEMPLATE_SPECIALIZATION
* Some compilers fail to allow template specialization, such as with this:
* template<class U> void DoSomething(U u);
* void DoSomething(int x);
*
* EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION
* Some compilers fail to allow partial template specialization, such as with this:
* template <class T, class Allocator> class vector{ }; // Primary templated class.
* template <class Allocator> class vector<bool, Allocator>{ }; // Partially specialized version.
*
* EA_COMPILER_NO_MEMBER_TEMPLATES
* Some compilers fail to allow member template functions such as this:
* struct A{ template<class U> void DoSomething(U u); };
*
* EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION
* Some compilers fail to allow member template specialization, such as with this:
* struct A{
* template<class U> void DoSomething(U u);
* void DoSomething(int x);
* };
*
* EA_COMPILER_NO_TEMPLATE_TEMPLATES
* Code such as this is legal:
* template<typename T, template<typename> class U>
* U<T> SomeFunction(const U<T> x) { return x.DoSomething(); }
*
* EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS
* Some compilers fail to compile templated friends, as with this:
* struct A{ template<class U> friend class SomeFriend; };
* This is described in the C++ Standard at 14.5.3.
*
* EA_COMPILER_NO_VOID_RETURNS
* This is legal C++:
* void DoNothing1(){ };
* void DoNothing2(){ return DoNothing1(); }
*
* EA_COMPILER_NO_COVARIANT_RETURN_TYPE
* See the C++ standard sec 10.3,p5.
*
* EA_COMPILER_NO_DEDUCED_TYPENAME
* Some compilers don't support the use of 'typename' for
* dependent types in deduced contexts, as with this:
* template <class T> void Function(T, typename T::type);
*
* EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP
* Also known as Koenig lookup. Basically, if you have a function
* that is a namespace and you call that function without prefixing
* it with the namespace the compiler should look at any arguments
* you pass to that function call and search their namespace *first*
* to see if the given function exists there.
*
* EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE
* <exception> is in namespace std. Some std libraries fail to
* put the contents of <exception> in namespace std. The following
* code should normally be legal:
* void Function(){ std::terminate(); }
*
* EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
* Some compilers fail to execute DoSomething() properly, though they
* succeed in compiling it, as with this:
* template <int i>
* bool DoSomething(int j){ return i == j; };
* DoSomething<1>(2);
*
* EA_COMPILER_NO_EXCEPTIONS
* The compiler is configured to disallow the use of try/throw/catch
* syntax (often to improve performance). Use of such syntax in this
* case will cause a compilation error.
*
* EA_COMPILER_NO_UNWIND
* The compiler is configured to allow the use of try/throw/catch
* syntax and behaviour but disables the generation of stack unwinding
* code for responding to exceptions (often to improve performance).
*
*---------------------------------------------------------------------------*/
#ifndef INCLUDED_eacompiler_H
#define INCLUDED_eacompiler_H
#include <EABase/config/eaplatform.h>
// Note: This is used to generate the EA_COMPILER_STRING macros
#ifndef INTERNAL_STRINGIZE
#define INTERNAL_STRINGIZE(x) INTERNAL_PRIMITIVE_STRINGIZE(x)
#endif
#ifndef INTERNAL_PRIMITIVE_STRINGIZE
#define INTERNAL_PRIMITIVE_STRINGIZE(x) #x
#endif
// EA_COMPILER_HAS_FEATURE
#ifndef EA_COMPILER_HAS_FEATURE
#if defined(__clang__)
#define EA_COMPILER_HAS_FEATURE(x) __has_feature(x)
#else
#define EA_COMPILER_HAS_FEATURE(x) 0
#endif
#endif
// EA_COMPILER_HAS_BUILTIN
#ifndef EA_COMPILER_HAS_BUILTIN
#if defined(__clang__)
#define EA_COMPILER_HAS_BUILTIN(x) __has_builtin(x)
#else
#define EA_COMPILER_HAS_BUILTIN(x) 0
#endif
#endif
// EDG (EDG compiler front-end, used by other compilers such as SN)
#if defined(__EDG_VERSION__)
#define EA_COMPILER_EDG 1
#if defined(_MSC_VER)
#define EA_COMPILER_EDG_VC_MODE 1
#endif
#if defined(__GNUC__)
#define EA_COMPILER_EDG_GCC_MODE 1
#endif
#endif
// EA_COMPILER_WINRTCX_ENABLED
//
// Defined as 1 if the compiler has its available C++/CX support enabled, else undefined.
// This specifically means the corresponding compilation unit has been built with Windows Runtime
// Components enabled, usually via the '-ZW' compiler flags being used. This option allows for using
// ref counted hat-type '^' objects and other C++/CX specific keywords like "ref new"
#if !defined(EA_COMPILER_WINRTCX_ENABLED) && defined(__cplusplus_winrt)
#define EA_COMPILER_WINRTCX_ENABLED 1
#endif
// EA_COMPILER_CPP11_ENABLED
//
// Defined as 1 if the compiler has its available C++11 support enabled, else undefined.
// This does not mean that all of C++11 or any particular feature of C++11 is supported
// by the compiler. It means that whatever C++11 support the compiler has is enabled.
// This also includes existing and older compilers that still identify C++11 as C++0x.
//
// We cannot use (__cplusplus >= 201103L) alone because some compiler vendors have
// decided to not define __cplusplus like thus until they have fully completed their
// C++11 support.
//
#if !defined(EA_COMPILER_CPP11_ENABLED) && defined(__cplusplus)
#if (__cplusplus >= 201103L) // Clang and GCC defines this like so in C++11 mode.
#define EA_COMPILER_CPP11_ENABLED 1
#elif defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
#define EA_COMPILER_CPP11_ENABLED 1
#elif defined(_MSC_VER) && _MSC_VER >= 1600 // Microsoft unilaterally enables its C++11 support; there is no way to disable it.
#define EA_COMPILER_CPP11_ENABLED 1
#elif defined(__EDG_VERSION__) // && ???
// To do: Is there a generic way to determine this?
#endif
#endif
// EA_COMPILER_CPP14_ENABLED
//
// Defined as 1 if the compiler has its available C++14 support enabled, else undefined.
// This does not mean that all of C++14 or any particular feature of C++14 is supported
// by the compiler. It means that whatever C++14 support the compiler has is enabled.
//
// We cannot use (__cplusplus >= 201402L) alone because some compiler vendors have
// decided to not define __cplusplus like thus until they have fully completed their
// C++14 support.
#if !defined(EA_COMPILER_CPP14_ENABLED) && defined(__cplusplus)
#if (__cplusplus >= 201402L) // Clang and GCC defines this like so in C++14 mode.
#define EA_COMPILER_CPP14_ENABLED 1
#elif defined(_MSC_VER) && (_MSC_VER >= 1900) // VS2015+
#define EA_COMPILER_CPP14_ENABLED 1
#endif
#endif
// EA_COMPILER_CPP17_ENABLED
//
// Defined as 1 if the compiler has its available C++17 support enabled, else undefined.
// This does not mean that all of C++17 or any particular feature of C++17 is supported
// by the compiler. It means that whatever C++17 support the compiler has is enabled.
//
// We cannot use (__cplusplus >= 201703L) alone because some compiler vendors have
// decided to not define __cplusplus like thus until they have fully completed their
// C++17 support.
#if !defined(EA_COMPILER_CPP17_ENABLED) && defined(__cplusplus)
#if (__cplusplus >= 201703L)
#define EA_COMPILER_CPP17_ENABLED 1
#elif defined(_MSVC_LANG) && (_MSVC_LANG >= 201703L) // C++17+
#define EA_COMPILER_CPP17_ENABLED 1
#endif
#endif
// EA_COMPILER_CPP20_ENABLED
//
// Defined as 1 if the compiler has its available C++20 support enabled, else undefined.
// This does not mean that all of C++20 or any particular feature of C++20 is supported
// by the compiler. It means that whatever C++20 support the compiler has is enabled.
//
// We cannot use (__cplusplus >= 202003L) alone because some compiler vendors have
// decided to not define __cplusplus like thus until they have fully completed their
// C++20 support.
#if !defined(EA_COMPILER_CPP20_ENABLED) && defined(__cplusplus)
// TODO(rparoin): enable once a C++20 value for the __cplusplus macro has been published
// #if (__cplusplus >= 202003L)
// #define EA_COMPILER_CPP20_ENABLED 1
// #elif defined(_MSVC_LANG) && (_MSVC_LANG >= 202003L) // C++20+
// #define EA_COMPILER_CPP20_ENABLED 1
// #endif
#endif
#if defined(__ARMCC_VERSION)
// Note that this refers to the ARM RVCT compiler (armcc or armcpp), but there
// are other compilers that target ARM processors, such as GCC and Microsoft VC++.
// If you want to detect compiling for the ARM processor, check for EA_PROCESSOR_ARM
// being defined.
// This compiler is also identified by defined(__CC_ARM) || defined(__ARMCC__).
#define EA_COMPILER_RVCT 1
#define EA_COMPILER_ARM 1
#define EA_COMPILER_VERSION __ARMCC_VERSION
#define EA_COMPILER_NAME "RVCT"
//#define EA_COMPILER_STRING (defined below)
// Clang's GCC-compatible driver.
#elif defined(__clang__) && !defined(_MSC_VER)
#define EA_COMPILER_CLANG 1
#define EA_COMPILER_VERSION (__clang_major__ * 100 + __clang_minor__)
#define EA_COMPILER_NAME "clang"
#define EA_COMPILER_STRING EA_COMPILER_NAME __clang_version__
// GCC (a.k.a. GNUC)
#elif defined(__GNUC__) // GCC compilers exist for many platforms.
#define EA_COMPILER_GNUC 1
#define EA_COMPILER_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
#define EA_COMPILER_NAME "GCC"
#define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( __GNUC__ ) "." INTERNAL_STRINGIZE( __GNUC_MINOR__ )
#if (__GNUC__ == 2) && (__GNUC_MINOR__ < 95) // If GCC < 2.95...
#define EA_COMPILER_NO_MEMBER_TEMPLATES 1
#endif
#if (__GNUC__ == 2) && (__GNUC_MINOR__ <= 97) // If GCC <= 2.97...
#define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 1
#endif
#if (__GNUC__ == 3) && ((__GNUC_MINOR__ == 1) || (__GNUC_MINOR__ == 2)) // If GCC 3.1 or 3.2 (but not pre 3.1 or post 3.2)...
#define EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 1
#endif
// Borland C++
#elif defined(__BORLANDC__)
#define EA_COMPILER_BORLANDC 1
#define EA_COMPILER_VERSION __BORLANDC__
#define EA_COMPILER_NAME "Borland C"
//#define EA_COMPILER_STRING (defined below)
#if (__BORLANDC__ <= 0x0550) // If Borland C++ Builder 4 and 5...
#define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 1
#endif
#if (__BORLANDC__ >= 0x561) && (__BORLANDC__ < 0x600)
#define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION 1
#endif
// Intel C++
// The Intel Windows compiler masquerades as VC++ and defines _MSC_VER.
// The Intel compiler is based on the EDG compiler front-end.
#elif defined(__ICL) || defined(__ICC)
#define EA_COMPILER_INTEL 1
// Should we enable the following? We probably should do so since enabling it does a lot more good than harm
// for users. The Intel Windows compiler does a pretty good job of emulating VC++ and so the user would likely
// have to handle few special cases where the Intel compiler doesn't emulate VC++ correctly.
#if defined(_MSC_VER)
#define EA_COMPILER_MSVC 1
#define EA_COMPILER_MICROSOFT 1
#endif
// Should we enable the following? This isn't as clear because as of this writing we don't know if the Intel
// compiler truly emulates GCC well enough that enabling this does more good than harm.
#if defined(__GNUC__)
#define EA_COMPILER_GNUC 1
#endif
#if defined(__ICL)
#define EA_COMPILER_VERSION __ICL
#elif defined(__ICC)
#define EA_COMPILER_VERSION __ICC
#endif
#define EA_COMPILER_NAME "Intel C++"
#if defined(_MSC_VER)
#define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( EA_COMPILER_VERSION ) ", EDG version " INTERNAL_STRINGIZE( __EDG_VERSION__ ) ", VC++ version " INTERNAL_STRINGIZE( _MSC_VER )
#elif defined(__GNUC__)
#define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( EA_COMPILER_VERSION ) ", EDG version " INTERNAL_STRINGIZE( __EDG_VERSION__ ) ", GCC version " INTERNAL_STRINGIZE( __GNUC__ )
#else
#define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( EA_COMPILER_VERSION ) ", EDG version " INTERNAL_STRINGIZE( __EDG_VERSION__ )
#endif
#elif defined(_MSC_VER)
#define EA_COMPILER_MSVC 1
#define EA_COMPILER_MICROSOFT 1
#define EA_COMPILER_VERSION _MSC_VER
#define EA_COMPILER_NAME "Microsoft Visual C++"
//#define EA_COMPILER_STRING (defined below)
#if defined(__clang__)
// Clang's MSVC-compatible driver.
#define EA_COMPILER_CLANG_CL 1
#endif
#define EA_STANDARD_LIBRARY_MSVC 1
#define EA_STANDARD_LIBRARY_MICROSOFT 1
#if (_MSC_VER <= 1200) // If VC6.x and earlier...
#if (_MSC_VER < 1200)
#define EA_COMPILER_MSVCOLD 1
#else
#define EA_COMPILER_MSVC6 1
#endif
#if (_MSC_VER < 1200) // If VC5.x or earlier...
#define EA_COMPILER_NO_TEMPLATE_SPECIALIZATION 1
#endif
#define EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 1 // The compiler compiles this OK, but executes it wrong. Fixed in VC7.0
#define EA_COMPILER_NO_VOID_RETURNS 1 // The compiler fails to compile such cases. Fixed in VC7.0
#define EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE 1 // The compiler fails to compile such cases. Fixed in VC7.0
#define EA_COMPILER_NO_DEDUCED_TYPENAME 1 // The compiler fails to compile such cases. Fixed in VC7.0
#define EA_COMPILER_NO_STATIC_CONSTANTS 1 // The compiler fails to compile such cases. Fixed in VC7.0
#define EA_COMPILER_NO_COVARIANT_RETURN_TYPE 1 // The compiler fails to compile such cases. Fixed in VC7.1
#define EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP 1 // The compiler compiles this OK, but executes it wrong. Fixed in VC7.1
#define EA_COMPILER_NO_TEMPLATE_TEMPLATES 1 // The compiler fails to compile such cases. Fixed in VC7.1
#define EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION 1 // The compiler fails to compile such cases. Fixed in VC7.1
#define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 1 // The compiler fails to compile such cases. Fixed in VC7.1
//#define EA_COMPILER_NO_MEMBER_TEMPLATES 1 // VC6.x supports member templates properly 95% of the time. So do we flag the remaining 5%?
//#define EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION 1 // VC6.x supports member templates properly 95% of the time. So do we flag the remaining 5%?
#elif (_MSC_VER <= 1300) // If VC7.0 and earlier...
#define EA_COMPILER_MSVC7 1
#define EA_COMPILER_NO_COVARIANT_RETURN_TYPE 1 // The compiler fails to compile such cases. Fixed in VC7.1
#define EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP 1 // The compiler compiles this OK, but executes it wrong. Fixed in VC7.1
#define EA_COMPILER_NO_TEMPLATE_TEMPLATES 1 // The compiler fails to compile such cases. Fixed in VC7.1
#define EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION 1 // The compiler fails to compile such cases. Fixed in VC7.1
#define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 1 // The compiler fails to compile such cases. Fixed in VC7.1
#define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION 1 // This is the case only for VC7.0 and not VC6 or VC7.1+. Fixed in VC7.1
//#define EA_COMPILER_NO_MEMBER_TEMPLATES 1 // VC7.0 supports member templates properly 95% of the time. So do we flag the remaining 5%?
#elif (_MSC_VER < 1400) // VS2003 _MSC_VER of 1300 means VC7 (VS2003)
// The VC7.1 and later compiler is fairly close to the C++ standard
// and thus has no compiler limitations that we are concerned about.
#define EA_COMPILER_MSVC7_2003 1
#define EA_COMPILER_MSVC7_1 1
#elif (_MSC_VER < 1500) // VS2005 _MSC_VER of 1400 means VC8 (VS2005)
#define EA_COMPILER_MSVC8_2005 1
#define EA_COMPILER_MSVC8_0 1
#elif (_MSC_VER < 1600) // VS2008. _MSC_VER of 1500 means VC9 (VS2008)
#define EA_COMPILER_MSVC9_2008 1
#define EA_COMPILER_MSVC9_0 1
#elif (_MSC_VER < 1700) // VS2010 _MSC_VER of 1600 means VC10 (VS2010)
#define EA_COMPILER_MSVC_2010 1
#define EA_COMPILER_MSVC10_0 1
#elif (_MSC_VER < 1800) // VS2012 _MSC_VER of 1700 means VS2011/VS2012
#define EA_COMPILER_MSVC_2011 1 // Microsoft changed the name to VS2012 before shipping, despite referring to it as VS2011 up to just a few weeks before shipping.
#define EA_COMPILER_MSVC11_0 1
#define EA_COMPILER_MSVC_2012 1
#define EA_COMPILER_MSVC12_0 1
#elif (_MSC_VER < 1900) // VS2013 _MSC_VER of 1800 means VS2013
#define EA_COMPILER_MSVC_2013 1
#define EA_COMPILER_MSVC13_0 1
#elif (_MSC_VER < 1910) // VS2015 _MSC_VER of 1900 means VS2015
#define EA_COMPILER_MSVC_2015 1
#define EA_COMPILER_MSVC14_0 1
#elif (_MSC_VER < 1911) // VS2017 _MSC_VER of 1910 means VS2017
#define EA_COMPILER_MSVC_2017 1
#define EA_COMPILER_MSVC15_0 1
#endif
// IBM
#elif defined(__xlC__)
#define EA_COMPILER_IBM 1
#define EA_COMPILER_NAME "IBM XL C"
#define EA_COMPILER_VERSION __xlC__
#define EA_COMPILER_STRING "IBM XL C compiler, version " INTERNAL_STRINGIZE( __xlC__ )
// Unknown
#else // Else the compiler is unknown
#define EA_COMPILER_VERSION 0
#define EA_COMPILER_NAME "Unknown"
#endif
#ifndef EA_COMPILER_STRING
#define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE(EA_COMPILER_VERSION)
#endif
// Deprecated definitions
// For backwards compatibility, should be supported for at least the life of EABase v2.0.x.
#ifndef EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#define EA_COMPILER_PARTIAL_TEMPLATE_SPECIALIZATION 1
#endif
#ifndef EA_COMPILER_NO_TEMPLATE_SPECIALIZATION
#define EA_COMPILER_TEMPLATE_SPECIALIZATION 1
#endif
#ifndef EA_COMPILER_NO_MEMBER_TEMPLATES
#define EA_COMPILER_MEMBER_TEMPLATES 1
#endif
#ifndef EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION
#define EA_COMPILER_MEMBER_TEMPLATE_SPECIALIZATION 1
#endif
///////////////////////////////////////////////////////////////////////////////
// EA_COMPILER_VA_COPY_REQUIRED
//
// Defines whether va_copy must be used to copy or save va_list objects between uses.
// Some compilers on some platforms implement va_list whereby its contents
// are destroyed upon usage, even if passed by value to another function.
// With these compilers you can use va_copy to save and restore a va_list.
// Known compiler/platforms that destroy va_list contents upon usage include:
// CodeWarrior on PowerPC
// GCC on x86-64
// However, va_copy is part of the C99 standard and not part of earlier C and
// C++ standards. So not all compilers support it. VC++ doesn't support va_copy,
// but it turns out that VC++ doesn't usually need it on the platforms it supports,
// and va_copy can usually be implemented via memcpy(va_list, va_list) with VC++.
///////////////////////////////////////////////////////////////////////////////
#ifndef EA_COMPILER_VA_COPY_REQUIRED
#if ((defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__clang__)) && (!defined(__i386__) || defined(__x86_64__)) && !defined(__ppc__) && !defined(__PPC__) && !defined(__PPC64__)
#define EA_COMPILER_VA_COPY_REQUIRED 1
#endif
#endif
// EA_COMPILER_NO_RTTI
//
// If EA_COMPILER_NO_RTTI is defined, then RTTI (run-time type information)
// is not available (possibly due to being disabled by the user).
//
#if defined(__EDG_VERSION__) && !defined(__RTTI)
#define EA_COMPILER_NO_RTTI 1
#elif defined(__clang__) && !EA_COMPILER_HAS_FEATURE(cxx_rtti)
#define EA_COMPILER_NO_RTTI 1
#elif defined(__IBMCPP__) && !defined(__RTTI_ALL__)
#define EA_COMPILER_NO_RTTI 1
#elif defined(__GXX_ABI_VERSION) && !defined(__GXX_RTTI)
#define EA_COMPILER_NO_RTTI 1
#elif defined(_MSC_VER) && !defined(_CPPRTTI)
#define EA_COMPILER_NO_RTTI 1
#elif defined(__ARMCC_VERSION) && defined(__TARGET_CPU_MPCORE) && !defined(__RTTI)
#define EA_COMPILER_NO_RTTI 1
#endif
// EA_COMPILER_NO_EXCEPTIONS / EA_COMPILER_NO_UNWIND
//
// If EA_COMPILER_NO_EXCEPTIONS is defined, then the compiler is
// configured to not recognize C++ exception-handling statements
// such as try/catch/throw. Thus, when EA_COMPILER_NO_EXCEPTIONS is
// defined, code that attempts to use exception handling statements
// will usually cause a compilation error. If is often desirable
// for projects to disable exception handling because exception
// handling causes extra code and/or data generation which might
// not be needed, especially if it is known that exceptions won't
// be happening. When writing code that is to be portable between
// systems of which some enable exception handling while others
// don't, check for EA_COMPILER_NO_EXCEPTIONS being defined.
//
#if !defined(EA_COMPILER_NO_EXCEPTIONS) && !defined(EA_COMPILER_NO_UNWIND)
#if defined(EA_COMPILER_GNUC) && defined(_NO_EX) // GCC on some platforms defines _NO_EX when exceptions are disabled.
#define EA_COMPILER_NO_EXCEPTIONS 1
#elif (defined(EA_COMPILER_CLANG) || defined(EA_COMPILER_GNUC) || defined(EA_COMPILER_INTEL) || defined(EA_COMPILER_RVCT)) && !defined(__EXCEPTIONS) // GCC and most EDG-based compilers define __EXCEPTIONS when exception handling is enabled.
#define EA_COMPILER_NO_EXCEPTIONS 1
#elif (defined(EA_COMPILER_MSVC)) && !defined(_CPPUNWIND)
#define EA_COMPILER_NO_UNWIND 1
#endif // EA_COMPILER_NO_EXCEPTIONS / EA_COMPILER_NO_UNWIND
#endif // !defined(EA_COMPILER_NO_EXCEPTIONS) && !defined(EA_COMPILER_NO_UNWIND)
// ------------------------------------------------------------------------
// EA_DISABLE_ALL_VC_WARNINGS / EA_RESTORE_ALL_VC_WARNINGS
//
// Disable and re-enable all warning(s) within code.
//
// Example usage:
// EA_DISABLE_ALL_VC_WARNINGS()
// <code>
// EA_RESTORE_ALL_VC_WARNINGS()
//
//This is duplicated from EABase's eacompilertraits.h
#ifndef EA_DISABLE_ALL_VC_WARNINGS
#if defined(_MSC_VER)
#define EA_DISABLE_ALL_VC_WARNINGS() \
__pragma(warning(push, 0)) \
__pragma(warning(disable: 4244 4265 4267 4350 4472 4509 4548 4623 4710 4985 6320 4755 4625 4626 4702)) // Some warnings need to be explicitly called out.
#else
#define EA_DISABLE_ALL_VC_WARNINGS()
#endif
#endif
//This is duplicated from EABase's eacompilertraits.h
#ifndef EA_RESTORE_ALL_VC_WARNINGS
#if defined(_MSC_VER)
#define EA_RESTORE_ALL_VC_WARNINGS() \
__pragma(warning(pop))
#else
#define EA_RESTORE_ALL_VC_WARNINGS()
#endif
#endif
// Dinkumware
//This is duplicated from EABase's eahave.h
#if !defined(EA_HAVE_DINKUMWARE_CPP_LIBRARY) && !defined(EA_NO_HAVE_DINKUMWARE_CPP_LIBRARY)
#if defined(__cplusplus)
EA_DISABLE_ALL_VC_WARNINGS()
#include <cstddef> // Need to trigger the compilation of yvals.h without directly using <yvals.h> because it might not exist.
EA_RESTORE_ALL_VC_WARNINGS()
#endif
#if defined(__cplusplus) && defined(_CPPLIB_VER) /* If using the Dinkumware Standard library... */
#define EA_HAVE_DINKUMWARE_CPP_LIBRARY 1
#else
#define EA_NO_HAVE_DINKUMWARE_CPP_LIBRARY 1
#endif
#endif
// EA_COMPILER_NO_ALIGNED_NEW
//
//
#if !defined(EA_COMPILER_NO_ALIGNED_NEW)
#if defined(_HAS_ALIGNED_NEW) && _HAS_ALIGNED_NEW // VS2017 15.5 Preview
// supported.
#elif defined(EA_COMPILER_CPP17_ENABLED)
// supported.
#else
#define EA_COMPILER_NO_ALIGNED_NEW 1
#endif
#endif
// EA_COMPILER_NO_NEW_THROW_SPEC / EA_THROW_SPEC_NEW / EA_THROW_SPEC_DELETE
//
// If defined then the compiler's version of operator new is not decorated
// with a throw specification. This is useful for us to know because we
// often want to write our own overloaded operator new implementations.
// We need such operator new overrides to be declared identically to the
// way the compiler is defining operator new itself.
//
// Example usage:
// void* operator new(std::size_t) EA_THROW_SPEC_NEW(std::bad_alloc);
// void* operator new[](std::size_t) EA_THROW_SPEC_NEW(std::bad_alloc);
// void* operator new(std::size_t, const std::nothrow_t&) EA_THROW_SPEC_NEW_NONE();
// void* operator new[](std::size_t, const std::nothrow_t&) EA_THROW_SPEC_NEW_NONE();
// void operator delete(void*) EA_THROW_SPEC_DELETE_NONE();
// void operator delete[](void*) EA_THROW_SPEC_DELETE_NONE();
// void operator delete(void*, const std::nothrow_t&) EA_THROW_SPEC_DELETE_NONE();
// void operator delete[](void*, const std::nothrow_t&) EA_THROW_SPEC_DELETE_NONE();
//
#if defined(EA_HAVE_DINKUMWARE_CPP_LIBRARY)
#if defined(_MSC_VER) && (_MSC_VER >= 1912) // VS2017 15.3+
#define EA_THROW_SPEC_NEW(x) noexcept(false)
#define EA_THROW_SPEC_NEW_NONE() noexcept
#define EA_THROW_SPEC_DELETE_NONE() noexcept
#elif defined(_MSC_VER) && (_MSC_VER >= 1910) // VS2017+
#define EA_THROW_SPEC_NEW(x) throw(x)
#define EA_THROW_SPEC_NEW_NONE() throw()
#define EA_THROW_SPEC_DELETE_NONE() throw()
#else
#if defined(EA_PLATFORM_SONY)
#define EA_THROW_SPEC_NEW(X) _THROWS(X)
#elif defined(_MSC_VER)
// Disabled warning "nonstandard extension used: 'throw (...)'" as this warning is a W4 warning which is usually off by default
// and doesn't convey any important information but will still complain when building with /Wall (which most teams do)
#define EA_THROW_SPEC_NEW(X) __pragma(warning(push)) __pragma(warning(disable: 4987)) _THROWS(X) __pragma(warning(pop))
#else
#define EA_THROW_SPEC_NEW(X) _THROW1(X)
#endif
#define EA_THROW_SPEC_NEW_NONE() _THROW0()
#define EA_THROW_SPEC_DELETE_NONE() _THROW0()
#endif
#elif defined(EA_COMPILER_NO_EXCEPTIONS) && !defined(EA_COMPILER_RVCT) && !defined(EA_PLATFORM_LINUX) && !defined(EA_PLATFORM_APPLE) && !defined(EA_PLATFORM_NX)
#define EA_COMPILER_NO_NEW_THROW_SPEC 1
#define EA_THROW_SPEC_NEW(x)
#define EA_THROW_SPEC_NEW_NONE()
#define EA_THROW_SPEC_DELETE_NONE()
#else
#define EA_THROW_SPEC_NEW(x) throw(x)
#define EA_THROW_SPEC_NEW_NONE() throw()
#define EA_THROW_SPEC_DELETE_NONE() throw()
#endif
// EA_COMPILER_NO_STANDARD_CPP_LIBRARY
//
// If defined, then the compiler doesn't provide a Standard C++ library.
//
#if defined(EA_PLATFORM_ANDROID)
// Disabled because EA's eaconfig/android_config/android_sdk packages currently
// don't support linking STL libraries. Perhaps we can figure out what linker arguments
// are needed for an app so we can manually specify them and then re-enable this code.
//#include <android/api-level.h>
//
//#if (__ANDROID_API__ < 9) // Earlier versions of Android provide no std C++ STL implementation.
#define EA_COMPILER_NO_STANDARD_CPP_LIBRARY 1
//#endif
#endif
// EA_COMPILER_NO_STATIC_VARIABLE_INIT
//
// If defined, it means that global or static C++ variables will be
// constructed. Not all compiler/platorm combinations support this.
// User code that needs to be portable must avoid having C++ variables
// that construct before main.
//
//#if defined(EA_PLATFORM_MOBILE)
// #define EA_COMPILER_NO_STATIC_VARIABLE_INIT 1
//#endif
// EA_COMPILER_NO_STATIC_FUNCTION_INIT
//
// If defined, it means that functions marked as startup functions
// (e.g. __attribute__((constructor)) in GCC) are supported. It may
// be that some compiler/platform combinations don't support this.
//
//#if defined(XXX) // So far, all compiler/platforms we use support this.
// #define EA_COMPILER_NO_STATIC_VARIABLE_INIT 1
//#endif
// EA_COMPILER_NO_VARIADIC_MACROS
//
// If defined, the compiler doesn't support C99/C++11 variadic macros.
// With a variadic macro, you can do this:
// #define MY_PRINTF(format, ...) printf(format, __VA_ARGS__)
//
#if !defined(EA_COMPILER_NO_VARIADIC_MACROS)
#if defined(_MSC_VER) && (_MSC_VER < 1500) // If earlier than VS2008..
#define EA_COMPILER_NO_VARIADIC_MACROS 1
#elif defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__)) < 401 // If earlier than GCC 4.1..
#define EA_COMPILER_NO_VARIADIC_MACROS 1
#elif defined(EA_COMPILER_EDG) // Includes other compilers
// variadic macros are supported
#endif
#endif
// EA_COMPILER_NO_RVALUE_REFERENCES
//
// If defined, the compiler doesn't fully support C++11 rvalue reference semantics.
// This applies to the compiler only and not the Standard Library in use with the compiler,
// which is required by the Standard to have some support itself.
//
#if !defined(EA_COMPILER_NO_RVALUE_REFERENCES)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_VER >= 1600) // VS2010+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403) // EDG 4.3+.
// supported. Earlier EDG supported a subset of rvalue references. Implicit move constructors and assignment operators aren't supported until EDG 4.5.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && EA_COMPILER_HAS_FEATURE(cxx_rvalue_references)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+
// supported.
#else
#define EA_COMPILER_NO_RVALUE_REFERENCES 1
#endif
#endif
// EA_COMPILER_NO_EXTERN_TEMPLATE
//
// If defined, the compiler doesn't support C++11 extern template.
// With extern templates, you can do this:
// extern template void DoSomething(KnownType u);
//
#if !defined(EA_COMPILER_NO_EXTERN_TEMPLATE)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_VER >= 1700) // VS2012+...
// Extern template is supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && defined(__apple_build_version__) && (EA_COMPILER_VERSION >= 401)
// Extern template is supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && !defined(__apple_build_version__) // Clang other than Apple's Clang
// Extern template is supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+
// Extern template is supported.
#else
#define EA_COMPILER_NO_EXTERN_TEMPLATE 1
#endif
#endif
// EA_COMPILER_NO_RANGE_BASED_FOR_LOOP
//
// If defined, the compiler doesn't support C++11 range-based for loops.
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html
// You must #include <iterator> for range-based for loops to work.
// Example usage:
// #include <iterator>
// #include <vector>
// std::vector<float> floatVector;
// for(float& f : floatVector)
// f += 1.0;
//
#if !defined(EA_COMPILER_NO_RANGE_BASED_FOR_LOOP)
#if defined(EA_COMPILER_CPP11_ENABLED) && (defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1700)) // VS2012+...
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && (defined(__clang__) && (EA_COMPILER_VERSION >= 300)) // Clang 3.x+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && (defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006)) // GCC 4.6+
// supported.
#else
#define EA_COMPILER_NO_RANGE_BASED_FOR_LOOP 1
#endif
#endif
// EA_COMPILER_NO_CONSTEXPR
//
// Refers to C++11 = constexpr (const expression) declarations.
//
#if !defined(EA_COMPILER_NO_CONSTEXPR)
#if defined(EA_COMPILER_CPP11_ENABLED) && (defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1900)) // VS2015+... Not present in VC++ up to and including VS2013.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406) // EDG 4.6+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && EA_COMPILER_HAS_FEATURE(cxx_constexpr)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1900) // VS 2015+
// supported.
#else
#define EA_COMPILER_NO_CONSTEXPR 1
#endif
#endif
// EA_COMPILER_NO_CONSTEXPR_IF
//
// Refers to C++17 = constexpr if(const expression) conditionals.
//
#if !defined(EA_COMPILER_NO_CONSTEXPR_IF)
#if defined(EA_COMPILER_CPP17_ENABLED) && (defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1911)) // VS2017 15.3+
// supported.
#elif defined(EA_COMPILER_CPP17_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 309) // Clang 3.9+
// supported.
#elif defined(EA_COMPILER_CPP17_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 7000) // GCC 7+
// supported.
#else
#define EA_COMPILER_NO_CONSTEXPR_IF 1
#endif
#endif
// EA_COMPILER_NO_OVERRIDE
//
// Refers to the C++11 override specifier.
//
#ifndef EA_COMPILER_NO_OVERRIDE
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION > 1600) // VC++ > VS2010, even without C++11 support. VS2010 does support override, however will generate warnings due to the keyword being 'non-standard'
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+
// supported.
#else
#define EA_COMPILER_NO_OVERRIDE 1
#endif
#endif
// EA_COMPILER_NO_INHERITANCE_FINAL
//
// Refers to the C++11 final specifier.
//
#ifndef EA_COMPILER_NO_INHERITANCE_FINAL
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1500) // VS2008+, even without C++11 support.
// supported, though you need to use EA_INHERITANCE_FINAL for it to work with VS versions prior to 2012.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+
// supported
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+
// supported
#else
#define EA_COMPILER_NO_INHERITANCE_FINAL 1
#endif
#endif
// EA_COMPILER_NO_AUTO
//
// Refers to C++11 auto.
//
#if !defined(EA_COMPILER_NO_AUTO)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+.
// supported with the exception of the usage of braced initializer lists as of EDG 4.3.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#else
#define EA_COMPILER_NO_AUTO 1
#endif
#endif
// EA_COMPILER_NO_NULLPTR
//
// Refers to C++11 nullptr (which is a built in type). std::nullptr_t is defined in C++11 <cstddef>.
// Note that <EABase/nullptr.h> implements a portable nullptr implementation.
//
#if !defined(EA_COMPILER_NO_NULLPTR)
#if (defined(_MSC_VER) && (_MSC_VER >= 1600)) && defined(EA_COMPILER_CPP11_ENABLED)
// supported
#elif defined(EA_COMPILER_GNUC) && (EA_COMPILER_VERSION >= 4006) && defined(EA_COMPILER_CPP11_ENABLED)
// supported
#elif defined(__clang__) && defined(EA_COMPILER_CPP11_ENABLED)
// supported
#elif defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403) && defined(EA_COMPILER_CPP11_ENABLED)
// supported
#else
#define EA_COMPILER_NO_NULLPTR 1
#endif
#endif
// EA_COMPILER_NO_DECLTYPE
//
// Refers to C++11 decltype.
//
#if !defined(EA_COMPILER_NO_DECLTYPE)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+
// supported, though VS2010 doesn't support the spec completely as specified in the final standard.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4003) // GCC 4.3+
// supported.
#else
#define EA_COMPILER_NO_DECLTYPE 1
#endif
#endif
// EA_COMPILER_NO_DEFAULTED_FUNCTIONS
// EA_COMPILER_NO_DELETED_FUNCTIONS
//
// Refers to C++11 = default and = delete function declarations.
//
#if !defined(EA_COMPILER_NO_DEFAULTED_FUNCTIONS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+
// supported, but as of VS2013 it isn't supported for defaulted move constructors and move assignment operators.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+.
// supported, but as of EDG 4.3 it isn't supported for defaulted move constructors and move assignment operators until EDG 4.5.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) // Clang 3.0+, including Apple's Clang
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#else
// VC++ doesn't support it as of VS2012.
#define EA_COMPILER_NO_DEFAULTED_FUNCTIONS 1
#endif
#endif
#if !defined(EA_COMPILER_NO_DELETED_FUNCTIONS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+
// supported, but as of VS2013 it isn't supported for defaulted move constructors and move assignment operators.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#else
// VC++ doesn't support it as of VS2012.
#define EA_COMPILER_NO_DELETED_FUNCTIONS 1
#endif
#endif
// EA_COMPILER_NO_LAMBDA_EXPRESSIONS
//
// Refers to C++11 lambda expressions.
//
#if !defined(EA_COMPILER_NO_LAMBDA_EXPRESSIONS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+
// supported, though VS2010 doesn't support the spec completely as specified in the final standard.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+.
// supported. However, converting lambdas to function pointers is not supported until EDG 4.5.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#else
#define EA_COMPILER_NO_LAMBDA_EXPRESSIONS 1
#endif
#endif
// EA_COMPILER_NO_TRAILING_RETURN_TYPES
//
// Refers to C++11 trailing-return-type. Also sometimes referred to as "incomplete return type".
//
#if !defined(EA_COMPILER_NO_TRAILING_RETURN_TYPES)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+
// supported, though VS2010 doesn't support the spec completely as specified in the final standard.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+.
// supported. However, use of "this" in trailing return types is not supported untiil EDG 4.4
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#else
#define EA_COMPILER_NO_TRAILING_RETURN_TYPES 1
#endif
#endif
// EA_COMPILER_NO_STRONGLY_TYPED_ENUMS
//
// Refers to C++11 strongly typed enums, which includes enum classes and sized enums. Doesn't include forward-declared enums.
//
#if !defined(EA_COMPILER_NO_STRONGLY_TYPED_ENUMS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1700) // VS2012+
// supported. A subset of this is actually supported by VS2010.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 400) // EDG 4.0+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#else
#define EA_COMPILER_NO_STRONGLY_TYPED_ENUMS 1
#endif
#endif
// EA_COMPILER_NO_FORWARD_DECLARED_ENUMS
//
// Refers to C++11 forward declared enums.
//
#if !defined(EA_COMPILER_NO_FORWARD_DECLARED_ENUMS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1700) // VS2012+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+.
// supported. EDG 4.3 supports basic forward-declared enums, but not forward-declared strongly typed enums.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+
// supported.
#else
#define EA_COMPILER_NO_FORWARD_DECLARED_ENUMS 1
#endif
#endif
// EA_COMPILER_NO_VARIADIC_TEMPLATES
//
// Refers to C++11 variadic templates.
//
#if !defined(EA_COMPILER_NO_VARIADIC_TEMPLATES)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_FULL_VER == 170051025) // VS2012 November Preview for Windows only.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403) // EDG 4.3+.
// supported, though 4.1 has partial support for variadic templates.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported, though GCC 4.3 has partial support for variadic templates.
#else
#define EA_COMPILER_NO_VARIADIC_TEMPLATES 1
#endif
#endif
// EA_COMPILER_NO_TEMPLATE_ALIASES
//
// Refers to C++11 alias templates.
// Example alias template usage:
// template <typename T>
// using Dictionary = eastl::map<eastl::string, T>;
//
// Dictionary<int> StringIntDictionary;
//
#if !defined(EA_COMPILER_NO_TEMPLATE_ALIASES)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+.
// supported, though 4.1 has partial support for variadic templates.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+
// supported, though GCC 4.3 has partial support for variadic templates.
#else
#define EA_COMPILER_NO_TEMPLATE_ALIASES 1
#endif
#endif
// EA_COMPILER_NO_VARIABLE_TEMPLATES
//
// Refers to C++14 variable templates.
// Example variable template usage:
// template<class T>
// constexpr T pi = T(3.1415926535897932385);
//
#if !defined(EA_COMPILER_NO_VARIABLE_TEMPLATES)
#if defined(_MSC_VER) && (_MSC_FULL_VER >= 190023918) // VS2015 Update 2 and above.
// supported.
#elif defined(EA_COMPILER_CPP14_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 304) && !defined(__apple_build_version__) // Clang 3.4+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP14_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 5000) // GCC 5+
// supported.
#elif !defined(EA_COMPILER_CPP14_ENABLED)
#define EA_COMPILER_NO_VARIABLE_TEMPLATES 1
#endif
#endif
// EA_COMPILER_NO_INLINE_VARIABLES
//
// Refers to C++17 inline variables that allows the definition of variables in header files
//
// Example usage:
// struct Foo
// {
// static inline constexpr int kConstant = 42; // no out of class definition
// };
//
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4424.pdf
// http://en.cppreference.com/w/cpp/language/inline
//
#if !defined(EA_COMPILER_NO_INLINE_VARIABLES)
#define EA_COMPILER_NO_INLINE_VARIABLES 1
#endif
// EA_COMPILER_NO_INITIALIZER_LISTS
//
// Refers to C++11 initializer lists.
// This refers to the compiler support for this and not the Standard Library support (std::initializer_list).
//
#if !defined(EA_COMPILER_NO_INITIALIZER_LISTS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_FULL_VER == 170051025) // VS2012 November Preview for Windows only.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported, though GCC 4.3 has partial support for it.
#else
#define EA_COMPILER_NO_INITIALIZER_LISTS 1
#endif
#endif
// EA_COMPILER_NO_NORETURN
//
// Refers to C++11 declaration attribute: noreturn.
// http://en.cppreference.com/w/cpp/language/attributes
// http://blog.aaronballman.com/2011/09/understanding-attributes/
//
#if !defined(EA_COMPILER_NO_NORETURN)
#if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1300) // VS2003+
// supported via __declspec(noreturn). You need to use that or EA_NORETURN. VC++ up to VS2013 doesn't support any C++11 attribute types.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+
// supported.
#else
#define EA_COMPILER_NO_NORETURN 1
#endif
#endif
// EA_COMPILER_NO_CARRIES_DEPENDENCY
//
// Refers to C++11 declaration attribute: carries_dependency.
// http://en.cppreference.com/w/cpp/language/attributes
// http://blog.aaronballman.com/2011/09/understanding-attributes/
//
#if !defined(EA_COMPILER_NO_CARRIES_DEPENDENCY)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+.
// supported; stricter than other compilers in its usage.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
// Currently GNUC doesn't appear to support this attribute.
//#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+
// // supported.
#else
#define EA_COMPILER_NO_CARRIES_DEPENDENCY 1
#endif
#endif
// EA_COMPILER_NO_FALLTHROUGH
//
// Refers to C++17 declaration attribute: fallthrough.
// http://en.cppreference.com/w/cpp/language/attributes
//
#if !defined(EA_COMPILER_NO_FALLTHROUGH)
#if defined(EA_COMPILER_CPP17_ENABLED)
// supported.
#else
#define EA_COMPILER_NO_FALLTHROUGH 1
#endif
#endif
// EA_COMPILER_NO_NODISCARD
//
// Refers to C++17 declaration attribute: nodiscard.
// http://en.cppreference.com/w/cpp/language/attributes
//
#if !defined(EA_COMPILER_NO_NODISCARD)
#if defined(EA_COMPILER_CPP17_ENABLED)
// supported.
#else
#define EA_COMPILER_NO_NODISCARD 1
#endif
#endif
// EA_COMPILER_NO_MAYBE_UNUSED
//
// Refers to C++17 declaration attribute: maybe_unused.
// http://en.cppreference.com/w/cpp/language/attributes
//
#if !defined(EA_COMPILER_NO_MAYBE_UNUSED)
#if defined(EA_COMPILER_CPP17_ENABLED)
// supported.
#elif defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1912) // VS2017 15.3+
// supported.
#else
#define EA_COMPILER_NO_MAYBE_UNUSED 1
#endif
#endif
// EA_COMPILER_NO_STRUCTURED_BINDING
//
// Indicates if target compiler supports the C++17 "structured binding" language feature.
// https://en.cppreference.com/w/cpp/language/structured_binding
//
//
#if !defined(EA_COMPILER_NO_STRUCTURED_BINDING)
#if defined(EA_COMPILER_CPP17_ENABLED)
// supported.
#elif defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1912) // VS2017 15.3+
// supported.
#else
#define EA_COMPILER_NO_STRUCTURED_BINDING 1
#endif
#endif
// EA_COMPILER_NO_DESIGNATED_INITIALIZERS
//
// Indicates the target compiler supports the C++20 "designated initializer" language feature.
// https://en.cppreference.com/w/cpp/language/aggregate_initialization
//
// Example:
// struct A { int x; int y; };
// A a = { .y = 42, .x = 1 };
//
#if !defined(EA_COMPILER_NO_DESIGNATED_INITIALIZERS)
#if defined(EA_COMPILER_CPP20_ENABLED)
// supported.
#else
#define EA_COMPILER_NO_DESIGNATED_INITIALIZERS 1
#endif
#endif
// EA_COMPILER_NO_NONSTATIC_MEMBER_INITIALIZERS
//
// Refers to C++11 declaration attribute: carries_dependency.
// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm
//
#if !defined(EA_COMPILER_NO_NONSTATIC_MEMBER_INITIALIZERS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+
// supported.
#else
#define EA_COMPILER_NO_NONSTATIC_MEMBER_INITIALIZERS 1
#endif
#endif
// EA_COMPILER_NO_RIGHT_ANGLE_BRACKETS
//
// Defines if the compiler supports >> (as opposed to > >) in template
// declarations such as typedef eastl::list<eastl::list<int>> ListList;
//
#if !defined(EA_COMPILER_NO_RIGHT_ANGLE_BRACKETS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4003) // GCC 4.3+
// supported.
#else
#define EA_COMPILER_NO_RIGHT_ANGLE_BRACKETS 1
#endif
#endif
// EA_COMPILER_NO_ALIGNOF
//
// Refers specifically to C++11 alignof and not old compiler extensions such as __alignof__().
// However, EABase provides a portable EA_ALIGN_OF which works for all compilers.
//
#if !defined(EA_COMPILER_NO_ALIGNOF)
// Not supported by VC++ as of VS2013, though EA_ALIGN_OF is supported on all coompilers as an alternative.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+
// supported.
#else
#define EA_COMPILER_NO_ALIGNOF 1
#endif
#endif
// EA_COMPILER_NO_ALIGNAS
//
// Refers to C++11 alignas.
//
#if !defined(EA_COMPILER_NO_ALIGNAS)
// Not supported by VC++ as of VS2013.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+
// supported.
#else
#define EA_COMPILER_NO_ALIGNAS 1
#endif
#endif
// EA_COMPILER_NO_DELEGATING_CONSTRUCTORS
//
// Refers to C++11 constructor delegation.
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
// https://www.ibm.com/developerworks/mydeveloperworks/blogs/5894415f-be62-4bc0-81c5-3956e82276f3/entry/c_0x_delegating_constructors
//
#if !defined(EA_COMPILER_NO_DELEGATING_CONSTRUCTORS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407) // EDG 4.7+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+
// supported.
#else
#define EA_COMPILER_NO_DELEGATING_CONSTRUCTORS 1
#endif
#endif
// EA_COMPILER_NO_INHERITING_CONSTRUCTORS
//
// Refers to C++11 constructor inheritance via 'using'.
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm
//
#if !defined(EA_COMPILER_NO_INHERITING_CONSTRUCTORS)
// Not supported by VC++ as of VS2013.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && EA_COMPILER_HAS_FEATURE(cxx_inheriting_constructors) // Clang
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+
// supported.
#else
#define EA_COMPILER_NO_INHERITING_CONSTRUCTORS 1
#endif
#endif
// EA_COMPILER_NO_USER_DEFINED_LITERALS
//
// http://en.cppreference.com/w/cpp/language/user_literal
// http://stackoverflow.com/questions/237804/what-new-capabilities-do-user-defined-literals-add-to-c
//
#if !defined(EA_COMPILER_NO_USER_DEFINED_LITERALS)
// Not supported by VC++ as of VS2013.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+
// supported.
#else
#define EA_COMPILER_NO_USER_DEFINED_LITERALS 1
#endif
#endif
// EA_COMPILER_NO_STANDARD_LAYOUT_TYPES
// a.k.a. POD relaxation
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm
//
#if !defined(EA_COMPILER_NO_STANDARD_LAYOUT_TYPES)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1700) // VS2012+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+
// supported.
#else
#define EA_COMPILER_NO_STANDARD_LAYOUT_TYPES 1
#endif
#endif
// EA_COMPILER_NO_EXTENDED_SIZEOF
//
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html
// Allows you to do this: sizeof(SomeClass::mSomeMember)
//
#if !defined(EA_COMPILER_NO_EXTENDED_SIZEOF)
// Not supported by VC++ as of VS2013.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
// Versions of EDG prior to 4.5 only support extended sizeof in non-member functions. Full support was added in 4.5
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+
// supported.
#else
#define EA_COMPILER_NO_EXTENDED_SIZEOF 1
#endif
#endif
// EA_COMPILER_NO_INLINE_NAMESPACES
//
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm
// http://blog.aaronballman.com/2011/07/inline-namespaces/
//
#if !defined(EA_COMPILER_NO_INLINE_NAMESPACES)
// Not supported by VC++ as of VS2013.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#else
#define EA_COMPILER_NO_INLINE_NAMESPACES 1
#endif
#endif
// EA_COMPILER_NO_UNRESTRICTED_UNIONS
//
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
//
#if !defined(EA_COMPILER_NO_UNRESTRICTED_UNIONS)
// Not supported by VC++ as of VS2013.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406) // EDG 4.6+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+
// supported.
#else
#define EA_COMPILER_NO_UNRESTRICTED_UNIONS 1
#endif
#endif
// EA_COMPILER_NO_EXPLICIT_CONVERSION_OPERATORS
//
// http://en.wikipedia.org/wiki/C%2B%2B11#Explicit_conversion_operators
//
#if !defined(EA_COMPILER_NO_EXPLICIT_CONVERSION_OPERATORS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_FULL_VER == 170051025) // VS2012 November Preview for Windows only.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 404) // EDG 4.4+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+
// supported.
#else
#define EA_COMPILER_NO_EXPLICIT_CONVERSION_OPERATORS 1
#endif
#endif
// EA_COMPILER_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
//
// The compiler does not support default template arguments for function templates.
// http://stackoverflow.com/questions/2447458/default-template-arguments-for-function-templates
//
#if !defined(EA_COMPILER_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403) // EDG 4.4+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4003) // GCC 4.3+
// supported.
#else
#define EA_COMPILER_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 1
#endif
#endif
// EA_COMPILER_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
//
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm
// http://stackoverflow.com/questions/5751977/local-type-as-template-arguments-in-c
//
#if !defined(EA_COMPILER_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+
// supported.
#if (EA_COMPILER_VERSION < 1700) // VS2010 generates a warning, but the C++ language now allows it.
#pragma warning(disable: 4836) // nonstandard extension used: local types or unnamed types cannot be used as template arguments.
#endif
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+
// supported.
#else
#define EA_COMPILER_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 1
#endif
#endif
// EA_COMPILER_NO_NOEXCEPT
//
// C++11 noexcept
// http://en.cppreference.com/w/cpp/language/attributes
// http://en.cppreference.com/w/cpp/language/noexcept
//
#if !defined(EA_COMPILER_NO_NOEXCEPT)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1900) // VS2014+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+
// supported.
#else
#define EA_COMPILER_NO_NOEXCEPT 1
#endif
#endif
// EA_COMPILER_NO_RAW_LITERALS
//
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm
// http://en.wikipedia.org/wiki/C%2B%2B11#New_string_literals
//
#if !defined(EA_COMPILER_NO_RAW_LITERALS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407) // EDG 4.7+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+
// supported.
#else
#define EA_COMPILER_NO_RAW_LITERALS 1
#endif
#endif
// EA_COMPILER_NO_UNICODE_STRING_LITERALS
//
// http://en.wikipedia.org/wiki/C%2B%2B11#New_string_literals
//
#if !defined(EA_COMPILER_NO_UNICODE_STRING_LITERALS)
// Not supported by VC++ as of VS2013.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407) // EDG 4.7+.
// supported. It's not clear if it's v4.4 or v4.7 that adds this support.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407) // EDG 4.7+.
// supported. It's not clear if it's v4.4 or v4.7 that adds this support.
#else
#define EA_COMPILER_NO_UNICODE_STRING_LITERALS 1
#endif
#endif
// EA_COMPILER_NO_NEW_CHARACTER_TYPES
//
// Refers to char16_t and char32_t as true native types (and not something simply typedef'd from uint16_t and uint32_t).
// http://en.cppreference.com/w/cpp/language/types
//
#if !defined(EA_COMPILER_NO_NEW_CHARACTER_TYPES)
#if defined(EA_COMPILER_NO_UNICODE_STRING_LITERALS) // Some compilers have had support for char16_t prior to support for u"", but it's not useful to have the former without the latter.
#define EA_COMPILER_NO_NEW_CHARACTER_TYPES 1
#endif
#endif
// EA_COMPILER_NO_UNICODE_CHAR_NAME_LITERALS
//
// C++ 11 relaxed \u\U sequences in strings.
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html
//
#if !defined(EA_COMPILER_NO_UNICODE_CHAR_NAME_LITERALS)
// VC++ up till at least VS2013 supports \u and \U but supports them wrong with respect to the C++11 Standard.
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+
// supported.
#else
#define EA_COMPILER_NO_UNICODE_CHAR_NAME_LITERALS 1
#endif
#endif
// EA_COMPILER_NO_UNIFIED_INITIALIZATION_SYNTAX
//
// http://en.wikipedia.org/wiki/C%2B%2B11#Uniform_initialization
//
#if !defined(EA_COMPILER_NO_UNIFIED_INITIALIZATION_SYNTAX)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+
// supported.
#else
#define EA_COMPILER_NO_UNIFIED_INITIALIZATION_SYNTAX 1
#endif
#endif
// EA_COMPILER_NO_EXTENDED_FRIEND_DECLARATIONS
//
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
//
#if !defined(EA_COMPILER_NO_EXTENDED_FRIEND_DECLARATIONS)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang.
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+
// supported.
#else
#define EA_COMPILER_NO_EXTENDED_FRIEND_DECLARATIONS 1
#endif
#endif
// EA_COMPILER_NO_THREAD_LOCAL
//
// Refers specifically to C++ thread_local, which is like compiler __thread implementations except
// that it also supports non-trivial classes (e.g. with ctors). EA_COMPILER_NO_THREAD_LOCAL refers
// specifically to full C++11 thread_local support. The EAThread package provides a wrapper for
// __thread via EA_THREAD_LOCAL (which unfortunately sounds like C++ thread_local).
//
// https://en.cppreference.com/w/cpp/keyword/thread_local
//
#if !defined(EA_COMPILER_NO_THREAD_LOCAL)
#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && EA_COMPILER_HAS_FEATURE(cxx_thread_local)
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1900) // VS2015+
// supported.
#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+
// supported.
#else
#define EA_COMPILER_NO_THREAD_LOCAL 1
#endif
#endif
#endif // INCLUDED_eacompiler_H
Reference in New Issue View Git Blame Copy Permalink