1 /*----------------------------------------------------------------------------- 2 * config/eacompiler.h 3 * 4 * Copyright (c) Electronic Arts Inc. All rights reserved. 5 *----------------------------------------------------------------------------- 6 * Currently supported defines include: 7 * EA_COMPILER_GNUC 8 * EA_COMPILER_ARM 9 * EA_COMPILER_EDG 10 * EA_COMPILER_SN 11 * EA_COMPILER_MSVC 12 * EA_COMPILER_METROWERKS 13 * EA_COMPILER_INTEL 14 * EA_COMPILER_BORLANDC 15 * EA_COMPILER_IBM 16 * EA_COMPILER_QNX 17 * EA_COMPILER_GREEN_HILLS 18 * EA_COMPILER_CLANG 19 * EA_COMPILER_CLANG_CL 20 * 21 * EA_COMPILER_VERSION = <integer> 22 * EA_COMPILER_NAME = <string> 23 * EA_COMPILER_STRING = <string> 24 * 25 * EA_COMPILER_VA_COPY_REQUIRED 26 * 27 * C++98/03 functionality 28 * EA_COMPILER_NO_STATIC_CONSTANTS 29 * EA_COMPILER_NO_TEMPLATE_SPECIALIZATION 30 * EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION 31 * EA_COMPILER_NO_MEMBER_TEMPLATES 32 * EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION 33 * EA_COMPILER_NO_TEMPLATE_TEMPLATES 34 * EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 35 * EA_COMPILER_NO_VOID_RETURNS 36 * EA_COMPILER_NO_COVARIANT_RETURN_TYPE 37 * EA_COMPILER_NO_DEDUCED_TYPENAME 38 * EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP 39 * EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE 40 * EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 41 * EA_COMPILER_NO_RTTI 42 * EA_COMPILER_NO_EXCEPTIONS 43 * EA_COMPILER_NO_NEW_THROW_SPEC 44 * EA_THROW_SPEC_NEW / EA_THROW_SPEC_DELETE 45 * EA_COMPILER_NO_UNWIND 46 * EA_COMPILER_NO_STANDARD_CPP_LIBRARY 47 * EA_COMPILER_NO_STATIC_VARIABLE_INIT 48 * EA_COMPILER_NO_STATIC_FUNCTION_INIT 49 * EA_COMPILER_NO_VARIADIC_MACROS 50 * 51 * C++11 functionality 52 * EA_COMPILER_NO_RVALUE_REFERENCES 53 * EA_COMPILER_NO_EXTERN_TEMPLATE 54 * EA_COMPILER_NO_RANGE_BASED_FOR_LOOP 55 * EA_COMPILER_NO_CONSTEXPR 56 * EA_COMPILER_NO_OVERRIDE 57 * EA_COMPILER_NO_INHERITANCE_FINAL 58 * EA_COMPILER_NO_NULLPTR 59 * EA_COMPILER_NO_AUTO 60 * EA_COMPILER_NO_DECLTYPE 61 * EA_COMPILER_NO_DEFAULTED_FUNCTIONS 62 * EA_COMPILER_NO_DELETED_FUNCTIONS 63 * EA_COMPILER_NO_LAMBDA_EXPRESSIONS 64 * EA_COMPILER_NO_TRAILING_RETURN_TYPES 65 * EA_COMPILER_NO_STRONGLY_TYPED_ENUMS 66 * EA_COMPILER_NO_FORWARD_DECLARED_ENUMS 67 * EA_COMPILER_NO_VARIADIC_TEMPLATES 68 * EA_COMPILER_NO_TEMPLATE_ALIASES 69 * EA_COMPILER_NO_INITIALIZER_LISTS 70 * EA_COMPILER_NO_NORETURN 71 * EA_COMPILER_NO_CARRIES_DEPENDENCY 72 * EA_COMPILER_NO_FALLTHROUGH 73 * EA_COMPILER_NO_NODISCARD 74 * EA_COMPILER_NO_MAYBE_UNUSED 75 * EA_COMPILER_NO_NONSTATIC_MEMBER_INITIALIZERS 76 * EA_COMPILER_NO_RIGHT_ANGLE_BRACKETS 77 * EA_COMPILER_NO_ALIGNOF 78 * EA_COMPILER_NO_ALIGNAS 79 * EA_COMPILER_NO_DELEGATING_CONSTRUCTORS 80 * EA_COMPILER_NO_INHERITING_CONSTRUCTORS 81 * EA_COMPILER_NO_USER_DEFINED_LITERALS 82 * EA_COMPILER_NO_STANDARD_LAYOUT_TYPES 83 * EA_COMPILER_NO_EXTENDED_SIZEOF 84 * EA_COMPILER_NO_INLINE_NAMESPACES 85 * EA_COMPILER_NO_UNRESTRICTED_UNIONS 86 * EA_COMPILER_NO_EXPLICIT_CONVERSION_OPERATORS 87 * EA_COMPILER_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 88 * EA_COMPILER_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 89 * EA_COMPILER_NO_NOEXCEPT 90 * EA_COMPILER_NO_RAW_LITERALS 91 * EA_COMPILER_NO_UNICODE_STRING_LITERALS 92 * EA_COMPILER_NO_NEW_CHARACTER_TYPES 93 * EA_COMPILER_NO_UNICODE_CHAR_NAME_LITERALS 94 * EA_COMPILER_NO_UNIFIED_INITIALIZATION_SYNTAX 95 * EA_COMPILER_NO_EXTENDED_FRIEND_DECLARATIONS 96 * 97 * C++14 functionality 98 * EA_COMPILER_NO_VARIABLE_TEMPLATES 99 * 100 * C++17 functionality 101 * EA_COMPILER_NO_INLINE_VARIABLES 102 * EA_COMPILER_NO_ALIGNED_NEW 103 * 104 *----------------------------------------------------------------------------- 105 * 106 * Supplemental documentation 107 * EA_COMPILER_NO_STATIC_CONSTANTS 108 * Code such as this is legal, but some compilers fail to compile it: 109 * struct A{ static const a = 1; }; 110 * 111 * EA_COMPILER_NO_TEMPLATE_SPECIALIZATION 112 * Some compilers fail to allow template specialization, such as with this: 113 * template<class U> void DoSomething(U u); 114 * void DoSomething(int x); 115 * 116 * EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION 117 * Some compilers fail to allow partial template specialization, such as with this: 118 * template <class T, class Allocator> class vector{ }; // Primary templated class. 119 * template <class Allocator> class vector<bool, Allocator>{ }; // Partially specialized version. 120 * 121 * EA_COMPILER_NO_MEMBER_TEMPLATES 122 * Some compilers fail to allow member template functions such as this: 123 * struct A{ template<class U> void DoSomething(U u); }; 124 * 125 * EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION 126 * Some compilers fail to allow member template specialization, such as with this: 127 * struct A{ 128 * template<class U> void DoSomething(U u); 129 * void DoSomething(int x); 130 * }; 131 * 132 * EA_COMPILER_NO_TEMPLATE_TEMPLATES 133 * Code such as this is legal: 134 * template<typename T, template<typename> class U> 135 * U<T> SomeFunction(const U<T> x) { return x.DoSomething(); } 136 * 137 * EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 138 * Some compilers fail to compile templated friends, as with this: 139 * struct A{ template<class U> friend class SomeFriend; }; 140 * This is described in the C++ Standard at 14.5.3. 141 * 142 * EA_COMPILER_NO_VOID_RETURNS 143 * This is legal C++: 144 * void DoNothing1(){ }; 145 * void DoNothing2(){ return DoNothing1(); } 146 * 147 * EA_COMPILER_NO_COVARIANT_RETURN_TYPE 148 * See the C++ standard sec 10.3,p5. 149 * 150 * EA_COMPILER_NO_DEDUCED_TYPENAME 151 * Some compilers don't support the use of 'typename' for 152 * dependent types in deduced contexts, as with this: 153 * template <class T> void Function(T, typename T::type); 154 * 155 * EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP 156 * Also known as Koenig lookup. Basically, if you have a function 157 * that is a namespace and you call that function without prefixing 158 * it with the namespace the compiler should look at any arguments 159 * you pass to that function call and search their namespace *first* 160 * to see if the given function exists there. 161 * 162 * EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE 163 * <exception> is in namespace std. Some std libraries fail to 164 * put the contents of <exception> in namespace std. The following 165 * code should normally be legal: 166 * void Function(){ std::terminate(); } 167 * 168 * EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 169 * Some compilers fail to execute DoSomething() properly, though they 170 * succeed in compiling it, as with this: 171 * template <int i> 172 * bool DoSomething(int j){ return i == j; }; 173 * DoSomething<1>(2); 174 * 175 * EA_COMPILER_NO_EXCEPTIONS 176 * The compiler is configured to disallow the use of try/throw/catch 177 * syntax (often to improve performance). Use of such syntax in this 178 * case will cause a compilation error. 179 * 180 * EA_COMPILER_NO_UNWIND 181 * The compiler is configured to allow the use of try/throw/catch 182 * syntax and behaviour but disables the generation of stack unwinding 183 * code for responding to exceptions (often to improve performance). 184 * 185 *---------------------------------------------------------------------------*/ 186 187 #ifndef INCLUDED_eacompiler_H 188 #define INCLUDED_eacompiler_H 189 190 #include <EABase/config/eaplatform.h> 191 192 // Note: This is used to generate the EA_COMPILER_STRING macros 193 #ifndef INTERNAL_STRINGIZE 194 #define INTERNAL_STRINGIZE(x) INTERNAL_PRIMITIVE_STRINGIZE(x) 195 #endif 196 #ifndef INTERNAL_PRIMITIVE_STRINGIZE 197 #define INTERNAL_PRIMITIVE_STRINGIZE(x) #x 198 #endif 199 200 // EA_COMPILER_HAS_FEATURE 201 #ifndef EA_COMPILER_HAS_FEATURE 202 #if defined(__clang__) 203 #define EA_COMPILER_HAS_FEATURE(x) __has_feature(x) 204 #else 205 #define EA_COMPILER_HAS_FEATURE(x) 0 206 #endif 207 #endif 208 209 210 // EA_COMPILER_HAS_BUILTIN 211 #ifndef EA_COMPILER_HAS_BUILTIN 212 #if defined(__clang__) 213 #define EA_COMPILER_HAS_BUILTIN(x) __has_builtin(x) 214 #else 215 #define EA_COMPILER_HAS_BUILTIN(x) 0 216 #endif 217 #endif 218 219 220 // EDG (EDG compiler front-end, used by other compilers such as SN) 221 #if defined(__EDG_VERSION__) 222 #define EA_COMPILER_EDG 1 223 224 #if defined(_MSC_VER) 225 #define EA_COMPILER_EDG_VC_MODE 1 226 #endif 227 #if defined(__GNUC__) 228 #define EA_COMPILER_EDG_GCC_MODE 1 229 #endif 230 #endif 231 232 // EA_COMPILER_WINRTCX_ENABLED 233 // 234 // Defined as 1 if the compiler has its available C++/CX support enabled, else undefined. 235 // This specifically means the corresponding compilation unit has been built with Windows Runtime 236 // Components enabled, usually via the '-ZW' compiler flags being used. This option allows for using 237 // ref counted hat-type '^' objects and other C++/CX specific keywords like "ref new" 238 #if !defined(EA_COMPILER_WINRTCX_ENABLED) && defined(__cplusplus_winrt) 239 #define EA_COMPILER_WINRTCX_ENABLED 1 240 #endif 241 242 243 // EA_COMPILER_CPP11_ENABLED 244 // 245 // Defined as 1 if the compiler has its available C++11 support enabled, else undefined. 246 // This does not mean that all of C++11 or any particular feature of C++11 is supported 247 // by the compiler. It means that whatever C++11 support the compiler has is enabled. 248 // This also includes existing and older compilers that still identify C++11 as C++0x. 249 // 250 // We cannot use (__cplusplus >= 201103L) alone because some compiler vendors have 251 // decided to not define __cplusplus like thus until they have fully completed their 252 // C++11 support. 253 // 254 #if !defined(EA_COMPILER_CPP11_ENABLED) && defined(__cplusplus) 255 #if (__cplusplus >= 201103L) // Clang and GCC defines this like so in C++11 mode. 256 #define EA_COMPILER_CPP11_ENABLED 1 257 #elif defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__) 258 #define EA_COMPILER_CPP11_ENABLED 1 259 #elif defined(_MSC_VER) && _MSC_VER >= 1600 // Microsoft unilaterally enables its C++11 support; there is no way to disable it. 260 #define EA_COMPILER_CPP11_ENABLED 1 261 #elif defined(__SN_VER__) && (__SN_VER__ >= 43001) 262 #if __option(cpp11) 263 #define EA_COMPILER_CPP11_ENABLED 1 264 #endif 265 #elif defined(__EDG_VERSION__) // && ??? 266 // To do: Is there a generic way to determine this? 267 #endif 268 #endif 269 270 271 // EA_COMPILER_CPP14_ENABLED 272 // 273 // Defined as 1 if the compiler has its available C++14 support enabled, else undefined. 274 // This does not mean that all of C++14 or any particular feature of C++14 is supported 275 // by the compiler. It means that whatever C++14 support the compiler has is enabled. 276 // 277 // We cannot use (__cplusplus >= 201402L) alone because some compiler vendors have 278 // decided to not define __cplusplus like thus until they have fully completed their 279 // C++14 support. 280 #if !defined(EA_COMPILER_CPP14_ENABLED) && defined(__cplusplus) 281 #if (__cplusplus >= 201402L) // Clang and GCC defines this like so in C++14 mode. 282 #define EA_COMPILER_CPP14_ENABLED 1 283 #elif defined(_MSC_VER) && (_MSC_VER >= 1900) // VS2015+ 284 #define EA_COMPILER_CPP14_ENABLED 1 285 #endif 286 #endif 287 288 289 // EA_COMPILER_CPP17_ENABLED 290 // 291 // Defined as 1 if the compiler has its available C++17 support enabled, else undefined. 292 // This does not mean that all of C++17 or any particular feature of C++17 is supported 293 // by the compiler. It means that whatever C++17 support the compiler has is enabled. 294 // 295 // We cannot use (__cplusplus >= 201703L) alone because some compiler vendors have 296 // decided to not define __cplusplus like thus until they have fully completed their 297 // C++17 support. 298 #if !defined(EA_COMPILER_CPP17_ENABLED) && defined(__cplusplus) 299 #if (__cplusplus >= 201703L) 300 #define EA_COMPILER_CPP17_ENABLED 1 301 #elif defined(_MSVC_LANG) && (_MSVC_LANG >= 201703L) // C++17+ 302 #define EA_COMPILER_CPP17_ENABLED 1 303 #endif 304 #endif 305 306 307 #if defined(__ARMCC_VERSION) 308 // Note that this refers to the ARM RVCT compiler (armcc or armcpp), but there 309 // are other compilers that target ARM processors, such as GCC and Microsoft VC++. 310 // If you want to detect compiling for the ARM processor, check for EA_PROCESSOR_ARM 311 // being defined. 312 // This compiler is also identified by defined(__CC_ARM) || defined(__ARMCC__). 313 #define EA_COMPILER_RVCT 1 314 #define EA_COMPILER_ARM 1 315 #define EA_COMPILER_VERSION __ARMCC_VERSION 316 #define EA_COMPILER_NAME "RVCT" 317 //#define EA_COMPILER_STRING (defined below) 318 319 // Clang's GCC-compatible driver. 320 #elif defined(__clang__) && !defined(_MSC_VER) 321 #define EA_COMPILER_CLANG 1 322 #define EA_COMPILER_VERSION (__clang_major__ * 100 + __clang_minor__) 323 #define EA_COMPILER_NAME "clang" 324 #define EA_COMPILER_STRING EA_COMPILER_NAME __clang_version__ 325 326 // GCC (a.k.a. GNUC) 327 #elif defined(__GNUC__) // GCC compilers exist for many platforms. 328 #define EA_COMPILER_GNUC 1 329 #define EA_COMPILER_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__) 330 #define EA_COMPILER_NAME "GCC" 331 #define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( __GNUC__ ) "." INTERNAL_STRINGIZE( __GNUC_MINOR__ ) 332 333 #if (__GNUC__ == 2) && (__GNUC_MINOR__ < 95) // If GCC < 2.95... 334 #define EA_COMPILER_NO_MEMBER_TEMPLATES 1 335 #endif 336 #if (__GNUC__ == 2) && (__GNUC_MINOR__ <= 97) // If GCC <= 2.97... 337 #define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 1 338 #endif 339 #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)... 340 #define EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 1 341 #endif 342 343 // Borland C++ 344 #elif defined(__BORLANDC__) 345 #define EA_COMPILER_BORLANDC 1 346 #define EA_COMPILER_VERSION __BORLANDC__ 347 #define EA_COMPILER_NAME "Borland C" 348 //#define EA_COMPILER_STRING (defined below) 349 350 #if (__BORLANDC__ <= 0x0550) // If Borland C++ Builder 4 and 5... 351 #define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 1 352 #endif 353 #if (__BORLANDC__ >= 0x561) && (__BORLANDC__ < 0x600) 354 #define EA_COMPILER_NO_MEMBER_FUNCTION_SPECIALIZATION 1 355 #endif 356 357 358 // Intel C++ 359 // The Intel Windows compiler masquerades as VC++ and defines _MSC_VER. 360 // The Intel compiler is based on the EDG compiler front-end. 361 #elif defined(__ICL) || defined(__ICC) 362 #define EA_COMPILER_INTEL 1 363 364 // Should we enable the following? We probably should do so since enabling it does a lot more good than harm 365 // for users. The Intel Windows compiler does a pretty good job of emulating VC++ and so the user would likely 366 // have to handle few special cases where the Intel compiler doesn't emulate VC++ correctly. 367 #if defined(_MSC_VER) 368 #define EA_COMPILER_MSVC 1 369 #define EA_COMPILER_MICROSOFT 1 370 #endif 371 372 // Should we enable the following? This isn't as clear because as of this writing we don't know if the Intel 373 // compiler truly emulates GCC well enough that enabling this does more good than harm. 374 #if defined(__GNUC__) 375 #define EA_COMPILER_GNUC 1 376 #endif 377 378 #if defined(__ICL) 379 #define EA_COMPILER_VERSION __ICL 380 #elif defined(__ICC) 381 #define EA_COMPILER_VERSION __ICC 382 #endif 383 #define EA_COMPILER_NAME "Intel C++" 384 #if defined(_MSC_VER) 385 #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 ) 386 #elif defined(__GNUC__) 387 #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__ ) 388 #else 389 #define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE( EA_COMPILER_VERSION ) ", EDG version " INTERNAL_STRINGIZE( __EDG_VERSION__ ) 390 #endif 391 392 393 #elif defined(_MSC_VER) 394 #define EA_COMPILER_MSVC 1 395 #define EA_COMPILER_MICROSOFT 1 396 #define EA_COMPILER_VERSION _MSC_VER 397 #define EA_COMPILER_NAME "Microsoft Visual C++" 398 //#define EA_COMPILER_STRING (defined below) 399 400 #if defined(__clang__) 401 // Clang's MSVC-compatible driver. 402 #define EA_COMPILER_CLANG_CL 1 403 #endif 404 405 #define EA_STANDARD_LIBRARY_MSVC 1 406 #define EA_STANDARD_LIBRARY_MICROSOFT 1 407 408 #if (_MSC_VER <= 1200) // If VC6.x and earlier... 409 #if (_MSC_VER < 1200) 410 #define EA_COMPILER_MSVCOLD 1 411 #else 412 #define EA_COMPILER_MSVC6 1 413 #endif 414 415 #if (_MSC_VER < 1200) // If VC5.x or earlier... 416 #define EA_COMPILER_NO_TEMPLATE_SPECIALIZATION 1 417 #endif 418 #define EA_COMPILER_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 1 // The compiler compiles this OK, but executes it wrong. Fixed in VC7.0 419 #define EA_COMPILER_NO_VOID_RETURNS 1 // The compiler fails to compile such cases. Fixed in VC7.0 420 #define EA_COMPILER_NO_EXCEPTION_STD_NAMESPACE 1 // The compiler fails to compile such cases. Fixed in VC7.0 421 #define EA_COMPILER_NO_DEDUCED_TYPENAME 1 // The compiler fails to compile such cases. Fixed in VC7.0 422 #define EA_COMPILER_NO_STATIC_CONSTANTS 1 // The compiler fails to compile such cases. Fixed in VC7.0 423 #define EA_COMPILER_NO_COVARIANT_RETURN_TYPE 1 // The compiler fails to compile such cases. Fixed in VC7.1 424 #define EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP 1 // The compiler compiles this OK, but executes it wrong. Fixed in VC7.1 425 #define EA_COMPILER_NO_TEMPLATE_TEMPLATES 1 // The compiler fails to compile such cases. Fixed in VC7.1 426 #define EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION 1 // The compiler fails to compile such cases. Fixed in VC7.1 427 #define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 1 // The compiler fails to compile such cases. Fixed in VC7.1 428 //#define EA_COMPILER_NO_MEMBER_TEMPLATES 1 // VC6.x supports member templates properly 95% of the time. So do we flag the remaining 5%? 429 //#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%? 430 431 #elif (_MSC_VER <= 1300) // If VC7.0 and earlier... 432 #define EA_COMPILER_MSVC7 1 433 434 #define EA_COMPILER_NO_COVARIANT_RETURN_TYPE 1 // The compiler fails to compile such cases. Fixed in VC7.1 435 #define EA_COMPILER_NO_ARGUMENT_DEPENDENT_LOOKUP 1 // The compiler compiles this OK, but executes it wrong. Fixed in VC7.1 436 #define EA_COMPILER_NO_TEMPLATE_TEMPLATES 1 // The compiler fails to compile such cases. Fixed in VC7.1 437 #define EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION 1 // The compiler fails to compile such cases. Fixed in VC7.1 438 #define EA_COMPILER_NO_MEMBER_TEMPLATE_FRIENDS 1 // The compiler fails to compile such cases. Fixed in VC7.1 439 #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 440 //#define EA_COMPILER_NO_MEMBER_TEMPLATES 1 // VC7.0 supports member templates properly 95% of the time. So do we flag the remaining 5%? 441 442 #elif (_MSC_VER < 1400) // VS2003 _MSC_VER of 1300 means VC7 (VS2003) 443 // The VC7.1 and later compiler is fairly close to the C++ standard 444 // and thus has no compiler limitations that we are concerned about. 445 #define EA_COMPILER_MSVC7_2003 1 446 #define EA_COMPILER_MSVC7_1 1 447 448 #elif (_MSC_VER < 1500) // VS2005 _MSC_VER of 1400 means VC8 (VS2005) 449 #define EA_COMPILER_MSVC8_2005 1 450 #define EA_COMPILER_MSVC8_0 1 451 452 #elif (_MSC_VER < 1600) // VS2008. _MSC_VER of 1500 means VC9 (VS2008) 453 #define EA_COMPILER_MSVC9_2008 1 454 #define EA_COMPILER_MSVC9_0 1 455 456 #elif (_MSC_VER < 1700) // VS2010 _MSC_VER of 1600 means VC10 (VS2010) 457 #define EA_COMPILER_MSVC_2010 1 458 #define EA_COMPILER_MSVC10_0 1 459 460 #elif (_MSC_VER < 1800) // VS2012 _MSC_VER of 1700 means VS2011/VS2012 461 #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. 462 #define EA_COMPILER_MSVC11_0 1 463 #define EA_COMPILER_MSVC_2012 1 464 #define EA_COMPILER_MSVC12_0 1 465 466 #elif (_MSC_VER < 1900) // VS2013 _MSC_VER of 1800 means VS2013 467 #define EA_COMPILER_MSVC_2013 1 468 #define EA_COMPILER_MSVC13_0 1 469 470 #elif (_MSC_VER < 1910) // VS2015 _MSC_VER of 1900 means VS2015 471 #define EA_COMPILER_MSVC_2015 1 472 #define EA_COMPILER_MSVC14_0 1 473 474 #elif (_MSC_VER < 1911) // VS2017 _MSC_VER of 1910 means VS2017 475 #define EA_COMPILER_MSVC_2017 1 476 #define EA_COMPILER_MSVC15_0 1 477 478 #endif 479 480 481 // IBM 482 #elif defined(__xlC__) 483 #define EA_COMPILER_IBM 1 484 #define EA_COMPILER_NAME "IBM XL C" 485 #define EA_COMPILER_VERSION __xlC__ 486 #define EA_COMPILER_STRING "IBM XL C compiler, version " INTERNAL_STRINGIZE( __xlC__ ) 487 488 // Unknown 489 #else // Else the compiler is unknown 490 491 #define EA_COMPILER_VERSION 0 492 #define EA_COMPILER_NAME "Unknown" 493 494 #endif 495 496 #ifndef EA_COMPILER_STRING 497 #define EA_COMPILER_STRING EA_COMPILER_NAME " compiler, version " INTERNAL_STRINGIZE(EA_COMPILER_VERSION) 498 #endif 499 500 501 // Deprecated definitions 502 // For backwards compatibility, should be supported for at least the life of EABase v2.0.x. 503 #ifndef EA_COMPILER_NO_TEMPLATE_PARTIAL_SPECIALIZATION 504 #define EA_COMPILER_PARTIAL_TEMPLATE_SPECIALIZATION 1 505 #endif 506 #ifndef EA_COMPILER_NO_TEMPLATE_SPECIALIZATION 507 #define EA_COMPILER_TEMPLATE_SPECIALIZATION 1 508 #endif 509 #ifndef EA_COMPILER_NO_MEMBER_TEMPLATES 510 #define EA_COMPILER_MEMBER_TEMPLATES 1 511 #endif 512 #ifndef EA_COMPILER_NO_MEMBER_TEMPLATE_SPECIALIZATION 513 #define EA_COMPILER_MEMBER_TEMPLATE_SPECIALIZATION 1 514 #endif 515 516 517 518 /////////////////////////////////////////////////////////////////////////////// 519 // EA_COMPILER_VA_COPY_REQUIRED 520 // 521 // Defines whether va_copy must be used to copy or save va_list objects between uses. 522 // Some compilers on some platforms implement va_list whereby its contents 523 // are destroyed upon usage, even if passed by value to another function. 524 // With these compilers you can use va_copy to save and restore a va_list. 525 // Known compiler/platforms that destroy va_list contents upon usage include: 526 // CodeWarrior on PowerPC 527 // GCC on x86-64 528 // However, va_copy is part of the C99 standard and not part of earlier C and 529 // C++ standards. So not all compilers support it. VC++ doesn't support va_copy, 530 // but it turns out that VC++ doesn't usually need it on the platforms it supports, 531 // and va_copy can usually be implemented via memcpy(va_list, va_list) with VC++. 532 /////////////////////////////////////////////////////////////////////////////// 533 534 #ifndef EA_COMPILER_VA_COPY_REQUIRED 535 #if ((defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__clang__)) && (!defined(__i386__) || defined(__x86_64__)) && !defined(__ppc__) && !defined(__PPC__) && !defined(__PPC64__) 536 #define EA_COMPILER_VA_COPY_REQUIRED 1 537 #endif 538 #endif 539 540 541 // EA_COMPILER_NO_RTTI 542 // 543 // If EA_COMPILER_NO_RTTI is defined, then RTTI (run-time type information) 544 // is not available (possibly due to being disabled by the user). 545 // 546 #if defined(__EDG_VERSION__) && !defined(__RTTI) 547 #define EA_COMPILER_NO_RTTI 1 548 #elif defined(__clang__) && !EA_COMPILER_HAS_FEATURE(cxx_rtti) 549 #define EA_COMPILER_NO_RTTI 1 550 #elif defined(__IBMCPP__) && !defined(__RTTI_ALL__) 551 #define EA_COMPILER_NO_RTTI 1 552 #elif defined(__GXX_ABI_VERSION) && !defined(__GXX_RTTI) 553 #define EA_COMPILER_NO_RTTI 1 554 #elif defined(_MSC_VER) && !defined(_CPPRTTI) 555 #define EA_COMPILER_NO_RTTI 1 556 #elif defined(__ARMCC_VERSION) && defined(__TARGET_CPU_MPCORE) && !defined(__RTTI) 557 #define EA_COMPILER_NO_RTTI 1 558 #endif 559 560 561 562 // EA_COMPILER_NO_EXCEPTIONS / EA_COMPILER_NO_UNWIND 563 // 564 // If EA_COMPILER_NO_EXCEPTIONS is defined, then the compiler is 565 // configured to not recognize C++ exception-handling statements 566 // such as try/catch/throw. Thus, when EA_COMPILER_NO_EXCEPTIONS is 567 // defined, code that attempts to use exception handling statements 568 // will usually cause a compilation error. If is often desirable 569 // for projects to disable exception handling because exception 570 // handling causes extra code and/or data generation which might 571 // not be needed, especially if it is known that exceptions won't 572 // be happening. When writing code that is to be portable between 573 // systems of which some enable exception handling while others 574 // don't, check for EA_COMPILER_NO_EXCEPTIONS being defined. 575 // 576 #if !defined(EA_COMPILER_NO_EXCEPTIONS) && !defined(EA_COMPILER_NO_UNWIND) 577 #if defined(EA_COMPILER_GNUC) && defined(_NO_EX) // GCC on some platforms defines _NO_EX when exceptions are disabled. 578 #define EA_COMPILER_NO_EXCEPTIONS 1 579 580 #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. 581 #define EA_COMPILER_NO_EXCEPTIONS 1 582 583 #elif (defined(EA_COMPILER_BORLAND) || defined(EA_COMPILER_MSVC)) && !defined(_CPPUNWIND) 584 #define EA_COMPILER_NO_UNWIND 1 585 586 #endif // EA_COMPILER_NO_EXCEPTIONS / EA_COMPILER_NO_UNWIND 587 #endif // !defined(EA_COMPILER_NO_EXCEPTIONS) && !defined(EA_COMPILER_NO_UNWIND) 588 589 590 // ------------------------------------------------------------------------ 591 // EA_DISABLE_ALL_VC_WARNINGS / EA_RESTORE_ALL_VC_WARNINGS 592 // 593 // Disable and re-enable all warning(s) within code. 594 // 595 // Example usage: 596 // EA_DISABLE_ALL_VC_WARNINGS() 597 // <code> 598 // EA_RESTORE_ALL_VC_WARNINGS() 599 // 600 //This is duplicated from EABase's eacompilertraits.h 601 #ifndef EA_DISABLE_ALL_VC_WARNINGS 602 #if defined(_MSC_VER) 603 #define EA_DISABLE_ALL_VC_WARNINGS() \ 604 __pragma(warning(push, 0)) \ 605 __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. 606 #else 607 #define EA_DISABLE_ALL_VC_WARNINGS() 608 #endif 609 #endif 610 611 //This is duplicated from EABase's eacompilertraits.h 612 #ifndef EA_RESTORE_ALL_VC_WARNINGS 613 #if defined(_MSC_VER) 614 #define EA_RESTORE_ALL_VC_WARNINGS() \ 615 __pragma(warning(pop)) 616 #else 617 #define EA_RESTORE_ALL_VC_WARNINGS() 618 #endif 619 #endif 620 621 // Dinkumware 622 //This is duplicated from EABase's eahave.h 623 #if !defined(EA_HAVE_DINKUMWARE_CPP_LIBRARY) && !defined(EA_NO_HAVE_DINKUMWARE_CPP_LIBRARY) 624 #if defined(__cplusplus) 625 EA_DISABLE_ALL_VC_WARNINGS() 626 #include <cstddef> // Need to trigger the compilation of yvals.h without directly using <yvals.h> because it might not exist. 627 EA_RESTORE_ALL_VC_WARNINGS() 628 #endif 629 630 #if defined(__cplusplus) && defined(_CPPLIB_VER) /* If using the Dinkumware Standard library... */ 631 #define EA_HAVE_DINKUMWARE_CPP_LIBRARY 1 632 #else 633 #define EA_NO_HAVE_DINKUMWARE_CPP_LIBRARY 1 634 #endif 635 #endif 636 637 638 // EA_COMPILER_NO_ALIGNED_NEW 639 // 640 // 641 #if !defined(EA_COMPILER_NO_ALIGNED_NEW) 642 #if defined(_HAS_ALIGNED_NEW) && _HAS_ALIGNED_NEW // VS2017 15.5 Preview 643 // supported. 644 #elif defined(EA_COMPILER_CPP17_ENABLED) 645 // supported. 646 #else 647 #define EA_COMPILER_NO_ALIGNED_NEW 1 648 #endif 649 #endif 650 651 // EA_COMPILER_NO_NEW_THROW_SPEC / EA_THROW_SPEC_NEW / EA_THROW_SPEC_DELETE 652 // 653 // If defined then the compiler's version of operator new is not decorated 654 // with a throw specification. This is useful for us to know because we 655 // often want to write our own overloaded operator new implementations. 656 // We need such operator new overrides to be declared identically to the 657 // way the compiler is defining operator new itself. 658 // 659 // Example usage: 660 // void* operator new(std::size_t) EA_THROW_SPEC_NEW(std::bad_alloc); 661 // void* operator new[](std::size_t) EA_THROW_SPEC_NEW(std::bad_alloc); 662 // void* operator new(std::size_t, const std::nothrow_t&) EA_THROW_SPEC_NEW_NONE(); 663 // void* operator new[](std::size_t, const std::nothrow_t&) EA_THROW_SPEC_NEW_NONE(); 664 // void operator delete(void*) EA_THROW_SPEC_DELETE_NONE(); 665 // void operator delete[](void*) EA_THROW_SPEC_DELETE_NONE(); 666 // void operator delete(void*, const std::nothrow_t&) EA_THROW_SPEC_DELETE_NONE(); 667 // void operator delete[](void*, const std::nothrow_t&) EA_THROW_SPEC_DELETE_NONE(); 668 // 669 #if defined(EA_HAVE_DINKUMWARE_CPP_LIBRARY) 670 #if defined(_MSC_VER) && (_MSC_VER >= 1912) // VS2017 15.3+ 671 #define EA_THROW_SPEC_NEW(x) noexcept(false) 672 #define EA_THROW_SPEC_NEW_NONE() noexcept 673 #define EA_THROW_SPEC_DELETE_NONE() noexcept 674 675 #elif defined(_MSC_VER) && (_MSC_VER >= 1910) // VS2017+ 676 #define EA_THROW_SPEC_NEW(x) throw(x) 677 #define EA_THROW_SPEC_NEW_NONE() throw() 678 #define EA_THROW_SPEC_DELETE_NONE() throw() 679 680 #else 681 #if defined(EA_PLATFORM_PS4) 682 #define EA_THROW_SPEC_NEW(X) _THROWS(X) 683 #elif defined(_MSC_VER) 684 // Disabled warning "nonstandard extension used: 'throw (...)'" as this warning is a W4 warning which is usually off by default 685 // and doesn't convey any important information but will still complain when building with /Wall (which most teams do) 686 #define EA_THROW_SPEC_NEW(X) __pragma(warning(push)) __pragma(warning(disable: 4987)) _THROWS(X) __pragma(warning(pop)) 687 #else 688 #define EA_THROW_SPEC_NEW(X) _THROW1(X) 689 #endif 690 #define EA_THROW_SPEC_NEW_NONE() _THROW0() 691 #define EA_THROW_SPEC_DELETE_NONE() _THROW0() 692 693 #endif 694 #elif defined(EA_COMPILER_NO_EXCEPTIONS) && !defined(EA_COMPILER_RVCT) && !defined(EA_PLATFORM_LINUX) && !defined(EA_PLATFORM_APPLE) && !defined(CS_UNDEFINED_STRING) 695 #define EA_COMPILER_NO_NEW_THROW_SPEC 1 696 697 #define EA_THROW_SPEC_NEW(x) 698 #define EA_THROW_SPEC_NEW_NONE() 699 #define EA_THROW_SPEC_DELETE_NONE() 700 #else 701 #define EA_THROW_SPEC_NEW(x) throw(x) 702 #define EA_THROW_SPEC_NEW_NONE() throw() 703 #define EA_THROW_SPEC_DELETE_NONE() throw() 704 #endif 705 706 707 // EA_COMPILER_NO_STANDARD_CPP_LIBRARY 708 // 709 // If defined, then the compiler doesn't provide a Standard C++ library. 710 // 711 #if defined(EA_PLATFORM_ANDROID) 712 // Disabled because EA's eaconfig/android_config/android_sdk packages currently 713 // don't support linking STL libraries. Perhaps we can figure out what linker arguments 714 // are needed for an app so we can manually specify them and then re-enable this code. 715 //#include <android/api-level.h> 716 // 717 //#if (__ANDROID_API__ < 9) // Earlier versions of Android provide no std C++ STL implementation. 718 #define EA_COMPILER_NO_STANDARD_CPP_LIBRARY 1 719 //#endif 720 #endif 721 722 723 // EA_COMPILER_NO_STATIC_VARIABLE_INIT 724 // 725 // If defined, it means that global or static C++ variables will be 726 // constructed. Not all compiler/platorm combinations support this. 727 // User code that needs to be portable must avoid having C++ variables 728 // that construct before main. 729 // 730 //#if defined(EA_PLATFORM_MOBILE) 731 // #define EA_COMPILER_NO_STATIC_VARIABLE_INIT 1 732 //#endif 733 734 735 // EA_COMPILER_NO_STATIC_FUNCTION_INIT 736 // 737 // If defined, it means that functions marked as startup functions 738 // (e.g. __attribute__((constructor)) in GCC) are supported. It may 739 // be that some compiler/platform combinations don't support this. 740 // 741 //#if defined(XXX) // So far, all compiler/platforms we use support this. 742 // #define EA_COMPILER_NO_STATIC_VARIABLE_INIT 1 743 //#endif 744 745 // EA_COMPILER_NO_VARIADIC_MACROS 746 // 747 // If defined, the compiler doesn't support C99/C++11 variadic macros. 748 // With a variadic macro, you can do this: 749 // #define MY_PRINTF(format, ...) printf(format, __VA_ARGS__) 750 // 751 #if !defined(EA_COMPILER_NO_VARIADIC_MACROS) 752 #if defined(_MSC_VER) && (_MSC_VER < 1500) // If earlier than VS2008.. 753 #define EA_COMPILER_NO_VARIADIC_MACROS 1 754 #elif defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__)) < 401 // If earlier than GCC 4.1.. 755 #define EA_COMPILER_NO_VARIADIC_MACROS 1 756 #elif defined(EA_COMPILER_EDG) // Includes other compilers 757 // variadic macros are supported 758 #endif 759 #endif 760 761 762 // EA_COMPILER_NO_RVALUE_REFERENCES 763 // 764 // If defined, the compiler doesn't fully support C++11 rvalue reference semantics. 765 // This applies to the compiler only and not the Standard Library in use with the compiler, 766 // which is required by the Standard to have some support itself. 767 // 768 #if !defined(EA_COMPILER_NO_RVALUE_REFERENCES) 769 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_VER >= 1600) // VS2010+ 770 // supported. 771 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403) // EDG 4.3+. 772 // supported. Earlier EDG supported a subset of rvalue references. Implicit move constructors and assignment operators aren't supported until EDG 4.5. 773 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && EA_COMPILER_HAS_FEATURE(cxx_rvalue_references) 774 // supported. 775 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+ 776 // supported. 777 #else 778 #define EA_COMPILER_NO_RVALUE_REFERENCES 1 779 #endif 780 #endif 781 782 783 // EA_COMPILER_NO_EXTERN_TEMPLATE 784 // 785 // If defined, the compiler doesn't support C++11 extern template. 786 // With extern templates, you can do this: 787 // extern template void DoSomething(KnownType u); 788 // 789 #if !defined(EA_COMPILER_NO_EXTERN_TEMPLATE) 790 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_VER >= 1700) // VS2012+... 791 // Extern template is supported. 792 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+. 793 // supported. 794 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && defined(__apple_build_version__) && (EA_COMPILER_VERSION >= 401) 795 // Extern template is supported. 796 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && !defined(__apple_build_version__) // Clang other than Apple's Clang 797 // Extern template is supported. 798 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+ 799 // Extern template is supported. 800 #else 801 #define EA_COMPILER_NO_EXTERN_TEMPLATE 1 802 #endif 803 #endif 804 805 806 // EA_COMPILER_NO_RANGE_BASED_FOR_LOOP 807 // 808 // If defined, the compiler doesn't support C++11 range-based for loops. 809 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html 810 // You must #include <iterator> for range-based for loops to work. 811 // Example usage: 812 // #include <iterator> 813 // #include <vector> 814 // std::vector<float> floatVector; 815 // for(float& f : floatVector) 816 // f += 1.0; 817 // 818 #if !defined(EA_COMPILER_NO_RANGE_BASED_FOR_LOOP) 819 #if defined(EA_COMPILER_CPP11_ENABLED) && (defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1700)) // VS2012+... 820 // supported. 821 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+. 822 // supported. 823 #elif defined(EA_COMPILER_CPP11_ENABLED) && (defined(__clang__) && (EA_COMPILER_VERSION >= 300)) // Clang 3.x+ 824 // supported. 825 #elif defined(EA_COMPILER_CPP11_ENABLED) && (defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006)) // GCC 4.6+ 826 // supported. 827 #else 828 #define EA_COMPILER_NO_RANGE_BASED_FOR_LOOP 1 829 #endif 830 #endif 831 832 833 // EA_COMPILER_NO_CONSTEXPR 834 // 835 // Refers to C++11 = constexpr (const expression) declarations. 836 // 837 #if !defined(EA_COMPILER_NO_CONSTEXPR) 838 #if defined(EA_COMPILER_CPP11_ENABLED) && (defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1900)) // VS2015+... Not present in VC++ up to and including VS2013. 839 // supported. 840 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406) // EDG 4.6+. 841 // supported. 842 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && EA_COMPILER_HAS_FEATURE(cxx_constexpr) 843 // supported. 844 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+ 845 // supported. 846 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1900) // VS 2015+ 847 // supported. 848 #else 849 #define EA_COMPILER_NO_CONSTEXPR 1 850 #endif 851 #endif 852 853 854 // EA_COMPILER_NO_CONSTEXPR_IF 855 // 856 // Refers to C++17 = constexpr if(const expression) conditionals. 857 // 858 #if !defined(EA_COMPILER_NO_CONSTEXPR_IF) 859 #if defined(EA_COMPILER_CPP17_ENABLED) && (defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1911)) // VS2017 15.3+ 860 // supported. 861 #elif defined(EA_COMPILER_CPP17_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 309) // Clang 3.9+ 862 // supported. 863 #elif defined(EA_COMPILER_CPP17_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 7000) // GCC 7+ 864 // supported. 865 #else 866 #define EA_COMPILER_NO_CONSTEXPR_IF 1 867 #endif 868 #endif 869 870 871 // EA_COMPILER_NO_OVERRIDE 872 // 873 // Refers to the C++11 override specifier. 874 // 875 #ifndef EA_COMPILER_NO_OVERRIDE 876 #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' 877 // supported. 878 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+ 879 // supported. 880 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+ 881 // supported. 882 #else 883 #define EA_COMPILER_NO_OVERRIDE 1 884 #endif 885 #endif 886 887 888 // EA_COMPILER_NO_INHERITANCE_FINAL 889 // 890 // Refers to the C++11 final specifier. 891 // 892 #ifndef EA_COMPILER_NO_INHERITANCE_FINAL 893 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1500) // VS2008+, even without C++11 support. 894 // supported, though you need to use EA_INHERITANCE_FINAL for it to work with VS versions prior to 2012. 895 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+ 896 // supported 897 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+ 898 // supported 899 #else 900 #define EA_COMPILER_NO_INHERITANCE_FINAL 1 901 #endif 902 #endif 903 904 905 // EA_COMPILER_NO_AUTO 906 // 907 // Refers to C++11 auto. 908 // 909 #if !defined(EA_COMPILER_NO_AUTO) 910 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+ 911 // supported. 912 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+. 913 // supported with the exception of the usage of braced initializer lists as of EDG 4.3. 914 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 915 // supported. 916 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 917 // supported. 918 #else 919 #define EA_COMPILER_NO_AUTO 1 920 #endif 921 #endif 922 923 924 // EA_COMPILER_NO_NULLPTR 925 // 926 // Refers to C++11 nullptr (which is a built in type). std::nullptr_t is defined in C++11 <cstddef>. 927 // Note that <EABase/nullptr.h> implements a portable nullptr implementation. 928 // 929 #if !defined(EA_COMPILER_NO_NULLPTR) 930 #if (defined(_MSC_VER) && (_MSC_VER >= 1600)) && defined(EA_COMPILER_CPP11_ENABLED) 931 // supported 932 #elif defined(EA_COMPILER_GNUC) && (EA_COMPILER_VERSION >= 4006) && defined(EA_COMPILER_CPP11_ENABLED) 933 // supported 934 #elif defined(__clang__) && defined(EA_COMPILER_CPP11_ENABLED) 935 // supported 936 #elif defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403) && defined(EA_COMPILER_CPP11_ENABLED) 937 // supported 938 #else 939 #define EA_COMPILER_NO_NULLPTR 1 940 #endif 941 #endif 942 943 944 // EA_COMPILER_NO_DECLTYPE 945 // 946 // Refers to C++11 decltype. 947 // 948 #if !defined(EA_COMPILER_NO_DECLTYPE) 949 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+ 950 // supported, though VS2010 doesn't support the spec completely as specified in the final standard. 951 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+. 952 // supported. 953 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 954 // supported. 955 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4003) // GCC 4.3+ 956 // supported. 957 #else 958 #define EA_COMPILER_NO_DECLTYPE 1 959 #endif 960 #endif 961 962 963 964 // EA_COMPILER_NO_DEFAULTED_FUNCTIONS 965 // EA_COMPILER_NO_DELETED_FUNCTIONS 966 // 967 // Refers to C++11 = default and = delete function declarations. 968 // 969 #if !defined(EA_COMPILER_NO_DEFAULTED_FUNCTIONS) 970 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+ 971 // supported, but as of VS2013 it isn't supported for defaulted move constructors and move assignment operators. 972 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+. 973 // supported, but as of EDG 4.3 it isn't supported for defaulted move constructors and move assignment operators until EDG 4.5. 974 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) // Clang 3.0+, including Apple's Clang 975 // supported. 976 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 977 // supported. 978 #else 979 // VC++ doesn't support it as of VS2012. 980 #define EA_COMPILER_NO_DEFAULTED_FUNCTIONS 1 981 #endif 982 #endif 983 984 #if !defined(EA_COMPILER_NO_DELETED_FUNCTIONS) 985 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+ 986 // supported, but as of VS2013 it isn't supported for defaulted move constructors and move assignment operators. 987 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+. 988 // supported. 989 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+ 990 // supported. 991 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 992 // supported. 993 #else 994 // VC++ doesn't support it as of VS2012. 995 #define EA_COMPILER_NO_DELETED_FUNCTIONS 1 996 #endif 997 #endif 998 999 1000 // EA_COMPILER_NO_LAMBDA_EXPRESSIONS 1001 // 1002 // Refers to C++11 lambda expressions. 1003 // 1004 #if !defined(EA_COMPILER_NO_LAMBDA_EXPRESSIONS) 1005 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+ 1006 // supported, though VS2010 doesn't support the spec completely as specified in the final standard. 1007 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+. 1008 // supported. However, converting lambdas to function pointers is not supported until EDG 4.5. 1009 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) 1010 // supported. 1011 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1012 // supported. 1013 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 1014 // supported. 1015 #else 1016 #define EA_COMPILER_NO_LAMBDA_EXPRESSIONS 1 1017 #endif 1018 #endif 1019 1020 1021 // EA_COMPILER_NO_TRAILING_RETURN_TYPES 1022 // 1023 // Refers to C++11 trailing-return-type. Also sometimes referred to as "incomplete return type". 1024 // 1025 #if !defined(EA_COMPILER_NO_TRAILING_RETURN_TYPES) 1026 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+ 1027 // supported, though VS2010 doesn't support the spec completely as specified in the final standard. 1028 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+. 1029 // supported. However, use of "this" in trailing return types is not supported untiil EDG 4.4 1030 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) 1031 // supported. 1032 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1033 // supported. 1034 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 1035 // supported. 1036 #else 1037 #define EA_COMPILER_NO_TRAILING_RETURN_TYPES 1 1038 #endif 1039 #endif 1040 1041 1042 // EA_COMPILER_NO_STRONGLY_TYPED_ENUMS 1043 // 1044 // Refers to C++11 strongly typed enums, which includes enum classes and sized enums. Doesn't include forward-declared enums. 1045 // 1046 #if !defined(EA_COMPILER_NO_STRONGLY_TYPED_ENUMS) 1047 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1700) // VS2012+ 1048 // supported. A subset of this is actually supported by VS2010. 1049 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 400) // EDG 4.0+. 1050 // supported. 1051 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 1052 // supported. 1053 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 1054 // supported. 1055 #else 1056 #define EA_COMPILER_NO_STRONGLY_TYPED_ENUMS 1 1057 #endif 1058 #endif 1059 1060 1061 // EA_COMPILER_NO_FORWARD_DECLARED_ENUMS 1062 // 1063 // Refers to C++11 forward declared enums. 1064 // 1065 #if !defined(EA_COMPILER_NO_FORWARD_DECLARED_ENUMS) 1066 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1700) // VS2012+ 1067 // supported. 1068 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+. 1069 // supported. EDG 4.3 supports basic forward-declared enums, but not forward-declared strongly typed enums. 1070 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) 1071 // supported. 1072 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1073 // supported. 1074 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+ 1075 // supported. 1076 #else 1077 #define EA_COMPILER_NO_FORWARD_DECLARED_ENUMS 1 1078 #endif 1079 #endif 1080 1081 1082 // EA_COMPILER_NO_VARIADIC_TEMPLATES 1083 // 1084 // Refers to C++11 variadic templates. 1085 // 1086 #if !defined(EA_COMPILER_NO_VARIADIC_TEMPLATES) 1087 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1088 // supported. 1089 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_FULL_VER == 170051025) // VS2012 November Preview for Windows only. 1090 // supported. 1091 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403) // EDG 4.3+. 1092 // supported, though 4.1 has partial support for variadic templates. 1093 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 1094 // supported. 1095 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 1096 // supported, though GCC 4.3 has partial support for variadic templates. 1097 #else 1098 #define EA_COMPILER_NO_VARIADIC_TEMPLATES 1 1099 #endif 1100 #endif 1101 1102 1103 // EA_COMPILER_NO_TEMPLATE_ALIASES 1104 // 1105 // Refers to C++11 alias templates. 1106 // Example alias template usage: 1107 // template <typename T> 1108 // using Dictionary = eastl::map<eastl::string, T>; 1109 // 1110 // Dictionary<int> StringIntDictionary; 1111 // 1112 #if !defined(EA_COMPILER_NO_TEMPLATE_ALIASES) 1113 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1114 // supported. 1115 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) 1116 // supported. 1117 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+. 1118 // supported, though 4.1 has partial support for variadic templates. 1119 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1120 // supported. 1121 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+ 1122 // supported, though GCC 4.3 has partial support for variadic templates. 1123 #else 1124 #define EA_COMPILER_NO_TEMPLATE_ALIASES 1 1125 #endif 1126 #endif 1127 1128 1129 // EA_COMPILER_NO_VARIABLE_TEMPLATES 1130 // 1131 // Refers to C++14 variable templates. 1132 // Example variable template usage: 1133 // template<class T> 1134 // constexpr T pi = T(3.1415926535897932385); 1135 // 1136 #if !defined(EA_COMPILER_NO_VARIABLE_TEMPLATES) 1137 #if defined(_MSC_VER) && (_MSC_FULL_VER >= 190023918) // VS2015 Update 2 and above. 1138 // supported. 1139 #elif defined(EA_COMPILER_CPP14_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 304) && !defined(__apple_build_version__) // Clang 3.4+, not including Apple's Clang. 1140 // supported. 1141 #elif defined(EA_COMPILER_CPP14_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 5000) // GCC 5+ 1142 // supported. 1143 #elif !defined(EA_COMPILER_CPP14_ENABLED) 1144 #define EA_COMPILER_NO_VARIABLE_TEMPLATES 1 1145 #endif 1146 #endif 1147 1148 1149 // EA_COMPILER_NO_INLINE_VARIABLES 1150 // 1151 // Refers to C++17 inline variables that allows the definition of variables in header files 1152 // 1153 // Example usage: 1154 // struct Foo 1155 // { 1156 // static inline constexpr int kConstant = 42; // no out of class definition 1157 // }; 1158 // 1159 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4424.pdf 1160 // http://en.cppreference.com/w/cpp/language/inline 1161 // 1162 #if !defined(EA_COMPILER_NO_INLINE_VARIABLES) 1163 #define EA_COMPILER_NO_INLINE_VARIABLES 1 1164 #endif 1165 1166 1167 // EA_COMPILER_NO_INITIALIZER_LISTS 1168 // 1169 // Refers to C++11 initializer lists. 1170 // This refers to the compiler support for this and not the Standard Library support (std::initializer_list). 1171 // 1172 #if !defined(EA_COMPILER_NO_INITIALIZER_LISTS) 1173 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1174 // supported. 1175 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_FULL_VER == 170051025) // VS2012 November Preview for Windows only. 1176 // supported. 1177 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+. 1178 // supported. 1179 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) 1180 // supported. 1181 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1182 // supported. 1183 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 1184 // supported, though GCC 4.3 has partial support for it. 1185 #else 1186 #define EA_COMPILER_NO_INITIALIZER_LISTS 1 1187 #endif 1188 #endif 1189 1190 1191 // EA_COMPILER_NO_NORETURN 1192 // 1193 // Refers to C++11 declaration attribute: noreturn. 1194 // http://en.cppreference.com/w/cpp/language/attributes 1195 // http://blog.aaronballman.com/2011/09/understanding-attributes/ 1196 // 1197 #if !defined(EA_COMPILER_NO_NORETURN) 1198 #if defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1300) // VS2003+ 1199 // supported via __declspec(noreturn). You need to use that or EA_NORETURN. VC++ up to VS2013 doesn't support any C++11 attribute types. 1200 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+. 1201 // supported. 1202 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) 1203 // supported. 1204 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1205 // supported. 1206 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+ 1207 // supported. 1208 #else 1209 #define EA_COMPILER_NO_NORETURN 1 1210 #endif 1211 #endif 1212 1213 1214 // EA_COMPILER_NO_CARRIES_DEPENDENCY 1215 // 1216 // Refers to C++11 declaration attribute: carries_dependency. 1217 // http://en.cppreference.com/w/cpp/language/attributes 1218 // http://blog.aaronballman.com/2011/09/understanding-attributes/ 1219 // 1220 #if !defined(EA_COMPILER_NO_CARRIES_DEPENDENCY) 1221 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1222 // supported. 1223 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+. 1224 // supported; stricter than other compilers in its usage. 1225 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1226 // supported. 1227 // Currently GNUC doesn't appear to support this attribute. 1228 //#elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+ 1229 // // supported. 1230 #else 1231 #define EA_COMPILER_NO_CARRIES_DEPENDENCY 1 1232 #endif 1233 #endif 1234 1235 1236 // EA_COMPILER_NO_FALLTHROUGH 1237 // 1238 // Refers to C++17 declaration attribute: fallthrough. 1239 // http://en.cppreference.com/w/cpp/language/attributes 1240 // 1241 #if !defined(EA_COMPILER_NO_FALLTHROUGH) 1242 #if defined(EA_COMPILER_CPP17_ENABLED) 1243 // supported. 1244 #else 1245 #define EA_COMPILER_NO_FALLTHROUGH 1 1246 #endif 1247 #endif 1248 1249 1250 // EA_COMPILER_NO_NODISCARD 1251 // 1252 // Refers to C++17 declaration attribute: nodiscard. 1253 // http://en.cppreference.com/w/cpp/language/attributes 1254 // 1255 #if !defined(EA_COMPILER_NO_NODISCARD) 1256 #if defined(EA_COMPILER_CPP17_ENABLED) 1257 // supported. 1258 #else 1259 #define EA_COMPILER_NO_NODISCARD 1 1260 #endif 1261 #endif 1262 1263 1264 // EA_COMPILER_NO_MAYBE_UNUSED 1265 // 1266 // Refers to C++17 declaration attribute: maybe_unused. 1267 // http://en.cppreference.com/w/cpp/language/attributes 1268 // 1269 #if !defined(EA_COMPILER_NO_MAYBE_UNUSED) 1270 #if defined(EA_COMPILER_CPP17_ENABLED) 1271 // supported. 1272 #elif defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1912) // VS2017 15.3+ 1273 // supported. 1274 #else 1275 #define EA_COMPILER_NO_MAYBE_UNUSED 1 1276 #endif 1277 #endif 1278 1279 1280 // EA_COMPILER_NO_STRUCTURED_BINDING 1281 // 1282 // Indicates if target compiler supports the C++17 "structured binding" language feature. 1283 // https://en.cppreference.com/w/cpp/language/structured_binding 1284 // 1285 // 1286 #if !defined(EA_COMPILER_NO_STRUCTURED_BINDING) 1287 #if defined(EA_COMPILER_CPP17_ENABLED) 1288 // supported. 1289 #elif defined(EA_COMPILER_MSVC) && (EA_COMPILER_VERSION >= 1912) // VS2017 15.3+ 1290 // supported. 1291 #else 1292 #define EA_COMPILER_NO_STRUCTURED_BINDING 1 1293 #endif 1294 #endif 1295 1296 1297 // EA_COMPILER_NO_NONSTATIC_MEMBER_INITIALIZERS 1298 // 1299 // Refers to C++11 declaration attribute: carries_dependency. 1300 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2756.htm 1301 // 1302 #if !defined(EA_COMPILER_NO_NONSTATIC_MEMBER_INITIALIZERS) 1303 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1304 // supported. 1305 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1306 // supported. 1307 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1308 // supported. 1309 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+ 1310 // supported. 1311 #else 1312 #define EA_COMPILER_NO_NONSTATIC_MEMBER_INITIALIZERS 1 1313 #endif 1314 #endif 1315 1316 1317 // EA_COMPILER_NO_RIGHT_ANGLE_BRACKETS 1318 // 1319 // Defines if the compiler supports >> (as opposed to > >) in template 1320 // declarations such as typedef eastl::list<eastl::list<int>> ListList; 1321 // 1322 #if !defined(EA_COMPILER_NO_RIGHT_ANGLE_BRACKETS) 1323 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+ 1324 // supported. 1325 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+. 1326 // supported. 1327 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 1328 // supported. 1329 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4003) // GCC 4.3+ 1330 // supported. 1331 #else 1332 #define EA_COMPILER_NO_RIGHT_ANGLE_BRACKETS 1 1333 #endif 1334 #endif 1335 1336 1337 // EA_COMPILER_NO_ALIGNOF 1338 // 1339 // Refers specifically to C++11 alignof and not old compiler extensions such as __alignof__(). 1340 // However, EABase provides a portable EA_ALIGN_OF which works for all compilers. 1341 // 1342 #if !defined(EA_COMPILER_NO_ALIGNOF) 1343 // Not supported by VC++ as of VS2013, though EA_ALIGN_OF is supported on all coompilers as an alternative. 1344 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 1345 // supported. 1346 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+ 1347 // supported. 1348 #else 1349 #define EA_COMPILER_NO_ALIGNOF 1 1350 #endif 1351 #endif 1352 1353 1354 // EA_COMPILER_NO_ALIGNAS 1355 // 1356 // Refers to C++11 alignas. 1357 // 1358 #if !defined(EA_COMPILER_NO_ALIGNAS) 1359 // Not supported by VC++ as of VS2013. 1360 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1361 // supported. 1362 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1363 // supported. 1364 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+ 1365 // supported. 1366 #else 1367 #define EA_COMPILER_NO_ALIGNAS 1 1368 #endif 1369 #endif 1370 1371 1372 // EA_COMPILER_NO_DELEGATING_CONSTRUCTORS 1373 // 1374 // Refers to C++11 constructor delegation. 1375 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf 1376 // https://www.ibm.com/developerworks/mydeveloperworks/blogs/5894415f-be62-4bc0-81c5-3956e82276f3/entry/c_0x_delegating_constructors 1377 // 1378 #if !defined(EA_COMPILER_NO_DELEGATING_CONSTRUCTORS) 1379 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1380 // supported. 1381 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407) // EDG 4.7+. 1382 // supported. 1383 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1384 // supported. 1385 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1386 // supported. 1387 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+ 1388 // supported. 1389 #else 1390 #define EA_COMPILER_NO_DELEGATING_CONSTRUCTORS 1 1391 #endif 1392 #endif 1393 1394 1395 // EA_COMPILER_NO_INHERITING_CONSTRUCTORS 1396 // 1397 // Refers to C++11 constructor inheritance via 'using'. 1398 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm 1399 // 1400 #if !defined(EA_COMPILER_NO_INHERITING_CONSTRUCTORS) 1401 // Not supported by VC++ as of VS2013. 1402 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && EA_COMPILER_HAS_FEATURE(cxx_inheriting_constructors) // Clang 1403 // supported. 1404 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+ 1405 // supported. 1406 #else 1407 #define EA_COMPILER_NO_INHERITING_CONSTRUCTORS 1 1408 #endif 1409 #endif 1410 1411 1412 // EA_COMPILER_NO_USER_DEFINED_LITERALS 1413 // 1414 // http://en.cppreference.com/w/cpp/language/user_literal 1415 // http://stackoverflow.com/questions/237804/what-new-capabilities-do-user-defined-literals-add-to-c 1416 // 1417 #if !defined(EA_COMPILER_NO_USER_DEFINED_LITERALS) 1418 // Not supported by VC++ as of VS2013. 1419 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1420 // supported. 1421 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1422 // supported. 1423 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+ 1424 // supported. 1425 #else 1426 #define EA_COMPILER_NO_USER_DEFINED_LITERALS 1 1427 #endif 1428 #endif 1429 1430 1431 // EA_COMPILER_NO_STANDARD_LAYOUT_TYPES 1432 // a.k.a. POD relaxation 1433 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2342.htm 1434 // 1435 #if !defined(EA_COMPILER_NO_STANDARD_LAYOUT_TYPES) 1436 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1700) // VS2012+ 1437 // supported. 1438 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1439 // supported. 1440 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1441 // supported. 1442 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+ 1443 // supported. 1444 #else 1445 #define EA_COMPILER_NO_STANDARD_LAYOUT_TYPES 1 1446 #endif 1447 #endif 1448 1449 1450 // EA_COMPILER_NO_EXTENDED_SIZEOF 1451 // 1452 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2253.html 1453 // Allows you to do this: sizeof(SomeClass::mSomeMember) 1454 // 1455 #if !defined(EA_COMPILER_NO_EXTENDED_SIZEOF) 1456 // Not supported by VC++ as of VS2013. 1457 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1458 // supported. 1459 // Versions of EDG prior to 4.5 only support extended sizeof in non-member functions. Full support was added in 4.5 1460 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+. 1461 // supported. 1462 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1463 // supported. 1464 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+ 1465 // supported. 1466 #else 1467 #define EA_COMPILER_NO_EXTENDED_SIZEOF 1 1468 #endif 1469 #endif 1470 1471 1472 // EA_COMPILER_NO_INLINE_NAMESPACES 1473 // 1474 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm 1475 // http://blog.aaronballman.com/2011/07/inline-namespaces/ 1476 // 1477 #if !defined(EA_COMPILER_NO_INLINE_NAMESPACES) 1478 // Not supported by VC++ as of VS2013. 1479 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+. 1480 // supported. 1481 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 1482 // supported. 1483 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 1484 // supported. 1485 #else 1486 #define EA_COMPILER_NO_INLINE_NAMESPACES 1 1487 #endif 1488 #endif 1489 1490 1491 // EA_COMPILER_NO_UNRESTRICTED_UNIONS 1492 // 1493 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf 1494 // 1495 #if !defined(EA_COMPILER_NO_UNRESTRICTED_UNIONS) 1496 // Not supported by VC++ as of VS2013. 1497 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 406) // EDG 4.6+. 1498 // supported. 1499 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1500 // supported. 1501 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1502 // supported. 1503 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+ 1504 // supported. 1505 #else 1506 #define EA_COMPILER_NO_UNRESTRICTED_UNIONS 1 1507 #endif 1508 #endif 1509 1510 1511 // EA_COMPILER_NO_EXPLICIT_CONVERSION_OPERATORS 1512 // 1513 // http://en.wikipedia.org/wiki/C%2B%2B11#Explicit_conversion_operators 1514 // 1515 #if !defined(EA_COMPILER_NO_EXPLICIT_CONVERSION_OPERATORS) 1516 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1517 // supported. 1518 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (_MSC_FULL_VER == 170051025) // VS2012 November Preview for Windows only. 1519 // supported. 1520 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 404) // EDG 4.4+. 1521 // supported. 1522 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1523 // supported. 1524 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1525 // supported. 1526 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+ 1527 // supported. 1528 #else 1529 #define EA_COMPILER_NO_EXPLICIT_CONVERSION_OPERATORS 1 1530 #endif 1531 #endif 1532 1533 1534 // EA_COMPILER_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 1535 // 1536 // The compiler does not support default template arguments for function templates. 1537 // http://stackoverflow.com/questions/2447458/default-template-arguments-for-function-templates 1538 // 1539 #if !defined(EA_COMPILER_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS) 1540 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1541 // supported. 1542 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403) // EDG 4.4+. 1543 // supported. 1544 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 1545 // supported. 1546 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4003) // GCC 4.3+ 1547 // supported. 1548 #else 1549 #define EA_COMPILER_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 1 1550 #endif 1551 #endif 1552 1553 1554 // EA_COMPILER_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 1555 // 1556 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm 1557 // http://stackoverflow.com/questions/5751977/local-type-as-template-arguments-in-c 1558 // 1559 #if !defined(EA_COMPILER_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS) 1560 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+ 1561 // supported. 1562 #if (EA_COMPILER_VERSION < 1700) // VS2010 generates a warning, but the C++ language now allows it. 1563 #pragma warning(disable: 4836) // nonstandard extension used: local types or unnamed types cannot be used as template arguments. 1564 #endif 1565 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 402) // EDG 4.2+. 1566 // supported. 1567 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 1568 // supported. 1569 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+ 1570 // supported. 1571 #else 1572 #define EA_COMPILER_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 1 1573 #endif 1574 #endif 1575 1576 1577 // EA_COMPILER_NO_NOEXCEPT 1578 // 1579 // C++11 noexcept 1580 // http://en.cppreference.com/w/cpp/language/attributes 1581 // http://en.cppreference.com/w/cpp/language/noexcept 1582 // 1583 #if !defined(EA_COMPILER_NO_NOEXCEPT) 1584 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1900) // VS2014+ 1585 // supported. 1586 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1587 // supported. 1588 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 405) // EDG 4.5+. 1589 // supported. 1590 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1591 // supported. 1592 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4006) // GCC 4.6+ 1593 // supported. 1594 #else 1595 #define EA_COMPILER_NO_NOEXCEPT 1 1596 #endif 1597 #endif 1598 1599 1600 // EA_COMPILER_NO_RAW_LITERALS 1601 // 1602 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm 1603 // http://en.wikipedia.org/wiki/C%2B%2B11#New_string_literals 1604 // 1605 #if !defined(EA_COMPILER_NO_RAW_LITERALS) 1606 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1607 // supported. 1608 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407) // EDG 4.7+. 1609 // supported. 1610 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1611 // supported. 1612 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1613 // supported. 1614 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+ 1615 // supported. 1616 #else 1617 #define EA_COMPILER_NO_RAW_LITERALS 1 1618 #endif 1619 #endif 1620 1621 1622 // EA_COMPILER_NO_UNICODE_STRING_LITERALS 1623 // 1624 // http://en.wikipedia.org/wiki/C%2B%2B11#New_string_literals 1625 // 1626 #if !defined(EA_COMPILER_NO_UNICODE_STRING_LITERALS) 1627 // Not supported by VC++ as of VS2013. 1628 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407) // EDG 4.7+. 1629 // supported. It's not clear if it's v4.4 or v4.7 that adds this support. 1630 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1631 // supported. 1632 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 300) && !defined(__apple_build_version__) // Clang 3.0+, not including Apple's Clang. 1633 // supported. 1634 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 1635 // supported. 1636 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 407) // EDG 4.7+. 1637 // supported. It's not clear if it's v4.4 or v4.7 that adds this support. 1638 #else 1639 #define EA_COMPILER_NO_UNICODE_STRING_LITERALS 1 1640 #endif 1641 #endif 1642 1643 1644 // EA_COMPILER_NO_NEW_CHARACTER_TYPES 1645 // 1646 // Refers to char16_t and char32_t as true native types (and not something simply typedef'd from uint16_t and uint32_t). 1647 // http://en.cppreference.com/w/cpp/language/types 1648 // 1649 #if !defined(EA_COMPILER_NO_NEW_CHARACTER_TYPES) 1650 #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. 1651 #define EA_COMPILER_NO_NEW_CHARACTER_TYPES 1 1652 #endif 1653 #endif 1654 1655 1656 // EA_COMPILER_NO_UNICODE_CHAR_NAME_LITERALS 1657 // 1658 // C++ 11 relaxed \u\U sequences in strings. 1659 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2170.html 1660 // 1661 #if !defined(EA_COMPILER_NO_UNICODE_CHAR_NAME_LITERALS) 1662 // VC++ up till at least VS2013 supports \u and \U but supports them wrong with respect to the C++11 Standard. 1663 1664 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1665 // supported. 1666 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1667 // supported. 1668 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4005) // GCC 4.5+ 1669 // supported. 1670 #else 1671 #define EA_COMPILER_NO_UNICODE_CHAR_NAME_LITERALS 1 1672 #endif 1673 #endif 1674 1675 1676 // EA_COMPILER_NO_UNIFIED_INITIALIZATION_SYNTAX 1677 // 1678 // http://en.wikipedia.org/wiki/C%2B%2B11#Uniform_initialization 1679 // 1680 #if !defined(EA_COMPILER_NO_UNIFIED_INITIALIZATION_SYNTAX) 1681 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1800) // VS2013+. 1682 // supported. 1683 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 401) && defined(__apple_build_version__) // Apple clang 4.1+ 1684 // supported. 1685 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 301) && !defined(__apple_build_version__) // Clang 3.1+, not including Apple's Clang. 1686 // supported. 1687 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4004) // GCC 4.4+ 1688 // supported. 1689 #else 1690 #define EA_COMPILER_NO_UNIFIED_INITIALIZATION_SYNTAX 1 1691 #endif 1692 #endif 1693 1694 1695 // EA_COMPILER_NO_EXTENDED_FRIEND_DECLARATIONS 1696 // 1697 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf 1698 // 1699 #if !defined(EA_COMPILER_NO_EXTENDED_FRIEND_DECLARATIONS) 1700 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1600) // VS2010+ 1701 // supported. 1702 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 401) // EDG 4.1+. 1703 // supported. 1704 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && (EA_COMPILER_VERSION >= 209) // Clang 2.9+, including Apple's Clang. 1705 // supported. 1706 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4007) // GCC 4.7+ 1707 // supported. 1708 #else 1709 #define EA_COMPILER_NO_EXTENDED_FRIEND_DECLARATIONS 1 1710 #endif 1711 #endif 1712 1713 1714 // EA_COMPILER_NO_THREAD_LOCAL 1715 // 1716 // Refers specifically to C++ thread_local, which is like compiler __thread implementations except 1717 // that it also supports non-trivial classes (e.g. with ctors). EA_COMPILER_NO_THREAD_LOCAL refers 1718 // specifically to full C++11 thread_local support. The EAThread package provides a wrapper for 1719 // __thread via EA_THREAD_LOCAL (which unfortunately sounds like C++ thread_local). 1720 // 1721 #if !defined(EA_COMPILER_NO_THREAD_LOCAL) 1722 // Not supported by VC++ as of VS2013, though all VC++ versions have partial support via __thread. 1723 1724 //#if defined(EA_COMPILER_CPP11_ENABLED) && defined(__clang__) && __has_feature(cxx_thread_local) && _______ 1725 // // thread_local requires a cooperating standard library, and we yet don't have a means to identify such a thing. 1726 1727 #if defined(EA_COMPILER_CPP11_ENABLED) && defined(_MSC_VER) && (EA_COMPILER_VERSION >= 1900) // VS2015+ 1728 // supported. 1729 #elif defined(EA_COMPILER_CPP11_ENABLED) && defined(__GNUC__) && (EA_COMPILER_VERSION >= 4008) // GCC 4.8+ 1730 // supported. 1731 #else 1732 #define EA_COMPILER_NO_THREAD_LOCAL 1 1733 #endif 1734 #endif 1735 1736 1737 #endif // INCLUDED_eacompiler_H 1738 1739 1740 1741 1742 1743