#ifndef EASTL_INTERNAL_CONFIG_H

#define EASTL_INTERNAL_CONFIG_H

#ifdef EASTL_USER_CONFIG_HEADER

#include EASTL_USER_CONFIG_HEADER

#endif

#ifndef EASTL_EABASE_DISABLED

#include <EABase/eabase.h>

#endif

#include <EABase/eahave.h>

#if defined(EA_PRAGMA_ONCE_SUPPORTED)

#pragma once

#endif

#ifndef EASTL_VERSION

#define EASTL_VERSION "3.18.00"

#define EASTL_VERSION_N 31800

#endif

#if !defined(EA_COMPILER_NO_STANDARD_CPP_LIBRARY)

#if defined(EA_PLATFORM_ANDROID)

// Disabled because EA's eaconfig/android_config/android_sdk packages currently

// don't support linking STL libraries. Perhaps we can figure out what linker arguments

// are needed for an app so we can manually specify them and then re-enable this code.

//

//#include <android/api-level.h>

//

//#if (__ANDROID_API__ < 9) // Earlier versions of Android provide no std C++ STL implementation.

#define EA_COMPILER_NO_STANDARD_CPP_LIBRARY 1

//#endif

#endif

#endif

#if !defined(EA_NOEXCEPT)

#define EA_NOEXCEPT

#define EA_NOEXCEPT_IF(predicate)

#define EA_NOEXCEPT_EXPR(expression) false

#endif

#if !defined(EA_CPP14_CONSTEXPR)

#if defined(EA_COMPILER_CPP14_ENABLED)

#define EA_CPP14_CONSTEXPR constexpr

#else

#define EA_CPP14_CONSTEXPR // not supported

#define EA_NO_CPP14_CONSTEXPR

#endif

#endif

namespace eastl

{

// Intentionally empty.

}

#ifndef EASTL_DEBUG

#if defined(EA_DEBUG) || defined(_DEBUG)

#define EASTL_DEBUG 1

#else

#define EASTL_DEBUG 0

#endif

#endif

#ifndef EASTL_DEV_DEBUG

#define EASTL_DEV_DEBUG 0

#endif

#ifndef EASTL_DEBUGPARAMS_LEVEL

#if EASTL_DEBUG

#define EASTL_DEBUGPARAMS_LEVEL 2

#else

#define EASTL_DEBUGPARAMS_LEVEL 0

#endif

#endif

#ifndef EASTL_DLL

#if defined(EA_DLL)

#define EASTL_DLL 1

#else

#define EASTL_DLL 0

#endif

#endif

#ifndef EASTL_IF_NOT_DLL

#if EASTL_DLL

#define EASTL_IF_NOT_DLL(x)

#else

#define EASTL_IF_NOT_DLL(x) x

#endif

#endif

#if defined(EA_DLL) && !defined(EASTL_DLL)

#define EASTL_DLL 1

#endif

#ifndef EASTL_API // If the build file hasn't already defined this to be dllexport...

#if EASTL_DLL

#if defined(_MSC_VER)

#define EASTL_API __declspec(dllimport)

#define EASTL_LOCAL

#elif defined(__CYGWIN__)

#define EASTL_API __attribute__((dllimport))

#define EASTL_LOCAL

#elif (defined(__GNUC__) && (__GNUC__ >= 4))

#define EASTL_API __attribute__ ((visibility("default")))

#define EASTL_LOCAL __attribute__ ((visibility("hidden")))

#else

#define EASTL_API

#define EASTL_LOCAL

#endif

#else

#define EASTL_API

#define EASTL_LOCAL

#endif

#endif

#ifndef EASTL_EASTDC_API

#if EASTL_DLL

#if defined(_MSC_VER)

#define EASTL_EASTDC_API __declspec(dllimport)

#define EASTL_EASTDC_LOCAL

#elif defined(__CYGWIN__)

#define EASTL_EASTDC_API __attribute__((dllimport))

#define EASTL_EASTDC_LOCAL

#elif (defined(__GNUC__) && (__GNUC__ >= 4))

#define EASTL_EASTDC_API __attribute__ ((visibility("default")))

#define EASTL_EASTDC_LOCAL __attribute__ ((visibility("hidden")))

#else

#define EASTL_EASTDC_API

#define EASTL_EASTDC_LOCAL

#endif

#else

#define EASTL_EASTDC_API

#define EASTL_EASTDC_LOCAL

#endif

#endif

#if !defined(EASTL_EASTDC_VSNPRINTF)

