diff --git a/.vscode/launch.json b/.vscode/launch.json index be6a328..de4ffda 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -8,10 +8,10 @@ "name": "Launch SA", "type": "cppvsdbg", "request": "launch", - "program": "F:/GTASanAndreas/gta_sa.exe", + "program": "E:/GTASanAndreas/gta_sa.exe", "args": [], "stopAtEntry": false, - "cwd": "F:/GTASanAndreas/", + "cwd": "E:/GTASanAndreas/", "environment": [], "console": "internalConsole" }, diff --git a/depend/toml.hpp b/depend/toml.hpp new file mode 100644 index 0000000..d75b0e9 --- /dev/null +++ b/depend/toml.hpp @@ -0,0 +1,15704 @@ +//---------------------------------------------------------------------------------------------------------------------- +// +// toml++ v3.1.0 +// https://github.com/marzer/tomlplusplus +// SPDX-License-Identifier: MIT +// +//---------------------------------------------------------------------------------------------------------------------- +// +// - THIS FILE WAS ASSEMBLED FROM MULTIPLE HEADER FILES BY A SCRIPT - PLEASE DON'T EDIT IT DIRECTLY - +// +// If you wish to submit a contribution to toml++, hooray and thanks! Before you crack on, please be aware that this +// file was assembled from a number of smaller files by a python script, and code contributions should not be made +// against it directly. You should instead make your changes in the relevant source file(s). The file names of the files +// that contributed to this header can be found at the beginnings and ends of the corresponding sections of this file. +// +//---------------------------------------------------------------------------------------------------------------------- +// +// TOML Language Specifications: +// latest: https://github.com/toml-lang/toml/blob/master/README.md +// v1.0.0: https://toml.io/en/v1.0.0 +// v0.5.0: https://toml.io/en/v0.5.0 +// changelog: https://github.com/toml-lang/toml/blob/master/CHANGELOG.md +// +//---------------------------------------------------------------------------------------------------------------------- +// +// MIT License +// +// Copyright (c) Mark Gillard +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated +// documentation files (the "Software"), to deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the +// Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +//---------------------------------------------------------------------------------------------------------------------- +#ifndef TOMLPLUSPLUS_H +#define TOMLPLUSPLUS_H + +#define INCLUDE_TOMLPLUSPLUS_H // old guard name used pre-v3 + +//******** impl/preprocessor.h *************************************************************************************** + +// clang-format off + +#ifndef __cplusplus + #error toml++ is a C++ library. +#endif + +#ifdef __INTELLISENSE__ + #define TOML_INTELLISENSE 1 +#else + #define TOML_INTELLISENSE 0 +#endif +#ifdef __clang__ + #define TOML_CLANG __clang_major__ +#else + #define TOML_CLANG 0 +#endif +#ifdef __INTEL_COMPILER + #define TOML_ICC __INTEL_COMPILER + #ifdef __ICL + #define TOML_ICC_CL TOML_ICC + #else + #define TOML_ICC_CL 0 + #endif +#else + #define TOML_ICC 0 + #define TOML_ICC_CL 0 +#endif +#if defined(_MSC_VER) && !TOML_CLANG && !TOML_ICC + #define TOML_MSVC _MSC_VER +#else + #define TOML_MSVC 0 +#endif +#if defined(__GNUC__) && !TOML_CLANG && !TOML_ICC + #define TOML_GCC __GNUC__ +#else + #define TOML_GCC 0 +#endif + +#ifdef __has_include + #define TOML_HAS_INCLUDE(header) __has_include(header) +#else + #define TOML_HAS_INCLUDE(header) 0 +#endif + +#if TOML_CLANG + + #define TOML_PUSH_WARNINGS \ + _Pragma("clang diagnostic push") \ + static_assert(true) + + #define TOML_DISABLE_SWITCH_WARNINGS \ + _Pragma("clang diagnostic ignored \"-Wswitch\"") \ + static_assert(true) + + #define TOML_DISABLE_ARITHMETIC_WARNINGS \ + _Pragma("clang diagnostic ignored \"-Wfloat-equal\"") \ + _Pragma("clang diagnostic ignored \"-Wdouble-promotion\"") \ + _Pragma("clang diagnostic ignored \"-Wshift-sign-overflow\"") \ + static_assert(true) + + #if TOML_CLANG >= 10 + #define TOML_DISABLE_SPAM_WARNINGS_CLANG_10 \ + _Pragma("clang diagnostic ignored \"-Wzero-as-null-pointer-constant\"") \ + static_assert(true) + #else + #define TOML_DISABLE_SPAM_WARNINGS_CLANG_10 static_assert(true) + #endif + + #if TOML_CLANG >= 11 + #define TOML_DISABLE_SPAM_WARNINGS_CLANG_11 \ + _Pragma("clang diagnostic ignored \"-Wsuggest-destructor-override\"") \ + static_assert(true) + #else + #define TOML_DISABLE_SPAM_WARNINGS_CLANG_11 static_assert(true) + #endif + + #define TOML_DISABLE_SPAM_WARNINGS \ + TOML_DISABLE_SPAM_WARNINGS_CLANG_10; \ + TOML_DISABLE_SPAM_WARNINGS_CLANG_11; \ + _Pragma("clang diagnostic ignored \"-Wweak-vtables\"") \ + _Pragma("clang diagnostic ignored \"-Wweak-template-vtables\"") \ + _Pragma("clang diagnostic ignored \"-Wdouble-promotion\"") \ + _Pragma("clang diagnostic ignored \"-Wchar-subscripts\"") \ + _Pragma("clang diagnostic ignored \"-Wmissing-field-initializers\"") \ + _Pragma("clang diagnostic ignored \"-Wpadded\"") \ + static_assert(true) + + #define TOML_POP_WARNINGS \ + _Pragma("clang diagnostic pop") \ + static_assert(true) + + #define TOML_DISABLE_WARNINGS \ + TOML_PUSH_WARNINGS; \ + _Pragma("clang diagnostic ignored \"-Weverything\"") \ + static_assert(true) + + #define TOML_ENABLE_WARNINGS TOML_POP_WARNINGS + + #define TOML_ASSUME(expr) __builtin_assume(expr) + #define TOML_UNREACHABLE __builtin_unreachable() + #define TOML_ATTR(...) __attribute__((__VA_ARGS__)) + #if defined(_MSC_VER) // msvc compat mode + #ifdef __has_declspec_attribute + #if __has_declspec_attribute(novtable) + #define TOML_ABSTRACT_BASE __declspec(novtable) + #endif + #if __has_declspec_attribute(empty_bases) + #define TOML_EMPTY_BASES __declspec(empty_bases) + #endif + #ifndef TOML_ALWAYS_INLINE + #define TOML_ALWAYS_INLINE __forceinline + #endif + #if __has_declspec_attribute(noinline) + #define TOML_NEVER_INLINE __declspec(noinline) + #endif + #endif + #endif + #ifdef __has_attribute + #if !defined(TOML_ALWAYS_INLINE) && __has_attribute(always_inline) + #define TOML_ALWAYS_INLINE __attribute__((__always_inline__)) inline + #endif + #if !defined(TOML_NEVER_INLINE) && __has_attribute(noinline) + #define TOML_NEVER_INLINE __attribute__((__noinline__)) + #endif + #if !defined(TOML_TRIVIAL_ABI) && __has_attribute(trivial_abi) + #define TOML_TRIVIAL_ABI __attribute__((__trivial_abi__)) + #endif + #if !defined(TOML_FLAGS_ENUM) && __has_attribute(flag_enum) + #define TOML_FLAGS_ENUM __attribute__((__flag_enum__)) + #endif + #if __has_attribute(enum_extensibility) + #ifndef TOML_OPEN_ENUM + #define TOML_OPEN_ENUM __attribute__((enum_extensibility(open))) + #endif + #ifndef TOML_CLOSED_ENUM + #define TOML_CLOSED_ENUM __attribute__((enum_extensibility(closed))) + #endif + #endif + #endif + #define TOML_LIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 1) ) + #define TOML_UNLIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 0) ) + + #define TOML_SIMPLE_STATIC_ASSERT_MESSAGES 1 + +#endif // clang + +#if TOML_MSVC || TOML_ICC_CL + + #define TOML_CPP_VERSION _MSVC_LANG + #if TOML_MSVC // !intel-cl + + #define TOML_PUSH_WARNINGS \ + __pragma(warning(push)) \ + static_assert(true) + + #if TOML_HAS_INCLUDE() + #pragma warning(push, 0) + #include + #pragma warning(pop) + #define TOML_DISABLE_CODE_ANALYSIS_WARNINGS \ + __pragma(warning(disable: ALL_CODE_ANALYSIS_WARNINGS)) \ + static_assert(true) + #else + #define TOML_DISABLE_CODE_ANALYSIS_WARNINGS + static_assert(true) + #endif + + #define TOML_DISABLE_SWITCH_WARNINGS \ + __pragma(warning(disable: 4061)) /* enumerator 'identifier' is not explicitly handled by a case label */ \ + __pragma(warning(disable: 4062)) /* enumerator 'identifier' is not handled */ \ + __pragma(warning(disable: 4063)) \ + __pragma(warning(disable: 26819)) \ + static_assert(true) + + #define TOML_DISABLE_SPAM_WARNINGS \ + __pragma(warning(disable: 4127)) /* conditional expr is constant */ \ + __pragma(warning(disable: 4324)) /* structure was padded due to alignment specifier */ \ + __pragma(warning(disable: 4348)) \ + __pragma(warning(disable: 4464)) /* relative include path contains '..' */ \ + __pragma(warning(disable: 4505)) /* unreferenced local function removed */ \ + __pragma(warning(disable: 4514)) /* unreferenced inline function has been removed */ \ + __pragma(warning(disable: 4582)) /* constructor is not implicitly called */ \ + __pragma(warning(disable: 4623)) /* default constructor was implicitly defined as deleted */ \ + __pragma(warning(disable: 4625)) /* copy constructor was implicitly defined as deleted */ \ + __pragma(warning(disable: 4626)) /* assignment operator was implicitly defined as deleted */ \ + __pragma(warning(disable: 4710)) /* function not inlined */ \ + __pragma(warning(disable: 4711)) /* function selected for automatic expansion */ \ + __pragma(warning(disable: 4820)) /* N bytes padding added */ \ + __pragma(warning(disable: 4946)) /* reinterpret_cast used between related classes */ \ + __pragma(warning(disable: 5026)) /* move constructor was implicitly defined as deleted */ \ + __pragma(warning(disable: 5027)) /* move assignment operator was implicitly defined as deleted */ \ + __pragma(warning(disable: 5039)) /* potentially throwing function passed to 'extern "C"' function */ \ + __pragma(warning(disable: 5045)) /* Compiler will insert Spectre mitigation */ \ + __pragma(warning(disable: 26451)) \ + __pragma(warning(disable: 26490)) \ + __pragma(warning(disable: 26495)) \ + __pragma(warning(disable: 26812)) \ + __pragma(warning(disable: 26819)) \ + static_assert(true) + + #define TOML_DISABLE_ARITHMETIC_WARNINGS \ + __pragma(warning(disable: 4365)) /* argument signed/unsigned mismatch */ \ + __pragma(warning(disable: 4738)) /* storing 32-bit float result in memory */ \ + __pragma(warning(disable: 5219)) /* implicit conversion from integral to float */ \ + static_assert(true) + + #define TOML_POP_WARNINGS \ + __pragma(warning(pop)) \ + static_assert(true) + + #define TOML_DISABLE_WARNINGS \ + __pragma(warning(push, 0)) \ + __pragma(warning(disable: 4348)) \ + __pragma(warning(disable: 4668)) \ + __pragma(warning(disable: 5105)) \ + TOML_DISABLE_CODE_ANALYSIS_WARNINGS;\ + TOML_DISABLE_SWITCH_WARNINGS; \ + TOML_DISABLE_SPAM_WARNINGS; \ + TOML_DISABLE_ARITHMETIC_WARNINGS; \ + static_assert(true) + + #define TOML_ENABLE_WARNINGS TOML_POP_WARNINGS + + #endif + #ifndef TOML_ALWAYS_INLINE + #define TOML_ALWAYS_INLINE __forceinline + #endif + #define TOML_NEVER_INLINE __declspec(noinline) + #define TOML_ASSUME(expr) __assume(expr) + #define TOML_UNREACHABLE __assume(0) + #define TOML_ABSTRACT_BASE __declspec(novtable) + #define TOML_EMPTY_BASES __declspec(empty_bases) + #ifdef _CPPUNWIND + #define TOML_COMPILER_EXCEPTIONS 1 + #else + #define TOML_COMPILER_EXCEPTIONS 0 + #endif + +#endif // msvc + +#if TOML_ICC + + #define TOML_PUSH_WARNINGS \ + __pragma(warning(push)) \ + static_assert(true) + + #define TOML_DISABLE_SPAM_WARNINGS \ + __pragma(warning(disable: 82)) /* storage class is not first */ \ + __pragma(warning(disable: 111)) /* statement unreachable (false-positive) */ \ + __pragma(warning(disable: 869)) /* unreferenced parameter */ \ + __pragma(warning(disable: 1011)) /* missing return (false-positive) */ \ + __pragma(warning(disable: 2261)) /* assume expr side-effects discarded */ \ + static_assert(true) + + #define TOML_POP_WARNINGS \ + __pragma(warning(pop)) \ + static_assert(true) + + #define TOML_DISABLE_WARNINGS \ + __pragma(warning(push, 0)) \ + static_assert(true) + + #define TOML_ENABLE_WARNINGS \ + TOML_POP_WARNINGS + +#endif // icc + +#if TOML_GCC + + #define TOML_PUSH_WARNINGS \ + _Pragma("GCC diagnostic push") \ + static_assert(true) + + #define TOML_DISABLE_SWITCH_WARNINGS \ + _Pragma("GCC diagnostic ignored \"-Wswitch\"") \ + _Pragma("GCC diagnostic ignored \"-Wswitch-enum\"") \ + _Pragma("GCC diagnostic ignored \"-Wswitch-default\"") \ + static_assert(true) + + #define TOML_DISABLE_ARITHMETIC_WARNINGS \ + _Pragma("GCC diagnostic ignored \"-Wfloat-equal\"") \ + _Pragma("GCC diagnostic ignored \"-Wsign-conversion\"") \ + static_assert(true) + + #define TOML_DISABLE_SUGGEST_ATTR_WARNINGS \ + _Pragma("GCC diagnostic ignored \"-Wsuggest-attribute=const\"") \ + _Pragma("GCC diagnostic ignored \"-Wsuggest-attribute=pure\"") \ + static_assert(true) + + #define TOML_DISABLE_SPAM_WARNINGS \ + _Pragma("GCC diagnostic ignored \"-Wpadded\"") \ + _Pragma("GCC diagnostic ignored \"-Wcast-align\"") \ + _Pragma("GCC diagnostic ignored \"-Wcomment\"") \ + _Pragma("GCC diagnostic ignored \"-Wtype-limits\"") \ + _Pragma("GCC diagnostic ignored \"-Wuseless-cast\"") \ + _Pragma("GCC diagnostic ignored \"-Wchar-subscripts\"") \ + _Pragma("GCC diagnostic ignored \"-Wsubobject-linkage\"") \ + _Pragma("GCC diagnostic ignored \"-Wmissing-field-initializers\"") \ + _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") \ + _Pragma("GCC diagnostic ignored \"-Wnoexcept\"") \ + static_assert(true) + + #define TOML_POP_WARNINGS \ + _Pragma("GCC diagnostic pop") \ + static_assert(true) + + #define TOML_DISABLE_WARNINGS \ + TOML_PUSH_WARNINGS; \ + _Pragma("GCC diagnostic ignored \"-Wall\"") \ + _Pragma("GCC diagnostic ignored \"-Wextra\"") \ + _Pragma("GCC diagnostic ignored \"-Wpedantic\"") \ + TOML_DISABLE_SWITCH_WARNINGS; \ + TOML_DISABLE_ARITHMETIC_WARNINGS; \ + TOML_DISABLE_SPAM_WARNINGS; \ + TOML_DISABLE_SUGGEST_ATTR_WARNINGS; \ + static_assert(true) + + #define TOML_ENABLE_WARNINGS \ + TOML_POP_WARNINGS + + #define TOML_ATTR(...) __attribute__((__VA_ARGS__)) + #ifndef TOML_ALWAYS_INLINE + #define TOML_ALWAYS_INLINE __attribute__((__always_inline__)) inline + #endif + #define TOML_NEVER_INLINE __attribute__((__noinline__)) + #define TOML_UNREACHABLE __builtin_unreachable() + #define TOML_LIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 1) ) + #define TOML_UNLIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 0) ) + +#endif + +#ifndef TOML_CPP_VERSION + #define TOML_CPP_VERSION __cplusplus +#endif +#if TOML_CPP_VERSION < 201103L + #error toml++ requires C++17 or higher. For a TOML library supporting pre-C++11 see https://github.com/ToruNiina/Boost.toml +#elif TOML_CPP_VERSION < 201703L + #error toml++ requires C++17 or higher. For a TOML library supporting C++11 see https://github.com/ToruNiina/toml11 +#endif + +#ifdef TOML_CONFIG_HEADER + #include TOML_CONFIG_HEADER +#endif + +// is the library being built as a shared lib/dll using meson and friends? +#ifndef TOML_SHARED_LIB + #define TOML_SHARED_LIB 0 +#endif + +// header-only mode +#if !defined(TOML_HEADER_ONLY) && defined(TOML_ALL_INLINE) // was TOML_ALL_INLINE pre-2.0 + #define TOML_HEADER_ONLY TOML_ALL_INLINE +#endif +#if !defined(TOML_HEADER_ONLY) || (defined(TOML_HEADER_ONLY) && TOML_HEADER_ONLY) || TOML_INTELLISENSE + #undef TOML_HEADER_ONLY + #define TOML_HEADER_ONLY 1 +#endif +#if defined(DOXYGEN) || TOML_SHARED_LIB + #undef TOML_HEADER_ONLY + #define TOML_HEADER_ONLY 0 +#endif + +// internal implementation switch +#if defined(TOML_IMPLEMENTATION) || TOML_HEADER_ONLY + #undef TOML_IMPLEMENTATION + #define TOML_IMPLEMENTATION 1 +#else + #define TOML_IMPLEMENTATION 0 +#endif + +// dll/shared lib function exports (legacy - TOML_API was the old name for this setting) +#if !defined(TOML_EXPORTED_MEMBER_FUNCTION) \ + && !defined(TOML_EXPORTED_STATIC_FUNCTION) \ + && !defined(TOML_EXPORTED_FREE_FUNCTION) \ + && !defined(TOML_EXPORTED_CLASS) \ + && defined(TOML_API) + #define TOML_EXPORTED_MEMBER_FUNCTION TOML_API + #define TOML_EXPORTED_STATIC_FUNCTION TOML_API + #define TOML_EXPORTED_FREE_FUNCTION TOML_API +#endif + +// dll/shared lib exports +#if TOML_SHARED_LIB + #undef TOML_API + #undef TOML_EXPORTED_CLASS + #undef TOML_EXPORTED_MEMBER_FUNCTION + #undef TOML_EXPORTED_STATIC_FUNCTION + #undef TOML_EXPORTED_FREE_FUNCTION + #if defined(_WIN32) || defined(__CYGWIN__) + #if TOML_IMPLEMENTATION + #define TOML_EXPORTED_CLASS __declspec(dllexport) + #define TOML_EXPORTED_FREE_FUNCTION __declspec(dllexport) + #else + #define TOML_EXPORTED_CLASS __declspec(dllimport) + #define TOML_EXPORTED_FREE_FUNCTION __declspec(dllimport) + #endif + #elif defined(__GNUC__) && __GNUC__ >= 4 + #define TOML_EXPORTED_CLASS __attribute__((visibility("default"))) + #define TOML_EXPORTED_MEMBER_FUNCTION __attribute__((visibility("default"))) + #define TOML_EXPORTED_STATIC_FUNCTION __attribute__((visibility("default"))) + #define TOML_EXPORTED_FREE_FUNCTION __attribute__((visibility("default"))) + #endif +#endif +#ifndef TOML_EXPORTED_CLASS + #define TOML_EXPORTED_CLASS +#endif +#ifndef TOML_EXPORTED_MEMBER_FUNCTION + #define TOML_EXPORTED_MEMBER_FUNCTION +#endif +#ifndef TOML_EXPORTED_STATIC_FUNCTION + #define TOML_EXPORTED_STATIC_FUNCTION +#endif +#ifndef TOML_EXPORTED_FREE_FUNCTION + #define TOML_EXPORTED_FREE_FUNCTION +#endif + +// experimental language features +#if !defined(TOML_ENABLE_UNRELEASED_FEATURES) && defined(TOML_UNRELEASED_FEATURES) // was TOML_UNRELEASED_FEATURES pre-3.0 + #define TOML_ENABLE_UNRELEASED_FEATURES TOML_UNRELEASED_FEATURES +#endif +#if (defined(TOML_ENABLE_UNRELEASED_FEATURES) && TOML_ENABLE_UNRELEASED_FEATURES) || TOML_INTELLISENSE + #undef TOML_ENABLE_UNRELEASED_FEATURES + #define TOML_ENABLE_UNRELEASED_FEATURES 1 +#endif +#ifndef TOML_ENABLE_UNRELEASED_FEATURES + #define TOML_ENABLE_UNRELEASED_FEATURES 0 +#endif + +// parser +#if !defined(TOML_ENABLE_PARSER) && defined(TOML_PARSER) // was TOML_PARSER pre-3.0 + #define TOML_ENABLE_PARSER TOML_PARSER +#endif +#if !defined(TOML_ENABLE_PARSER) || (defined(TOML_ENABLE_PARSER) && TOML_ENABLE_PARSER) || TOML_INTELLISENSE + #undef TOML_ENABLE_PARSER + #define TOML_ENABLE_PARSER 1 +#endif + +// formatters +#if !defined(TOML_ENABLE_FORMATTERS) \ + || (defined(TOML_ENABLE_FORMATTERS) && TOML_ENABLE_FORMATTERS) \ + || TOML_INTELLISENSE + #undef TOML_ENABLE_FORMATTERS + #define TOML_ENABLE_FORMATTERS 1 +#endif + +// SIMD +#if !defined(TOML_ENABLE_SIMD) \ + || (defined(TOML_ENABLE_SIMD) && TOML_ENABLE_SIMD) \ + || TOML_INTELLISENSE + #undef TOML_ENABLE_SIMD + #define TOML_ENABLE_SIMD 1 +#endif + +// windows compat +#if !defined(TOML_ENABLE_WINDOWS_COMPAT) && defined(TOML_WINDOWS_COMPAT) // was TOML_WINDOWS_COMPAT pre-3.0 + #define TOML_ENABLE_WINDOWS_COMPAT TOML_WINDOWS_COMPAT +#endif +#if !defined(TOML_ENABLE_WINDOWS_COMPAT) \ + || (defined(TOML_ENABLE_WINDOWS_COMPAT) && TOML_ENABLE_WINDOWS_COMPAT) \ + || TOML_INTELLISENSE + #undef TOML_ENABLE_WINDOWS_COMPAT + #define TOML_ENABLE_WINDOWS_COMPAT 1 +#endif + +#ifndef _WIN32 + #undef TOML_ENABLE_WINDOWS_COMPAT + #define TOML_ENABLE_WINDOWS_COMPAT 0 +#endif + +#ifndef TOML_INCLUDE_WINDOWS_H + #define TOML_INCLUDE_WINDOWS_H 0 +#endif + +// custom optional +#ifdef TOML_OPTIONAL_TYPE + #define TOML_HAS_CUSTOM_OPTIONAL_TYPE 1 +#else + #define TOML_HAS_CUSTOM_OPTIONAL_TYPE 0 +#endif + +// exceptions (compiler support) +#ifndef TOML_COMPILER_EXCEPTIONS + #if defined(__EXCEPTIONS) || defined(__cpp_exceptions) + #define TOML_COMPILER_EXCEPTIONS 1 + #else + #define TOML_COMPILER_EXCEPTIONS 0 + #endif +#endif + +// exceptions (library use) +#if TOML_COMPILER_EXCEPTIONS + #if !defined(TOML_EXCEPTIONS) || (defined(TOML_EXCEPTIONS) && TOML_EXCEPTIONS) + #undef TOML_EXCEPTIONS + #define TOML_EXCEPTIONS 1 + #endif +#else + #if defined(TOML_EXCEPTIONS) && TOML_EXCEPTIONS + #error TOML_EXCEPTIONS was explicitly enabled but exceptions are disabled/unsupported by the compiler. + #endif + #undef TOML_EXCEPTIONS + #define TOML_EXCEPTIONS 0 +#endif + +#ifndef TOML_UNDEF_MACROS + #define TOML_UNDEF_MACROS 1 +#endif + +#ifndef TOML_MAX_NESTED_VALUES + #define TOML_MAX_NESTED_VALUES 256 + // this refers to the depth of nested values, e.g. inline tables and arrays. + // 256 is crazy high! if you're hitting this limit with real input, TOML is probably the wrong tool for the job... +#endif + +#ifdef TOML_CHAR_8_STRINGS + #if TOML_CHAR_8_STRINGS + #error TOML_CHAR_8_STRINGS was removed in toml++ 2.0.0; all value setters and getters now work with char8_t strings implicitly. + #endif +#endif + +#ifdef TOML_LARGE_FILES + #if !TOML_LARGE_FILES + #error Support for !TOML_LARGE_FILES (i.e. 'small files') was removed in toml++ 3.0.0. + #endif +#endif + +#if !defined(TOML_FLOAT_CHARCONV) && (TOML_GCC || TOML_CLANG || (TOML_ICC && !TOML_ICC_CL)) + // not supported by any version of GCC or Clang as of 26/11/2020 + // not supported by any version of ICC on Linux as of 11/01/2021 + #define TOML_FLOAT_CHARCONV 0 +#endif +#if !defined(TOML_INT_CHARCONV) && (defined(__EMSCRIPTEN__) || defined(__APPLE__)) + // causes link errors on emscripten + // causes Mac OS SDK version errors on some versions of Apple Clang + #define TOML_INT_CHARCONV 0 +#endif +#ifndef TOML_INT_CHARCONV + #define TOML_INT_CHARCONV 1 +#endif +#ifndef TOML_FLOAT_CHARCONV + #define TOML_FLOAT_CHARCONV 1 +#endif +#if (TOML_INT_CHARCONV || TOML_FLOAT_CHARCONV) && !TOML_HAS_INCLUDE() + #undef TOML_INT_CHARCONV + #undef TOML_FLOAT_CHARCONV + #define TOML_INT_CHARCONV 0 + #define TOML_FLOAT_CHARCONV 0 +#endif + +#ifndef TOML_PUSH_WARNINGS + #define TOML_PUSH_WARNINGS static_assert(true) +#endif +#ifndef TOML_DISABLE_CODE_ANALYSIS_WARNINGS + #define TOML_DISABLE_CODE_ANALYSIS_WARNINGS static_assert(true) +#endif +#ifndef TOML_DISABLE_SWITCH_WARNINGS + #define TOML_DISABLE_SWITCH_WARNINGS static_assert(true) +#endif +#ifndef TOML_DISABLE_SUGGEST_ATTR_WARNINGS + #define TOML_DISABLE_SUGGEST_ATTR_WARNINGS static_assert(true) +#endif +#ifndef TOML_DISABLE_SPAM_WARNINGS + #define TOML_DISABLE_SPAM_WARNINGS static_assert(true) +#endif +#ifndef TOML_DISABLE_ARITHMETIC_WARNINGS + #define TOML_DISABLE_ARITHMETIC_WARNINGS static_assert(true) +#endif +#ifndef TOML_POP_WARNINGS + #define TOML_POP_WARNINGS static_assert(true) +#endif +#ifndef TOML_DISABLE_WARNINGS + #define TOML_DISABLE_WARNINGS static_assert(true) +#endif +#ifndef TOML_ENABLE_WARNINGS + #define TOML_ENABLE_WARNINGS static_assert(true) +#endif + +#ifndef TOML_ATTR + #define TOML_ATTR(...) +#endif + +#ifndef TOML_ABSTRACT_BASE + #define TOML_ABSTRACT_BASE +#endif + +#ifndef TOML_EMPTY_BASES + #define TOML_EMPTY_BASES +#endif + +#ifndef TOML_ALWAYS_INLINE + #define TOML_ALWAYS_INLINE inline +#endif +#ifndef TOML_NEVER_INLINE + #define TOML_NEVER_INLINE +#endif + +#ifndef TOML_ASSUME + #define TOML_ASSUME(expr) static_assert(true) +#endif + +#ifndef TOML_UNREACHABLE + #define TOML_UNREACHABLE TOML_ASSUME(false) +#endif + +#ifndef TOML_FLAGS_ENUM + #define TOML_FLAGS_ENUM +#endif + +#ifndef TOML_OPEN_ENUM + #define TOML_OPEN_ENUM +#endif + +#ifndef TOML_CLOSED_ENUM + #define TOML_CLOSED_ENUM +#endif + +#ifndef TOML_OPEN_FLAGS_ENUM + #define TOML_OPEN_FLAGS_ENUM TOML_OPEN_ENUM TOML_FLAGS_ENUM +#endif + +#ifndef TOML_CLOSED_FLAGS_ENUM + #define TOML_CLOSED_FLAGS_ENUM TOML_CLOSED_ENUM TOML_FLAGS_ENUM +#endif + +#ifdef __has_cpp_attribute + #define TOML_HAS_ATTR(...) __has_cpp_attribute(__VA_ARGS__) +#else + #define TOML_HAS_ATTR(...) 0 +#endif + +#if TOML_HAS_ATTR(likely) >= 201803 + #ifndef TOML_LIKELY + #define TOML_LIKELY(...) (__VA_ARGS__) [[likely]] + #endif + #ifndef TOML_LIKELY_CASE + #define TOML_LIKELY_CASE [[likely]] + #endif +#endif +#ifndef TOML_LIKELY + #define TOML_LIKELY(...) (__VA_ARGS__) +#endif +#ifndef TOML_LIKELY_CASE + #define TOML_LIKELY_CASE +#endif + +#if TOML_HAS_ATTR(unlikely) >= 201803 + #ifndef TOML_UNLIKELY + #define TOML_UNLIKELY(...) (__VA_ARGS__) [[unlikely]] + #endif + #ifndef TOML_UNLIKELY_CASE + #define TOML_UNLIKELY_CASE [[unlikely]] + #endif +#endif +#ifndef TOML_UNLIKELY + #define TOML_UNLIKELY(...) (__VA_ARGS__) +#endif +#ifndef TOML_UNLIKELY_CASE + #define TOML_UNLIKELY_CASE +#endif + +#if TOML_HAS_ATTR(nodiscard) + #define TOML_NODISCARD [[nodiscard]] +#else + #define TOML_NODISCARD +#endif + +#if TOML_HAS_ATTR(nodiscard) >= 201907 + #define TOML_NODISCARD_CTOR [[nodiscard]] +#else + #define TOML_NODISCARD_CTOR +#endif + +#ifndef TOML_TRIVIAL_ABI + #define TOML_TRIVIAL_ABI +#endif + +#define TOML_ASYMMETRICAL_EQUALITY_OPS(LHS, RHS, ...) \ + __VA_ARGS__ TOML_NODISCARD friend bool operator == (RHS rhs, LHS lhs) noexcept { return lhs == rhs; } \ + __VA_ARGS__ TOML_NODISCARD friend bool operator != (LHS lhs, RHS rhs) noexcept { return !(lhs == rhs); } \ + __VA_ARGS__ TOML_NODISCARD friend bool operator != (RHS rhs, LHS lhs) noexcept { return !(lhs == rhs); } \ + static_assert(true) + +#ifndef TOML_SIMPLE_STATIC_ASSERT_MESSAGES + #define TOML_SIMPLE_STATIC_ASSERT_MESSAGES 0 +#endif + +#define TOML_CONCAT_1(x, y) x##y +#define TOML_CONCAT(x, y) TOML_CONCAT_1(x, y) + +#define TOML_EVAL_BOOL_1(T, F) T +#define TOML_EVAL_BOOL_0(T, F) F + +#if defined(__aarch64__) || defined(__ARM_ARCH_ISA_A64) || defined(_M_ARM64) || defined(__ARM_64BIT_STATE) \ + || defined(__arm__) || defined(_M_ARM) || defined(__ARM_32BIT_STATE) + #define TOML_ARM 1 +#else + #define TOML_ARM 0 +#endif + +#define TOML_MAKE_FLAGS_(name, op) \ + TOML_CONST_INLINE_GETTER \ + constexpr name operator op(name lhs, name rhs) noexcept \ + { \ + using under = std::underlying_type_t; \ + return static_cast(static_cast(lhs) op static_cast(rhs)); \ + } \ + constexpr name& operator TOML_CONCAT(op, =)(name & lhs, name rhs) noexcept \ + { \ + return lhs = (lhs op rhs); \ + } \ + static_assert(true, "") + +#define TOML_MAKE_FLAGS(name) \ + TOML_MAKE_FLAGS_(name, &); \ + TOML_MAKE_FLAGS_(name, |); \ + TOML_MAKE_FLAGS_(name, ^); \ + TOML_CONST_INLINE_GETTER \ + constexpr name operator~(name val) noexcept \ + { \ + using under = std::underlying_type_t; \ + return static_cast(~static_cast(val)); \ + } \ + TOML_CONST_INLINE_GETTER \ + constexpr bool operator!(name val) noexcept \ + { \ + using under = std::underlying_type_t; \ + return !static_cast(val); \ + } \ + static_assert(true, "") + +#ifndef TOML_LIFETIME_HOOKS + #define TOML_LIFETIME_HOOKS 0 +#endif + +#if !defined(__POXY__) && !defined(POXY_IMPLEMENTATION_DETAIL) + #define POXY_IMPLEMENTATION_DETAIL(...) __VA_ARGS__ +#endif + +#ifdef NDEBUG + #define TOML_PURE_GETTER TOML_NODISCARD TOML_ATTR(pure) + #define TOML_CONST_GETTER TOML_NODISCARD TOML_ATTR(const) + #define TOML_PURE_INLINE_GETTER TOML_NODISCARD TOML_ALWAYS_INLINE TOML_ATTR(pure) + #define TOML_CONST_INLINE_GETTER TOML_NODISCARD TOML_ALWAYS_INLINE TOML_ATTR(const) +#else + #define TOML_PURE_GETTER TOML_NODISCARD + #define TOML_CONST_GETTER TOML_NODISCARD + #define TOML_PURE_INLINE_GETTER TOML_NODISCARD TOML_ALWAYS_INLINE + #define TOML_CONST_INLINE_GETTER TOML_NODISCARD TOML_ALWAYS_INLINE +#endif + +#define TOML_UNUSED(...) static_cast(__VA_ARGS__) + +#define TOML_DELETE_DEFAULTS(T) \ + T(const T&) = delete; \ + T(T&&) = delete; \ + T& operator=(const T&) = delete; \ + T& operator=(T&&) = delete + +// SFINAE +#if defined(__cpp_concepts) && __cpp_concepts >= 201907 + #define TOML_REQUIRES(...) requires(__VA_ARGS__) +#else + #define TOML_REQUIRES(...) +#endif +#define TOML_ENABLE_IF(...) , typename std::enable_if<(__VA_ARGS__), int>::type = 0 +#define TOML_CONSTRAINED_TEMPLATE(condition, ...) template <__VA_ARGS__ TOML_ENABLE_IF(condition)> TOML_REQUIRES(condition) +#define TOML_HIDDEN_CONSTRAINT(condition, ...) TOML_CONSTRAINED_TEMPLATE(condition, __VA_ARGS__) + +#ifdef __FLT16_MANT_DIG__ + #if __FLT_RADIX__ == 2 \ + && __FLT16_MANT_DIG__ == 11 \ + && __FLT16_DIG__ == 3 \ + && __FLT16_MIN_EXP__ == -13 \ + && __FLT16_MIN_10_EXP__ == -4 \ + && __FLT16_MAX_EXP__ == 16 \ + && __FLT16_MAX_10_EXP__ == 4 + #if TOML_ARM && (TOML_GCC || TOML_CLANG) + #define TOML_FP16 __fp16 + #endif + #if TOML_ARM && TOML_CLANG // not present in g++ + #define TOML_FLOAT16 _Float16 + #endif + #endif +#endif + +#if defined(__SIZEOF_FLOAT128__) \ + && defined(__FLT128_MANT_DIG__) \ + && defined(__LDBL_MANT_DIG__) \ + && __FLT128_MANT_DIG__ > __LDBL_MANT_DIG__ + #define TOML_FLOAT128 __float128 +#endif + +#ifdef __SIZEOF_INT128__ + #define TOML_INT128 __int128_t + #define TOML_UINT128 __uint128_t +#endif + +//******** impl/version.h ******************************************************************************************** + +#define TOML_LIB_MAJOR 3 +#define TOML_LIB_MINOR 1 +#define TOML_LIB_PATCH 0 + +#define TOML_LANG_MAJOR 1 +#define TOML_LANG_MINOR 0 +#define TOML_LANG_PATCH 0 + +//******** impl/preprocessor.h *************************************************************************************** + +#define TOML_LIB_SINGLE_HEADER 1 + +#define TOML_MAKE_VERSION(major, minor, patch) \ + ((major) * 10000 + (minor) * 100 + (patch)) + +#if TOML_ENABLE_UNRELEASED_FEATURES + #define TOML_LANG_EFFECTIVE_VERSION \ + TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH+1) +#else + #define TOML_LANG_EFFECTIVE_VERSION \ + TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH) +#endif + +#define TOML_LANG_HIGHER_THAN(major, minor, patch) \ + (TOML_LANG_EFFECTIVE_VERSION > TOML_MAKE_VERSION(major, minor, patch)) + +#define TOML_LANG_AT_LEAST(major, minor, patch) \ + (TOML_LANG_EFFECTIVE_VERSION >= TOML_MAKE_VERSION(major, minor, patch)) + +#define TOML_LANG_UNRELEASED \ + TOML_LANG_HIGHER_THAN(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH) + +#ifndef TOML_ABI_NAMESPACES + #ifdef DOXYGEN + #define TOML_ABI_NAMESPACES 0 + #else + #define TOML_ABI_NAMESPACES 1 + #endif +#endif +#if TOML_ABI_NAMESPACES + #define TOML_NAMESPACE_START namespace toml { inline namespace TOML_CONCAT(v, TOML_LIB_MAJOR) + #define TOML_NAMESPACE_END } static_assert(true) + #define TOML_NAMESPACE ::toml::TOML_CONCAT(v, TOML_LIB_MAJOR) + #define TOML_ABI_NAMESPACE_START(name) inline namespace name { static_assert(true) + #define TOML_ABI_NAMESPACE_BOOL(cond, T, F) TOML_ABI_NAMESPACE_START(TOML_CONCAT(TOML_EVAL_BOOL_, cond)(T, F)) + #define TOML_ABI_NAMESPACE_END } static_assert(true) +#else + #define TOML_NAMESPACE_START namespace toml + #define TOML_NAMESPACE_END static_assert(true) + #define TOML_NAMESPACE toml + #define TOML_ABI_NAMESPACE_START(...) static_assert(true) + #define TOML_ABI_NAMESPACE_BOOL(...) static_assert(true) + #define TOML_ABI_NAMESPACE_END static_assert(true) +#endif +#define TOML_IMPL_NAMESPACE_START TOML_NAMESPACE_START { namespace impl +#define TOML_IMPL_NAMESPACE_END } TOML_NAMESPACE_END +#if TOML_HEADER_ONLY + #define TOML_ANON_NAMESPACE_START static_assert(TOML_IMPLEMENTATION); TOML_IMPL_NAMESPACE_START + #define TOML_ANON_NAMESPACE_END TOML_IMPL_NAMESPACE_END + #define TOML_ANON_NAMESPACE TOML_NAMESPACE::impl + #define TOML_EXTERNAL_LINKAGE inline + #define TOML_INTERNAL_LINKAGE inline +#else + #define TOML_ANON_NAMESPACE_START static_assert(TOML_IMPLEMENTATION); \ + using namespace toml; \ + namespace + #define TOML_ANON_NAMESPACE_END static_assert(true) + #define TOML_ANON_NAMESPACE + #define TOML_EXTERNAL_LINKAGE + #define TOML_INTERNAL_LINKAGE static +#endif + +#ifdef NDEBUG + #undef TOML_ASSERT + #define TOML_ASSERT(expr) static_assert(true) +#endif +#ifndef TOML_ASSERT + #ifndef assert + TOML_DISABLE_WARNINGS; + #include + TOML_ENABLE_WARNINGS; + #endif + #define TOML_ASSERT(expr) assert(expr) +#endif +#ifdef NDEBUG + #define TOML_ASSERT_ASSUME(expr) TOML_ASSUME(expr) +#else + #define TOML_ASSERT_ASSUME(expr) TOML_ASSERT(expr) +#endif + +#if TOML_SIMPLE_STATIC_ASSERT_MESSAGES + + #define TOML_SA_NEWLINE " " + #define TOML_SA_LIST_SEP ", " + #define TOML_SA_LIST_BEG " (" + #define TOML_SA_LIST_END ")" + #define TOML_SA_LIST_NEW " " + #define TOML_SA_LIST_NXT ", " + +#else + + #define TOML_SA_NEWLINE "\n| " + #define TOML_SA_LIST_SEP TOML_SA_NEWLINE " - " + #define TOML_SA_LIST_BEG TOML_SA_LIST_SEP + #define TOML_SA_LIST_END + #define TOML_SA_LIST_NEW TOML_SA_NEWLINE TOML_SA_NEWLINE + #define TOML_SA_LIST_NXT TOML_SA_LIST_NEW + +#endif + +#define TOML_SA_NATIVE_VALUE_TYPE_LIST \ + TOML_SA_LIST_BEG "std::string" \ + TOML_SA_LIST_SEP "int64_t" \ + TOML_SA_LIST_SEP "double" \ + TOML_SA_LIST_SEP "bool" \ + TOML_SA_LIST_SEP "toml::date" \ + TOML_SA_LIST_SEP "toml::time" \ + TOML_SA_LIST_SEP "toml::date_time" \ + TOML_SA_LIST_END + +#define TOML_SA_NODE_TYPE_LIST \ + TOML_SA_LIST_BEG "toml::table" \ + TOML_SA_LIST_SEP "toml::array" \ + TOML_SA_LIST_SEP "toml::value" \ + TOML_SA_LIST_SEP "toml::value" \ + TOML_SA_LIST_SEP "toml::value" \ + TOML_SA_LIST_SEP "toml::value" \ + TOML_SA_LIST_SEP "toml::value" \ + TOML_SA_LIST_SEP "toml::value" \ + TOML_SA_LIST_SEP "toml::value" \ + TOML_SA_LIST_END + +#define TOML_SA_UNWRAPPED_NODE_TYPE_LIST \ + TOML_SA_LIST_NEW "A native TOML value type" \ + TOML_SA_NATIVE_VALUE_TYPE_LIST \ + \ + TOML_SA_LIST_NXT "A TOML node type" \ + TOML_SA_NODE_TYPE_LIST + +// clang-format on + +TOML_PUSH_WARNINGS; +TOML_DISABLE_SPAM_WARNINGS; +TOML_DISABLE_SWITCH_WARNINGS; +TOML_DISABLE_SUGGEST_ATTR_WARNINGS; + +// misc warning false-positives +#if TOML_MSVC +#pragma warning(disable : 5031) // #pragma warning(pop): likely mismatch +#if TOML_SHARED_LIB +#pragma warning(disable : 4251) // dll exports for std lib types +#endif +#elif TOML_CLANG +#pragma clang diagnostic ignored "-Wheader-hygiene" +#if TOML_CLANG >= 12 +#pragma clang diagnostic ignored "-Wc++20-extensions" +#endif +#if (TOML_CLANG == 13) && !defined(__APPLE__) +#pragma clang diagnostic ignored "-Wreserved-identifier" +#endif +#endif + +//******** impl/std_new.h ******************************************************************************************** + +TOML_DISABLE_WARNINGS; +#include +TOML_ENABLE_WARNINGS; + +#if TOML_CLANG >= 8 || TOML_GCC >= 7 || TOML_ICC >= 1910 || TOML_MSVC >= 1914 +#define TOML_LAUNDER(x) __builtin_launder(x) +#elif defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 +#define TOML_LAUNDER(x) std::launder(x) +#else +#define TOML_LAUNDER(x) x +#endif + +//******** impl/std_string.h ***************************************************************************************** + +TOML_DISABLE_WARNINGS; +#include +#include +TOML_ENABLE_WARNINGS; + +#if defined(DOXYGEN) \ + || (defined(__cpp_char8_t) && __cpp_char8_t >= 201811 && defined(__cpp_lib_char8_t) \ + && __cpp_lib_char8_t >= 201907) +#define TOML_HAS_CHAR8 1 +#else +#define TOML_HAS_CHAR8 0 +#endif + +namespace toml // non-abi namespace; this is not an error +{ + using namespace std::string_literals; + using namespace std::string_view_literals; +} + +#if TOML_ENABLE_WINDOWS_COMPAT + +TOML_IMPL_NAMESPACE_START +{ + TOML_NODISCARD + TOML_EXPORTED_FREE_FUNCTION + std::string narrow(std::wstring_view); + + TOML_NODISCARD + TOML_EXPORTED_FREE_FUNCTION + std::wstring widen(std::string_view); + +#if TOML_HAS_CHAR8 + + TOML_NODISCARD + TOML_EXPORTED_FREE_FUNCTION + std::wstring widen(std::u8string_view); + +#endif +} +TOML_IMPL_NAMESPACE_END; + +#endif // TOML_ENABLE_WINDOWS_COMPAT + +//******** impl/std_optional.h *************************************************************************************** + +TOML_DISABLE_WARNINGS; +#if !TOML_HAS_CUSTOM_OPTIONAL_TYPE +#include +#endif +TOML_ENABLE_WARNINGS; + +TOML_NAMESPACE_START +{ +#if TOML_HAS_CUSTOM_OPTIONAL_TYPE + + template + using optional = TOML_OPTIONAL_TYPE; + +#else + + template + using optional = std::optional; + +#endif +} +TOML_NAMESPACE_END; + +//******** impl/forward_declarations.h ******************************************************************************* + +TOML_DISABLE_WARNINGS; +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +TOML_ENABLE_WARNINGS; +TOML_PUSH_WARNINGS; +#ifdef _MSC_VER +#pragma push_macro("min") +#pragma push_macro("max") +#undef min +#undef max +#endif + +#ifndef TOML_DISABLE_ENVIRONMENT_CHECKS +#define TOML_ENV_MESSAGE \ + "If you're seeing this error it's because you're building toml++ for an environment that doesn't conform to " \ + "one of the 'ground truths' assumed by the library. Essentially this just means that I don't have the " \ + "resources to test on more platforms, but I wish I did! You can try disabling the checks by defining " \ + "TOML_DISABLE_ENVIRONMENT_CHECKS, but your mileage may vary. Please consider filing an issue at " \ + "https://github.com/marzer/tomlplusplus/issues to help me improve support for your target environment. " \ + "Thanks!" + +static_assert(CHAR_BIT == 8, TOML_ENV_MESSAGE); +static_assert(FLT_RADIX == 2, TOML_ENV_MESSAGE); +static_assert('A' == 65, TOML_ENV_MESSAGE); +static_assert(sizeof(double) == 8, TOML_ENV_MESSAGE); +static_assert(std::numeric_limits::is_iec559, TOML_ENV_MESSAGE); +static_assert(std::numeric_limits::digits == 53, TOML_ENV_MESSAGE); +static_assert(std::numeric_limits::digits10 == 15, TOML_ENV_MESSAGE); + +#undef TOML_ENV_MESSAGE +#endif // !TOML_DISABLE_ENVIRONMENT_CHECKS + +// undocumented forward declarations are hidden from doxygen because they fuck it up =/ + +namespace toml // non-abi namespace; this is not an error +{ + using ::std::size_t; + using ::std::intptr_t; + using ::std::uintptr_t; + using ::std::ptrdiff_t; + using ::std::nullptr_t; + using ::std::int8_t; + using ::std::int16_t; + using ::std::int32_t; + using ::std::int64_t; + using ::std::uint8_t; + using ::std::uint16_t; + using ::std::uint32_t; + using ::std::uint64_t; + using ::std::uint_least32_t; + using ::std::uint_least64_t; +} + +TOML_NAMESPACE_START +{ + struct date; + struct time; + struct time_offset; + + TOML_ABI_NAMESPACE_BOOL(TOML_HAS_CUSTOM_OPTIONAL_TYPE, custopt, stdopt); + struct date_time; + TOML_ABI_NAMESPACE_END; + + struct source_position; + struct source_region; + + class node; + template + class node_view; + + class key; + class array; + class table; + template + class value; + + class toml_formatter; + class json_formatter; + class yaml_formatter; + + TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, ex, noex); +#if TOML_EXCEPTIONS + using parse_result = table; +#else + class parse_result; +#endif + TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS +} +TOML_NAMESPACE_END; + +TOML_IMPL_NAMESPACE_START +{ + using node_ptr = std::unique_ptr; + + TOML_ABI_NAMESPACE_BOOL(TOML_EXCEPTIONS, impl_ex, impl_noex); + class parser; + TOML_ABI_NAMESPACE_END; // TOML_EXCEPTIONS + + // clang-format off + + inline constexpr std::string_view control_char_escapes[] = + { + "\\u0000"sv, + "\\u0001"sv, + "\\u0002"sv, + "\\u0003"sv, + "\\u0004"sv, + "\\u0005"sv, + "\\u0006"sv, + "\\u0007"sv, + "\\b"sv, + "\\t"sv, + "\\n"sv, + "\\u000B"sv, + "\\f"sv, + "\\r"sv, + "\\u000E"sv, + "\\u000F"sv, + "\\u0010"sv, + "\\u0011"sv, + "\\u0012"sv, + "\\u0013"sv, + "\\u0014"sv, + "\\u0015"sv, + "\\u0016"sv, + "\\u0017"sv, + "\\u0018"sv, + "\\u0019"sv, + "\\u001A"sv, + "\\u001B"sv, + "\\u001C"sv, + "\\u001D"sv, + "\\u001E"sv, + "\\u001F"sv, + }; + + inline constexpr std::string_view node_type_friendly_names[] = + { + "none"sv, + "table"sv, + "array"sv, + "string"sv, + "integer"sv, + "floating-point"sv, + "boolean"sv, + "date"sv, + "time"sv, + "date-time"sv + }; + + // clang-format on +} +TOML_IMPL_NAMESPACE_END; + +#if TOML_ABI_NAMESPACES +#if TOML_EXCEPTIONS +#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::impl_ex::parser +#else +#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::impl_noex::parser +#endif +#else +#define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::parser +#endif + +namespace toml +{ +} + +TOML_NAMESPACE_START // abi namespace +{ + inline namespace literals + { + } + + enum class TOML_CLOSED_ENUM node_type : uint8_t + { + none, + table, + array, + string, + integer, + floating_point, + boolean, + date, + time, + date_time + }; + + template + inline std::basic_ostream& operator<<(std::basic_ostream& lhs, node_type rhs) + { + using underlying_t = std::underlying_type_t; + const auto str = impl::node_type_friendly_names[static_cast(rhs)]; + if constexpr (std::is_same_v) + return lhs << str; + else + { + if constexpr (sizeof(Char) == 1) + return lhs << std::basic_string_view{ reinterpret_cast(str.data()), str.length() }; + else + return lhs << str.data(); + } + } + + enum class TOML_OPEN_FLAGS_ENUM value_flags : uint16_t // being an "OPEN" flags enum is not an error + { + none, + format_as_binary = 1, + format_as_octal = 2, + format_as_hexadecimal = 3, + }; + TOML_MAKE_FLAGS(value_flags); + + inline constexpr value_flags preserve_source_value_flags = + POXY_IMPLEMENTATION_DETAIL(value_flags{ static_cast>(-1) }); + + enum class TOML_CLOSED_FLAGS_ENUM format_flags : uint64_t + { + none, + quote_dates_and_times = (1ull << 0), + quote_infinities_and_nans = (1ull << 1), + allow_literal_strings = (1ull << 2), + allow_multi_line_strings = (1ull << 3), + allow_real_tabs_in_strings = (1ull << 4), + allow_unicode_strings = (1ull << 5), + allow_binary_integers = (1ull << 6), + allow_octal_integers = (1ull << 7), + allow_hexadecimal_integers = (1ull << 8), + indent_sub_tables = (1ull << 9), + indent_array_elements = (1ull << 10), + indentation = indent_sub_tables | indent_array_elements, + relaxed_float_precision = (1ull << 11), + }; + TOML_MAKE_FLAGS(format_flags); + + template + struct TOML_TRIVIAL_ABI inserter + { + static_assert(std::is_reference_v); + + T value; + }; + template + inserter(T &&) -> inserter; + template + inserter(T&) -> inserter; + + using default_formatter = toml_formatter; +} +TOML_NAMESPACE_END; + +TOML_IMPL_NAMESPACE_START +{ + template + using remove_cvref = std::remove_cv_t>; + + template + using common_signed_type = std::common_type_t...>; + + template + inline constexpr bool is_one_of = (false || ... || std::is_same_v); + + template + inline constexpr bool all_integral = (std::is_integral_v && ...); + + template + inline constexpr bool is_cvref = std::is_reference_v || std::is_const_v || std::is_volatile_v; + + template + inline constexpr bool is_wide_string = + is_one_of, const wchar_t*, wchar_t*, std::wstring_view, std::wstring>; + + template + inline constexpr bool value_retrieval_is_nothrow = !std::is_same_v, std::string> +#if TOML_HAS_CHAR8 + && !std::is_same_v, std::u8string> +#endif + + && !is_wide_string; + + template + struct copy_ref_; + template + using copy_ref = typename copy_ref_::type; + + template + struct copy_ref_ + { + using type = Dest; + }; + + template + struct copy_ref_ + { + using type = std::add_lvalue_reference_t; + }; + + template + struct copy_ref_ + { + using type = std::add_rvalue_reference_t; + }; + + template + struct copy_cv_; + template + using copy_cv = typename copy_cv_::type; + + template + struct copy_cv_ + { + using type = Dest; + }; + + template + struct copy_cv_ + { + using type = std::add_const_t; + }; + + template + struct copy_cv_ + { + using type = std::add_volatile_t; + }; + + template + struct copy_cv_ + { + using type = std::add_cv_t; + }; + + template + using copy_cvref = + copy_ref, std::remove_reference_t>, Dest>, Src>; + + template + inline constexpr bool dependent_false = false; + + template + inline constexpr bool first_is_same = false; + template + inline constexpr bool first_is_same = true; + + // general value traits + // (as they relate to their equivalent native TOML type) + template + struct value_traits + { + using native_type = void; + static constexpr bool is_native = false; + static constexpr bool is_losslessly_convertible_to_native = false; + static constexpr bool can_represent_native = false; + static constexpr bool can_partially_represent_native = false; + static constexpr auto type = node_type::none; + }; + + template + struct value_traits : value_traits + {}; + template + struct value_traits : value_traits + {}; + template + struct value_traits : value_traits + {}; + template + struct value_traits : value_traits + {}; + template + struct value_traits : value_traits + {}; + + // integer value_traits specializations - standard types + template + struct integer_value_limits + { + static constexpr auto min = (std::numeric_limits::min)(); + static constexpr auto max = (std::numeric_limits::max)(); + }; + template + struct integer_value_traits_base : integer_value_limits + { + using native_type = int64_t; + static constexpr bool is_native = std::is_same_v; + static constexpr bool is_signed = static_cast(-1) < T{}; // for impls not specializing std::is_signed + static constexpr auto type = node_type::integer; + static constexpr bool can_partially_represent_native = true; + }; + template + struct unsigned_integer_value_traits : integer_value_traits_base + { + static constexpr bool is_losslessly_convertible_to_native = + integer_value_limits::max <= 9223372036854775807ULL; + static constexpr bool can_represent_native = false; + }; + template + struct signed_integer_value_traits : integer_value_traits_base + { + using native_type = int64_t; + static constexpr bool is_losslessly_convertible_to_native = + integer_value_limits::min >= (-9223372036854775807LL - 1LL) + && integer_value_limits::max <= 9223372036854775807LL; + static constexpr bool can_represent_native = integer_value_limits::min <= (-9223372036854775807LL - 1LL) + && integer_value_limits::max >= 9223372036854775807LL; + }; + template ::is_signed> + struct integer_value_traits : signed_integer_value_traits + {}; + template + struct integer_value_traits : unsigned_integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; + static_assert(value_traits::is_native); + static_assert(value_traits::is_signed); + static_assert(value_traits::is_losslessly_convertible_to_native); + static_assert(value_traits::can_represent_native); + static_assert(value_traits::can_partially_represent_native); + + // integer value_traits specializations - non-standard types +#ifdef TOML_INT128 + template <> + struct integer_value_limits + { + static constexpr TOML_INT128 max = + static_cast((TOML_UINT128{ 1u } << ((__SIZEOF_INT128__ * CHAR_BIT) - 1)) - 1); + static constexpr TOML_INT128 min = -max - TOML_INT128{ 1 }; + }; + template <> + struct integer_value_limits + { + static constexpr TOML_UINT128 min = TOML_UINT128{}; + static constexpr TOML_UINT128 max = + (2u * static_cast(integer_value_limits::max)) + 1u; + }; + template <> + struct value_traits : integer_value_traits + {}; + template <> + struct value_traits : integer_value_traits + {}; +#endif +#ifdef TOML_SMALL_INT_TYPE + template <> + struct value_traits : signed_integer_value_traits + {}; +#endif + + // floating-point value_traits specializations - standard types + template + struct float_value_limits + { + static constexpr bool is_iec559 = std::numeric_limits::is_iec559; + static constexpr int digits = std::numeric_limits::digits; + static constexpr int digits10 = std::numeric_limits::digits10; + }; + template + struct float_value_traits : float_value_limits + { + using native_type = double; + static constexpr bool is_native = std::is_same_v; + static constexpr bool is_signed = true; + + static constexpr bool is_losslessly_convertible_to_native = float_value_limits::is_iec559 + && float_value_limits::digits <= 53 + && float_value_limits::digits10 <= 15; + + static constexpr bool can_represent_native = float_value_limits::is_iec559 + && float_value_limits::digits >= 53 // DBL_MANT_DIG + && float_value_limits::digits10 >= 15; // DBL_DIG + + static constexpr bool can_partially_represent_native // 32-bit float values + = float_value_limits::is_iec559 // + && float_value_limits::digits >= 24 // + && float_value_limits::digits10 >= 6; + + static constexpr auto type = node_type::floating_point; + }; + template <> + struct value_traits : float_value_traits + {}; + template <> + struct value_traits : float_value_traits + {}; + template <> + struct value_traits : float_value_traits + {}; + template + struct extended_float_value_limits + { + static constexpr bool is_iec559 = true; + static constexpr int digits = mant_dig; + static constexpr int digits10 = dig; + }; + static_assert(value_traits::is_native); + static_assert(value_traits::is_losslessly_convertible_to_native); + static_assert(value_traits::can_represent_native); + static_assert(value_traits::can_partially_represent_native); + + // floating-point value_traits specializations - non-standard types +#ifdef TOML_FP16 + template <> + struct float_value_limits : extended_float_value_limits<__FLT16_MANT_DIG__, __FLT16_DIG__> + {}; + template <> + struct value_traits : float_value_traits + {}; +#endif +#ifdef TOML_FLOAT16 + template <> + struct float_value_limits : extended_float_value_limits<__FLT16_MANT_DIG__, __FLT16_DIG__> + {}; + template <> + struct value_traits : float_value_traits + {}; +#endif +#ifdef TOML_FLOAT128 + template <> + struct float_value_limits : extended_float_value_limits<__FLT128_MANT_DIG__, __FLT128_DIG__> + {}; + template <> + struct value_traits : float_value_traits + {}; +#endif +#ifdef TOML_SMALL_FLOAT_TYPE + template <> + struct value_traits : float_value_traits + {}; +#endif + + // string value_traits specializations - char-based strings + template + struct string_value_traits + { + using native_type = std::string; + static constexpr bool is_native = std::is_same_v; + static constexpr bool is_losslessly_convertible_to_native = true; + static constexpr bool can_represent_native = + !std::is_array_v && (!std::is_pointer_v || std::is_const_v>); + static constexpr bool can_partially_represent_native = can_represent_native; + static constexpr auto type = node_type::string; + }; + template <> + struct value_traits : string_value_traits + {}; + template <> + struct value_traits : string_value_traits + {}; + template <> + struct value_traits : string_value_traits + {}; + template + struct value_traits : string_value_traits + {}; + template <> + struct value_traits : string_value_traits + {}; + template + struct value_traits : string_value_traits + {}; + + // string value_traits specializations - char8_t-based strings +#if TOML_HAS_CHAR8 + template <> + struct value_traits : string_value_traits + {}; + template <> + struct value_traits : string_value_traits + {}; + template <> + struct value_traits : string_value_traits + {}; + template + struct value_traits : string_value_traits + {}; + template <> + struct value_traits : string_value_traits + {}; + template + struct value_traits : string_value_traits + {}; +#endif + + // string value_traits specializations - wchar_t-based strings on Windows +#if TOML_ENABLE_WINDOWS_COMPAT + template + struct wstring_value_traits + { + using native_type = std::string; + static constexpr bool is_native = false; + static constexpr bool is_losslessly_convertible_to_native = true; // narrow + static constexpr bool can_represent_native = std::is_same_v; // widen + static constexpr bool can_partially_represent_native = can_represent_native; + static constexpr auto type = node_type::string; + }; + template <> + struct value_traits : wstring_value_traits + {}; + template <> + struct value_traits : wstring_value_traits + {}; + template <> + struct value_traits : wstring_value_traits + {}; + template + struct value_traits : wstring_value_traits + {}; + template <> + struct value_traits : wstring_value_traits + {}; + template + struct value_traits : wstring_value_traits + {}; +#endif + + // other 'native' value_traits specializations + template + struct native_value_traits + { + using native_type = T; + static constexpr bool is_native = true; + static constexpr bool is_losslessly_convertible_to_native = true; + static constexpr bool can_represent_native = true; + static constexpr bool can_partially_represent_native = true; + static constexpr auto type = NodeType; + }; + template <> + struct value_traits : native_value_traits + {}; + template <> + struct value_traits : native_value_traits + {}; + template <> + struct value_traits