/*----------------------------------------------------------------------------- * 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 = * EA_COMPILER_NAME = * EA_COMPILER_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 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 vector{ }; // Primary templated class. * template class vector{ }; // Partially specialized version. * * EA_COMPILER_NO_MEMBER_TEMPLATES * Some compilers fail to allow member template functions such as this: * struct A{ template 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 void DoSomething(U u); * void DoSomething(int x); * }; * * EA_COMPILER_NO_TEMPLATE_TEMPLATES * Code such as this is legal: * template class U> * U SomeFunction(const U x) { return x.DoSomething(); } * * EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS * Some compilers fail to compile templated friends, as with this: * struct A{ template 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 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 * is in namespace std. Some std libraries fail to * put the contents of 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 * 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 // 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() // // 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 // Need to trigger the compilation of yvals.h without directly using 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 // //#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 for range-based for loops to work. // Example usage: // #include // #include // std::vector 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 . // Note that 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 // using Dictionary = eastl::map; // // Dictionary 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 // 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> 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