#define EASTL_EASTDC_VSNPRINTF 1

#endif

#ifndef EASTL_NAME_ENABLED

#define EASTL_NAME_ENABLED EASTL_DEBUG

#endif

#ifndef EASTL_NAME

#if EASTL_NAME_ENABLED

#define EASTL_NAME(x) x

#define EASTL_NAME_VAL(x) x

#else

#define EASTL_NAME(x)

#define EASTL_NAME_VAL(x) ((const char*)NULL)

#endif

#endif

#ifndef EASTL_DEFAULT_NAME_PREFIX

#define EASTL_DEFAULT_NAME_PREFIX "EASTL"

#endif

#ifndef EASTL_ASSERT_ENABLED

#define EASTL_ASSERT_ENABLED EASTL_DEBUG

#endif

#ifndef EASTL_DEV_ASSERT_ENABLED

#define EASTL_DEV_ASSERT_ENABLED EASTL_DEV_DEBUG

#endif

#ifndef EASTL_EMPTY_REFERENCE_ASSERT_ENABLED

#define EASTL_EMPTY_REFERENCE_ASSERT_ENABLED EASTL_ASSERT_ENABLED

#endif

#ifndef EASTL_ASSERTION_FAILURE_DEFINED

#define EASTL_ASSERTION_FAILURE_DEFINED

namespace eastl

{

typedef void (*EASTL_AssertionFailureFunction)(const char* pExpression, void* pContext);

EASTL_API void SetAssertionFailureFunction(EASTL_AssertionFailureFunction pFunction, void* pContext);

// These are the internal default functions that implement asserts.

EASTL_API void AssertionFailure(const char* pExpression);

EASTL_API void AssertionFailureFunctionDefault(const char* pExpression, void* pContext);

}

#endif

#ifndef EASTL_ASSERT

#if EASTL_ASSERT_ENABLED

#define EASTL_ASSERT(expression) \

EA_DISABLE_VC_WARNING(4127) \

