diff options
Diffstat (limited to 'UnknownVersion/include/EABase/config/eacompiler.h')
| -rw-r--r-- | UnknownVersion/include/EABase/config/eacompiler.h | 1934 |
1 files changed, 1600 insertions, 334 deletions
diff --git a/UnknownVersion/include/EABase/config/eacompiler.h b/UnknownVersion/include/EABase/config/eacompiler.h index 97b65ef..4b388dd 100644 --- a/UnknownVersion/include/EABase/config/eacompiler.h +++ b/UnknownVersion/include/EABase/config/eacompiler.h @@ -1,43 +1,10 @@ -/* -Copyright (C) 2009 Electronic Arts, Inc. All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions -are met: - -1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. -3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of - its contributors may be used to endorse or promote products derived - from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY -EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY -DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF -THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - /*----------------------------------------------------------------------------- * config/eacompiler.h * - * Copyright (c) 2002 - 2005 Electronic Arts Inc. All rights reserved. - * Maintained by Paul Pedriana, Maxis - * - * Modified to support Clang++ (v2.8) by Austin Seipp, 2010. - * + * Copyright (c) Electronic Arts Inc. All rights reserved. *----------------------------------------------------------------------------- * Currently supported defines include: * EA_COMPILER_GNUC - * EA_COMPILER_CLANG * EA_COMPILER_ARM * EA_COMPILER_EDG * EA_COMPILER_SN @@ -46,11 +13,18 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * 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 @@ -66,14 +40,73 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * 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 * *----------------------------------------------------------------------------- * - * Documentation + * 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; }; @@ -94,7 +127,7 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION * Some compilers fail to allow member template specialization, such as with this: - * struct A{ + * struct A{ * template<class U> void DoSomething(U u); * void DoSomething(int x); * }; @@ -116,9 +149,9 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * 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 + * 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); * @@ -126,17 +159,17 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * 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* + * 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 + * <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 + * 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; }; @@ -144,12 +177,12 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * 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. - * + * 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 + * 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). * *---------------------------------------------------------------------------*/ @@ -157,356 +190,1589 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef INCLUDED_eacompiler_H #define INCLUDED_eacompiler_H -#ifndef INCLUDED_eaplatform_H -# include "EABase/config/eaplatform.h" -#endif +#include <EABase/config/eaplatform.h> - // Note: This is used to generate the EA_COMPILER_STRING macros +// Note: This is used to generate the EA_COMPILER_STRING macros #ifndef INTERNAL_STRINGIZE -# define INTERNAL_STRINGIZE(x) INTERNAL_PRIMITIVE_STRINGIZE(x) +#define INTERNAL_STRINGIZE(x) INTERNAL_PRIMITIVE_STRINGIZE(x) #endif #ifndef INTERNAL_PRIMITIVE_STRINGIZE -# define INTERNAL_PRIMITIVE_STRINGIZE(x) #x +#define INTERNAL_PRIMITIVE_STRINGIZE(x) #x #endif - // Note: this is for compatibility with non-clang compilers -#ifndef __has_feature -# define __has_feature(x) 0 +// 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 - - // Note: this is for compatibility with non-clang compilers -#ifndef __has_attribute -# define __has_attribute(x) 0 #endif - // Note: this is for compatibility with non-clang compilers -#ifndef __has_builtin -# define __has_builtin(x) 0 + +// 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) +// EDG (EDG compiler front-end, used by other compilers such as SN) #if defined(__EDG_VERSION__) -# define EA_COMPILER_EDG +#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 - // SN -#if defined(__SNC__) // SN Systems compiler - // Note that there are two versions of the SN compiler, one that is - // GNUC-based and a newer one which is based on an EDG (Edison Design - // Group) front-end with a back-end code generator made by SN. - // The EDG-based SN compiler uses "GCC compatibility mode" and thus - // defines __GNUC__ but isn't really GNUC. Also, as of this writing - // it appears that the SN compiler may arrive with MSVC-compatibility - // mode in addition as well. Thus, we define EA_COMPILER_SN - // separately from other EA_COMPILER defines it is possible that both - // may be defined at the same time. Note that while the newer EDG-based - // SN compiler may emulate other compilers, it doesn't act exactly - // the same. -# define EA_COMPILER_SN +// 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 - // Airplay SDK (third party mobile middleware compiler) -#if defined(__S3E__) -# define EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE +// 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 - // SNC (SN Systems) -#if defined(__SNC__) -# define EA_COMPILER_NAME "SNC" -# ifdef __GNUC__ // If SN is using GCC-compatibility mode (which it usually is)... -# define EA_COMPILER_GNUC -# define EA_COMPILER_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) // We intentionally report the GCC version here. SN -# define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, GCC version " INTERNAL_STRINGIZE( __GNUC__ ) "." INTERNAL_STRINGIZE( __GNUC_MINOR__ ) ", SNC version " INTERNAL_STRINGIZE( __SN_VER__ ) ", EDG version " INTERNAL_STRINGIZE( __EDG_VERSION__ ) -# else -# define EA_COMPILER_VERSION __SN_VER__ -# define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( EA_COMPILER_VERSION ) ", EDG version " INTERNAL_STRINGIZE( __EDG_VERSION__ ) -# 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) - // GCC (a.k.a. GNUC) +// 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 -# 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 -# endif -# if (__GNUC__ == 2) && (__GNUC_MINOR__ <= 97) // If GCC <= 2.97... -# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS -# 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 -# endif - - // Clang (quite compatible with GCC) -#elif defined(__clang__) -# define EA_COMPILER_CLANG -# define EA_COMPILER_VERSION (__clang_major__ * 1000 + __clang_minor__) -# define EA_COMPILER_NAME "Clang++" -# define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( __clang_version__ ) - - // Borland C++ +#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 -# define EA_COMPILER_VERSION __BORLANDC__ -# define EA_COMPILER_NAME "Borland C" - //#define EA_COMPILER_STRING (defined below) +#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 -# endif -# if (__BORLANDC__ >= 0x561) && (__BORLANDC__ < 0x600) -# define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION -# endif +#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++ (via EDG front-end) +// 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 -# if defined(__ICL) -# define EA_COMPILER_VERSION __ICL -# elif defined(__ICC) -# define EA_COMPILER_VERSION __ICC -# endif -# define EA_COMPILER_NAME "Intel C++" - //#define EA_COMPILER_STRING (defined below) - - // Intel is based ont the EDG (Edison Design Group) front end and - // all recent versions are very compliant to the C++ standard. - - - // Metrowerks -#elif defined(__MWERKS__) || defined(__CWCC__) // Metrowerks compilers exist for many platforms. -# define EA_COMPILER_METROWERKS -# ifdef __MWERKS__ -# define EA_COMPILER_VERSION __MWERKS__ -# else -# define EA_COMPILER_VERSION __CWCC__ -# endif -# define EA_COMPILER_NAME "Metrowerks" - //#define EA_COMPILER_STRING (defined below) - -# if (__MWERKS__ <= 0x2407) // If less than v7.x... -# define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION -# endif -# if (__MWERKS__ <= 0x3003) // If less than v8.x... -# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS -# endif - - - // Microsoft VC++ -#elif defined(_MSC_VER) && !(defined(__S3E__) && defined(__arm__) && defined(__aarch64__)) // S3E is a mobile SDK which mistakenly masquerades as VC++ on ARM. -# define EA_COMPILER_MSVC -# define EA_COMPILER_VERSION _MSC_VER -# define EA_COMPILER_NAME "Microsoft Visual C++" - //#define EA_COMPILER_STRING (defined below) - -# if (_MSC_VER <= 1200) // If VC6.x and earlier... -# if (_MSC_VER < 1200) -# define EA_COMPILER_MSVCOLD -# else -# define EA_COMPILER_MSVC6 -# endif - -# if (_MSC_VER < 1200) // If VC5.x or earlier... -# define EA_COMPILER_NO_TEMPLATE_SPECIALIZATION -# endif -# define EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS // The compiler compiles this OK, but executes it wrong. Fixed in VC7.0 -# define EA_COMPILER_NO_VOID_RETURNS // The compiler fails to compile such cases. Fixed in VC7.0 -# define EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE // The compiler fails to compile such cases. Fixed in VC7.0 -# define EA_COMPILER_NO_DEDUCED_TYPENAME // The compiler fails to compile such cases. Fixed in VC7.0 -# define EA_COMPILER_NO_STATIC_CONSTANTS // The compiler fails to compile such cases. Fixed in VC7.0 -# define EA_COMPILER_NO_COVARIANT_RETURN_TYPE // The compiler fails to compile such cases. Fixed in VC7.1 -# define EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP // The compiler compiles this OK, but executes it wrong. Fixed in VC7.1 -# define EA_COMPILER_NO_TEMPLATE_TEMPLATES // The compiler fails to compile such cases. Fixed in VC7.1 -# define EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION // The compiler fails to compile such cases. Fixed in VC7.1 -# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS // The compiler fails to compile such cases. Fixed in VC7.1 - //#define EA_COMPILER_NO_MEMBER_TEMPLATES // VC6.x supports member templates properly 95% of the time. So do we flag the remaining 5%? - //#define EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION // 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 - -# define EA_COMPILER_NO_COVARIANT_RETURN_TYPE // The compiler fails to compile such cases. Fixed in VC7.1 -# define EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP // The compiler compiles this OK, but executes it wrong. Fixed in VC7.1 -# define EA_COMPILER_NO_TEMPLATE_TEMPLATES // The compiler fails to compile such cases. Fixed in VC7.1 -# define EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION // The compiler fails to compile such cases. Fixed in VC7.1 -# define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS // The compiler fails to compile such cases. Fixed in VC7.1 -# define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION // This is the case only for VC7.0 and not VC6 or VC7.1+. Fixed in VC7.1 - //#define EA_COMPILER_NO_MEMBER_TEMPLATES // VC7.0 supports member templates properly 95% of the time. So do we flag the remaining 5%? - -# elif (_MSC_VER < 1400) // If VC7.1 ... - // 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 -# define EA_COMPILER_MSVC7_1 - -# else // _MSC_VER of 1400 means VC8 (VS2005), 1500 means VC9 (VS2008) -# define EA_COMPILER_MSVC8_2005 -# define EA_COMPILER_MSVC8_0 - -# endif - - - // IBM +#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 -# define EA_COMPILER_NAME "IBM XL C" -# define EA_COMPILER_VERSION __xlC__ -# define EA_COMPILER_STRING "IBM XL C compiler, version " INTERNAL_STRINGIZE( __xlC__ ) - - - // ARM compiler -# if defined(__ARMCC_VERSION) - // Note that this refers to the ARM 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. -# define EA_COMPILER_ARM -# define EA_COMPILER_VERSION __ARMCC_VERSION -# define EA_COMPILER_NAME __CC_ARM - //#define EA_COMPILER_STRING (defined below) - -# endif - - // Green Hills -#elif defined(__ghs__) -# define EA_COMPILER_GHS -# define EA_COMPILER_VERSION __GHS_VERSION_NUMBER -# define EA_COMPILER_NAME "Green Hills" - //#define EA_COMPILER_STRING (defined below) - - - // Unknown +#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" +#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) +#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. +// 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 +#define EA_COMPILER_PARTIAL_TEMPLATE_SPECIALIZATION 1 #endif #ifndef EA_COMPILER_NO_TEMPLATE_SPECIALIZATION -# define EA_COMPILER_TEMPLATE_SPECIALIZATION +#define EA_COMPILER_TEMPLATE_SPECIALIZATION 1 #endif #ifndef EA_COMPILER_NO_MEMBER_TEMPLATES -# define EA_COMPILER_MEMBER_TEMPLATES +#define EA_COMPILER_MEMBER_TEMPLATES 1 #endif #ifndef EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION -# define EA_COMPILER_MEMBER_TEMPLATE_SPECIALIZATION +#define EA_COMPILER_MEMBER_TEMPLATE_SPECIALIZATION 1 #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(__SNC__) && !defined(__RTTI) -# define EA_COMPILER_NO_RTTI +/////////////////////////////////////////////////////////////////////////////// +// 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 -#elif defined(__clang__) && !__has_feature(cxx_rtti) -# define EA_COMPILER_NO_RTTI +#define EA_COMPILER_NO_RTTI 1 #elif defined(_MSC_VER) && !defined(_CPPRTTI) -# define EA_COMPILER_NO_RTTI -#elif defined(__MWERKS__) -# if !__option(RTTI) -# define EA_COMPILER_NO_RTTI -# endif -#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_GNUC) && defined(_NO_EX) // GCC on some platforms (e.g. PS3) defines _NO_EX when exceptions are disabled. -# define EA_COMPILER_NO_EXCEPTIONS - -#elif (defined(EA_COMPILER_GNUC) || defined(EA_COMPILER_INTEL) || defined(EA_COMPILER_SN)) && !defined(__EXCEPTIONS) // GCC and most EDG-based compilers define __EXCEPTIONS when exception handling is enabled. -# define EA_COMPILER_NO_EXCEPTIONS - -#elif defined(EA_COMPILER_CLANG) && !__has_feature(cxx_exceptions) -# define EA_COMPILER_NO_EXCEPTIONS - -#elif defined(EA_COMPILER_METROWERKS) -# if !__option(exceptions) -# define EA_COMPILER_NO_EXCEPTIONS -# endif - - // Borland and Micrsoft use the _CPUUNWIND define to denote that - // exception stack unwinding code generation is disabled. The result - // is that you can call try/catch/throw and that exceptions will be - // caught handled, but that no automatic object destruction will - // happen between a throw and the resulting catch. We thus don't - // want to define EA_COMPILER_NO_EXCEPTIONS, but perhaps users might - // be interesting in knowing that unwinding is disabled. -#elif (defined(EA_COMPILER_BORLAND) || defined(EA_COMPILER_MSVC)) && !defined(_CPPUNWIND) -# define EA_COMPILER_NO_UNWIND +#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_STANDARD_CPP_LIBRARY - // - // If defined, then the compiler doesn't provide a Standard C++ library. - // +// 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(CS_UNDEFINED_STRING) +#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) -# define EA_COMPILER_NO_STANDARD_CPP_LIBRARY +// 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_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 - //#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_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 - //#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 + + + + + |