do { \

EA_ANALYSIS_ASSUME(expression); \

(void)((expression) || (eastl::AssertionFailure(#expression), 0)); \

} while (0) \

EA_RESTORE_VC_WARNING()

#else

#define EASTL_ASSERT(expression)

#endif

#endif

#ifndef EASTL_DEV_ASSERT

#if EASTL_DEV_ASSERT_ENABLED

#define EASTL_DEV_ASSERT(expression) \

EA_DISABLE_VC_WARNING(4127) \

do { \

EA_ANALYSIS_ASSUME(expression); \

(void)((expression) || (eastl::AssertionFailure(#expression), 0)); \

} while(0) \

EA_RESTORE_VC_WARNING()

#else

#define EASTL_DEV_ASSERT(expression)

#endif

#endif

#ifndef EASTL_ASSERT_MSG

#if EASTL_ASSERT_ENABLED

#define EASTL_ASSERT_MSG(expression, message) \

EA_DISABLE_VC_WARNING(4127) \

do { \

EA_ANALYSIS_ASSUME(expression); \

(void)((expression) || (eastl::AssertionFailure(message), 0)); \

} while (0) \

EA_RESTORE_VC_WARNING()

#else

#define EASTL_ASSERT_MSG(expression, message)

#endif

#endif

#ifndef EASTL_FAIL_MSG

#if EASTL_ASSERT_ENABLED

#define EASTL_FAIL_MSG(message) (eastl::AssertionFailure(message))

#else

#define EASTL_FAIL_MSG(message)

#endif

#endif

#define EASTL_CT_ASSERT(expression) static_assert(expression, #expression)

#define EASTL_CT_ASSERT_MSG(expression, message) static_assert(expression, message)

#ifndef EASTL_DEBUG_BREAK_OVERRIDE

#ifndef EASTL_DEBUG_BREAK

#if defined(_MSC_VER) && (_MSC_VER >= 1300)

#define EASTL_DEBUG_BREAK() __debugbreak() // This is a compiler intrinsic which will map to appropriate inlined asm for the platform.

#elif (defined(EA_PROCESSOR_ARM) && !defined(EA_PROCESSOR_ARM64)) && defined(__APPLE__)

#define EASTL_DEBUG_BREAK() asm("trap")

#elif defined(EA_PROCESSOR_ARM64) && defined(__APPLE__)

#include <signal.h>

#include <unistd.h>

#define EASTL_DEBUG_BREAK() kill( getpid(), SIGINT )

#elif defined(EA_PROCESSOR_ARM64) && defined(__GNUC__)

#define EASTL_DEBUG_BREAK() asm("brk 10")

#elif defined(EA_PROCESSOR_ARM) && defined(__GNUC__)

#define EASTL_DEBUG_BREAK() asm("BKPT 10") // The 10 is arbitrary. It's just a unique id.

#elif defined(EA_PROCESSOR_ARM) && defined(__ARMCC_VERSION)

#define EASTL_DEBUG_BREAK() __breakpoint(10)

#elif defined(EA_PROCESSOR_POWERPC) // Generic PowerPC.

#define EASTL_DEBUG_BREAK() asm(".long 0") // This triggers an exception by executing opcode 0x00000000.

#elif (defined(EA_PROCESSOR_X86) || defined(EA_PROCESSOR_X86_64)) && defined(EA_ASM_STYLE_INTEL)

#define EASTL_DEBUG_BREAK() { __asm int 3 }

#elif (defined(EA_PROCESSOR_X86) || defined(EA_PROCESSOR_X86_64)) && (defined(EA_ASM_STYLE_ATT) || defined(__GNUC__))

#define EASTL_DEBUG_BREAK() asm("int3")

#else

void EASTL_DEBUG_BREAK(); // User must define this externally.

#endif

#else

void EASTL_DEBUG_BREAK(); // User must define this externally.

#endif

#else

#ifndef EASTL_DEBUG_BREAK

#if EASTL_DEBUG_BREAK_OVERRIDE == 1

// define an empty callable to satisfy the call site.

#define EASTL_DEBUG_BREAK ([]{})

#else

#define EASTL_DEBUG_BREAK EASTL_DEBUG_BREAK_OVERRIDE

#endif

#else

#error EASTL_DEBUG_BREAK is already defined yet you would like to override it. Please ensure no other headers are already defining EASTL_DEBUG_BREAK before this header (config.h) is included

#endif

#endif

#ifndef EASTL_ALLOCATOR_COPY_ENABLED

#define EASTL_ALLOCATOR_COPY_ENABLED 0

#endif

#ifndef EASTL_FIXED_SIZE_TRACKING_ENABLED

#define EASTL_FIXED_SIZE_TRACKING_ENABLED EASTL_DEBUG

#endif

#ifndef EASTL_RTTI_ENABLED

// The VC++ default Standard Library (Dinkumware) disables major parts of RTTI

// (e.g. type_info) if exceptions are disabled, even if RTTI itself is enabled.

// _HAS_EXCEPTIONS is defined by Dinkumware to 0 or 1 (disabled or enabled).

#if defined(EA_COMPILER_NO_RTTI) || (defined(_MSC_VER) && defined(EA_HAVE_DINKUMWARE_CPP_LIBRARY) && !(defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS))

#define EASTL_RTTI_ENABLED 0

#else

#define EASTL_RTTI_ENABLED 1

#endif

#endif

#if !defined(EASTL_EXCEPTIONS_ENABLED) || ((EASTL_EXCEPTIONS_ENABLED == 1) && defined(EA_COMPILER_NO_EXCEPTIONS))

#define EASTL_EXCEPTIONS_ENABLED 0

#endif

#ifndef EASTL_STRING_OPT_EXPLICIT_CTORS

// Defined as 0 or 1. Default is 0.

// Defines if we should implement explicity in constructors where the C++

// standard string does not. The advantage of enabling explicit constructors

// is that you can do this: string s = "hello"; in addition to string s("hello");

// The disadvantage of enabling explicity constructors is that there can be

// silent conversions done which impede performance if the user isn't paying

// attention.

// C++ standard string ctors are not explicit.

#define EASTL_STRING_OPT_EXPLICIT_CTORS 0

#endif

#ifndef EASTL_STRING_OPT_LENGTH_ERRORS

// Defined as 0 or 1. Default is equal to EASTL_EXCEPTIONS_ENABLED.

// Defines if we check for string values going beyond kMaxSize

// (a very large value) and throw exections if so.

// C++ standard strings are expected to do such checks.

#define EASTL_STRING_OPT_LENGTH_ERRORS EASTL_EXCEPTIONS_ENABLED

#endif

#ifndef EASTL_STRING_OPT_RANGE_ERRORS

// Defined as 0 or 1. Default is equal to EASTL_EXCEPTIONS_ENABLED.

// Defines if we check for out-of-bounds references to string

// positions and throw exceptions if so. Well-behaved code shouldn't

// refence out-of-bounds positions and so shouldn't need these checks.

// C++ standard strings are expected to do such range checks.

#define EASTL_STRING_OPT_RANGE_ERRORS EASTL_EXCEPTIONS_ENABLED

#endif

#ifndef EASTL_STRING_OPT_ARGUMENT_ERRORS

// Defined as 0 or 1. Default is 0.

// Defines if we check for NULL ptr arguments passed to string

// functions by the user and throw exceptions if so. Well-behaved code

// shouldn't pass bad arguments and so shouldn't need these checks.

// Also, some users believe that strings should check for NULL pointers

// in all their arguments and do no-ops if so. This is very debatable.

// C++ standard strings are not required to check for such argument errors.

#define EASTL_STRING_OPT_ARGUMENT_ERRORS 0

#endif

#ifndef EASTL_BITSET_SIZE_T

#define EASTL_BITSET_SIZE_T 1

#endif

#ifndef EASTL_INT128_SUPPORTED

#if defined(__SIZEOF_INT128__) || (defined(EA_COMPILER_INTMAX_SIZE) && (EA_COMPILER_INTMAX_SIZE >= 16))

#define EASTL_INT128_SUPPORTED 1

#else

#define EASTL_INT128_SUPPORTED 0

#endif

#endif

#ifndef EASTL_DEFAULT_ALLOCATOR_ALIGNED_ALLOCATIONS_SUPPORTED

#if EASTL_DLL

#define EASTL_DEFAULT_ALLOCATOR_ALIGNED_ALLOCATIONS_SUPPORTED 0

#else

#define EASTL_DEFAULT_ALLOCATOR_ALIGNED_ALLOCATIONS_SUPPORTED 1

#endif

#endif

#ifndef EASTL_INT128_DEFINED

#if EASTL_INT128_SUPPORTED

#define EASTL_INT128_DEFINED 1

#if defined(__SIZEOF_INT128__) || defined(EA_COMPILER_GNUC) || defined(__clang__)

typedef __int128_t eastl_int128_t;

typedef __uint128_t eastl_uint128_t;

#else

typedef int128_t eastl_int128_t; // The EAStdC package defines an EA::StdC::int128_t and uint128_t type,

typedef uint128_t eastl_uint128_t; // though they are currently within the EA::StdC namespace.

#endif

#endif

#endif

#if !defined(EASTL_BITSET_WORD_TYPE_DEFAULT)

#if defined(EASTL_BITSET_WORD_SIZE) // EASTL_BITSET_WORD_SIZE is deprecated, but we temporarily support the ability for the user to specify it. Use EASTL_BITSET_WORD_TYPE_DEFAULT instead.

#if (EASTL_BITSET_WORD_SIZE == 4)

#define EASTL_BITSET_WORD_TYPE_DEFAULT uint32_t

#define EASTL_BITSET_WORD_SIZE_DEFAULT 4

#else

#define EASTL_BITSET_WORD_TYPE_DEFAULT uint64_t

#define EASTL_BITSET_WORD_SIZE_DEFAULT 8

#endif

#elif (EA_PLATFORM_WORD_SIZE == 16) // EA_PLATFORM_WORD_SIZE is defined in EABase.

#define EASTL_BITSET_WORD_TYPE_DEFAULT uint128_t

#define EASTL_BITSET_WORD_SIZE_DEFAULT 16

#elif (EA_PLATFORM_WORD_SIZE == 8)

#define EASTL_BITSET_WORD_TYPE_DEFAULT uint64_t

#define EASTL_BITSET_WORD_SIZE_DEFAULT 8

#elif (EA_PLATFORM_WORD_SIZE == 4)

#define EASTL_BITSET_WORD_TYPE_DEFAULT uint32_t

#define EASTL_BITSET_WORD_SIZE_DEFAULT 4

#else

#define EASTL_BITSET_WORD_TYPE_DEFAULT uint16_t

#define EASTL_BITSET_WORD_SIZE_DEFAULT 2

#endif

#endif

#ifndef EASTL_LIST_SIZE_CACHE

#define EASTL_LIST_SIZE_CACHE 1

#endif

#ifndef EASTL_SLIST_SIZE_CACHE

#define EASTL_SLIST_SIZE_CACHE 1

#endif

#ifndef EASTL_MAX_STACK_USAGE

#define EASTL_MAX_STACK_USAGE 4000

#endif

#ifndef EASTL_VA_COPY_ENABLED

#if ((defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__clang__)) && (!defined(__i386__) || defined(__x86_64__)) && !defined(__ppc__) && !defined(__PPC__) && !defined(__PPC64__)