From 8eed7cecf237f22aa017401dd18bf99af1dfb0da Mon Sep 17 00:00:00 2001 From: Max Kusatz Date: Thu, 29 Oct 2020 20:44:39 +0100 Subject: Initial Commit --- include/toml.hpp | 12089 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 12089 insertions(+) create mode 100644 include/toml.hpp (limited to 'include/toml.hpp') diff --git a/include/toml.hpp b/include/toml.hpp new file mode 100644 index 0000000..c351d3a --- /dev/null +++ b/include/toml.hpp @@ -0,0 +1,12089 @@ +//---------------------------------------------------------------------------------------------------------------------- +// +// toml++ v2.2.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-rc.3: https://toml.io/en/v1.0.0-rc.3 +// v1.0.0-rc.2: https://toml.io/en/v1.0.0-rc.2 +// v1.0.0-rc.1: https://toml.io/en/v1.0.0-rc.1 +// 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) 2019-2020 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 INCLUDE_TOMLPLUSPLUS_H +#define INCLUDE_TOMLPLUSPLUS_H + +#if 1 //------ ↓ toml_preprocessor.h -------------------------------------------------------------------------------- + +#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 + +#if TOML_CLANG + + #define TOML_PUSH_WARNINGS _Pragma("clang diagnostic push") + #define TOML_DISABLE_SWITCH_WARNINGS _Pragma("clang diagnostic ignored \"-Wswitch\"") + #define TOML_DISABLE_INIT_WARNINGS _Pragma("clang diagnostic ignored \"-Wmissing-field-initializers\"") + #define TOML_DISABLE_ARITHMETIC_WARNINGS _Pragma("clang diagnostic ignored \"-Wfloat-equal\"") \ + _Pragma("clang diagnostic ignored \"-Wdouble-promotion\"") \ + _Pragma("clang diagnostic ignored \"-Wchar-subscripts\"") \ + _Pragma("clang diagnostic ignored \"-Wshift-sign-overflow\"") + #define TOML_DISABLE_SHADOW_WARNINGS _Pragma("clang diagnostic ignored \"-Wshadow\"") + #define TOML_DISABLE_SPAM_WARNINGS _Pragma("clang diagnostic ignored \"-Wweak-vtables\"") \ + _Pragma("clang diagnostic ignored \"-Wweak-template-vtables\"") \ + _Pragma("clang diagnostic ignored \"-Wpadded\"") + #define TOML_POP_WARNINGS _Pragma("clang diagnostic pop") + #define TOML_DISABLE_WARNINGS TOML_PUSH_WARNINGS \ + _Pragma("clang diagnostic ignored \"-Weverything\"") + #define TOML_ENABLE_WARNINGS TOML_POP_WARNINGS + #define TOML_ASSUME(cond) __builtin_assume(cond) + #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_INTERFACE __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 + #endif + #define TOML_LIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 1) ) + #define TOML_UNLIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 0) ) + + //floating-point from_chars and to_chars are not implemented in any version of clang as of 1/1/2020 + #ifndef TOML_FLOAT_CHARCONV + #define TOML_FLOAT_CHARCONV 0 + #endif + + #define TOML_SIMPLE_STATIC_ASSERT_MESSAGES 1 + +#endif // clang + +#if TOML_MSVC || TOML_ICC_CL + + #define TOML_CPP_VERSION _MSVC_LANG + #define TOML_PUSH_WARNINGS __pragma(warning(push)) + #if TOML_MSVC // !intel-cl + #define TOML_PUSH_WARNINGS __pragma(warning(push)) + #define TOML_DISABLE_SWITCH_WARNINGS __pragma(warning(disable: 4063)) + #define TOML_POP_WARNINGS __pragma(warning(pop)) + #define TOML_DISABLE_WARNINGS __pragma(warning(push, 0)) + #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(cond) __assume(cond) + #define TOML_UNREACHABLE __assume(0) + #define TOML_INTERFACE __declspec(novtable) + #define TOML_EMPTY_BASES __declspec(empty_bases) + +#endif // msvc + +#if TOML_ICC + + #define TOML_PUSH_WARNINGS __pragma(warning(push)) + #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: 1011)) /* missing return (false-positive) */ \ + __pragma(warning(disable: 2261)) /* assume expr side-effects discarded */ + #define TOML_POP_WARNINGS __pragma(warning(pop)) + #define TOML_DISABLE_WARNINGS __pragma(warning(push, 0)) + #define TOML_ENABLE_WARNINGS TOML_POP_WARNINGS + +#endif // icc + +#if TOML_GCC + + #define TOML_PUSH_WARNINGS _Pragma("GCC diagnostic push") + #define TOML_DISABLE_SWITCH_WARNINGS _Pragma("GCC diagnostic ignored \"-Wswitch\"") \ + _Pragma("GCC diagnostic ignored \"-Wswitch-enum\"") \ + _Pragma("GCC diagnostic ignored \"-Wswitch-default\"") + #define TOML_DISABLE_INIT_WARNINGS _Pragma("GCC diagnostic ignored \"-Wmissing-field-initializers\"") \ + _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") \ + _Pragma("GCC diagnostic ignored \"-Wuninitialized\"") + #define TOML_DISABLE_ARITHMETIC_WARNINGS _Pragma("GCC diagnostic ignored \"-Wfloat-equal\"") \ + _Pragma("GCC diagnostic ignored \"-Wsign-conversion\"") \ + _Pragma("GCC diagnostic ignored \"-Wchar-subscripts\"") + #define TOML_DISABLE_SHADOW_WARNINGS _Pragma("GCC diagnostic ignored \"-Wshadow\"") + #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 \"-Wsuggest-attribute=const\"") \ + _Pragma("GCC diagnostic ignored \"-Wsuggest-attribute=pure\"") + #define TOML_POP_WARNINGS _Pragma("GCC diagnostic pop") + #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_INIT_WARNINGS \ + TOML_DISABLE_ARITHMETIC_WARNINGS \ + TOML_DISABLE_SHADOW_WARNINGS \ + TOML_DISABLE_SPAM_WARNINGS + #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) ) + + // floating-point from_chars and to_chars are not implemented in any version of gcc as of 1/1/2020 + #ifndef TOML_FLOAT_CHARCONV + #define TOML_FLOAT_CHARCONV 0 + #endif + +#endif + +#ifdef TOML_CONFIG_HEADER + #include TOML_CONFIG_HEADER +#endif + +#ifdef DOXYGEN + #define TOML_HEADER_ONLY 0 + #define TOML_WINDOWS_COMPAT 1 +#endif + +#if defined(TOML_ALL_INLINE) && !defined(TOML_HEADER_ONLY) + #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(TOML_IMPLEMENTATION) || TOML_HEADER_ONLY + #undef TOML_IMPLEMENTATION + #define TOML_IMPLEMENTATION 1 +#else + #define TOML_IMPLEMENTATION 0 +#endif + +#ifndef TOML_API + #define TOML_API +#endif + +#ifndef TOML_UNRELEASED_FEATURES + #define TOML_UNRELEASED_FEATURES 0 +#endif + +#ifndef TOML_LARGE_FILES + #define TOML_LARGE_FILES 0 +#endif + +#ifndef TOML_UNDEF_MACROS + #define TOML_UNDEF_MACROS 1 +#endif + +#ifndef TOML_PARSER + #define TOML_PARSER 1 +#endif + +#ifndef DOXYGEN + #if defined(_WIN32) && !defined(TOML_WINDOWS_COMPAT) + #define TOML_WINDOWS_COMPAT 1 + #endif + #if !defined(_WIN32) || !defined(TOML_WINDOWS_COMPAT) + #undef TOML_WINDOWS_COMPAT + #define TOML_WINDOWS_COMPAT 0 + #endif +#endif + +#ifdef TOML_OPTIONAL_TYPE + #define TOML_HAS_CUSTOM_OPTIONAL_TYPE 1 +#else + #define TOML_HAS_CUSTOM_OPTIONAL_TYPE 0 +#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 can now work with char8_t strings implicitly so changing the underlying string type \ +is no longer necessary. + #endif +#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 +#elif TOML_CPP_VERSION >= 202600L + #define TOML_CPP 26 +#elif TOML_CPP_VERSION >= 202300L + #define TOML_CPP 23 +#elif TOML_CPP_VERSION >= 202002L + #define TOML_CPP 20 +#elif TOML_CPP_VERSION >= 201703L + #define TOML_CPP 17 +#endif +#undef TOML_CPP_VERSION + +#ifdef __has_include + #define TOML_HAS_INCLUDE(header) __has_include(header) +#else + #define TOML_HAS_INCLUDE(header) 0 +#endif + +#if defined(__EXCEPTIONS) || defined(_CPPUNWIND) || defined(__cpp_exceptions) + #define TOML_COMPILER_EXCEPTIONS 1 +#else + #define TOML_COMPILER_EXCEPTIONS 0 +#endif +#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 + +#if TOML_EXCEPTIONS + #define TOML_MAY_THROW +#else + #define TOML_MAY_THROW noexcept +#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 +#endif +#ifndef TOML_DISABLE_SWITCH_WARNINGS + #define TOML_DISABLE_SWITCH_WARNINGS +#endif +#ifndef TOML_DISABLE_INIT_WARNINGS + #define TOML_DISABLE_INIT_WARNINGS +#endif +#ifndef TOML_DISABLE_SPAM_WARNINGS + #define TOML_DISABLE_SPAM_WARNINGS +#endif +#ifndef TOML_DISABLE_ARITHMETIC_WARNINGS + #define TOML_DISABLE_ARITHMETIC_WARNINGS +#endif +#ifndef TOML_DISABLE_SHADOW_WARNINGS + #define TOML_DISABLE_SHADOW_WARNINGS +#endif +#ifndef TOML_POP_WARNINGS + #define TOML_POP_WARNINGS +#endif +#ifndef TOML_DISABLE_WARNINGS + #define TOML_DISABLE_WARNINGS +#endif +#ifndef TOML_ENABLE_WARNINGS + #define TOML_ENABLE_WARNINGS +#endif + +#ifndef TOML_ATTR + #define TOML_ATTR(...) +#endif + +#ifndef TOML_INTERFACE + #define TOML_INTERFACE +#endif + +#ifndef TOML_EMPTY_BASES + #define TOML_EMPTY_BASES +#endif + +#ifndef TOML_NEVER_INLINE + #define TOML_NEVER_INLINE +#endif + +#ifndef TOML_ASSUME + #define TOML_ASSUME(cond) (void)0 +#endif + +#ifndef TOML_UNREACHABLE + #define TOML_UNREACHABLE TOML_ASSERT(false) +#endif + +#define TOML_NO_DEFAULT_CASE default: TOML_UNREACHABLE + +#ifdef __cpp_consteval + #define TOML_CONSTEVAL consteval +#else + #define TOML_CONSTEVAL constexpr +#endif + +#ifdef __has_cpp_attribute + #define TOML_HAS_ATTR(...) __has_cpp_attribute(__VA_ARGS__) +#else + #define TOML_HAS_ATTR(...) 0 +#endif + +#if !defined(DOXYGEN) && !TOML_INTELLISENSE + #if !defined(TOML_LIKELY) && TOML_HAS_ATTR(likely) + #define TOML_LIKELY(...) (__VA_ARGS__) [[likely]] + #endif + #if !defined(TOML_UNLIKELY) && TOML_HAS_ATTR(unlikely) + #define TOML_UNLIKELY(...) (__VA_ARGS__) [[unlikely]] + #endif + #if TOML_HAS_ATTR(nodiscard) >= 201907L + #define TOML_NODISCARD_CTOR [[nodiscard]] + #endif +#endif + +#ifndef TOML_LIKELY + #define TOML_LIKELY(...) (__VA_ARGS__) +#endif +#ifndef TOML_UNLIKELY + #define TOML_UNLIKELY(...) (__VA_ARGS__) +#endif +#ifndef TOML_NODISCARD_CTOR + #define TOML_NODISCARD_CTOR +#endif + +#ifndef TOML_TRIVIAL_ABI + #define TOML_TRIVIAL_ABI +#endif + +#define TOML_ASYMMETRICAL_EQUALITY_OPS(LHS, RHS, ...) \ + __VA_ARGS__ [[nodiscard]] friend bool operator == (RHS rhs, LHS lhs) noexcept { return lhs == rhs; } \ + __VA_ARGS__ [[nodiscard]] friend bool operator != (LHS lhs, RHS rhs) noexcept { return !(lhs == rhs); } \ + __VA_ARGS__ [[nodiscard]] friend bool operator != (RHS rhs, LHS lhs) noexcept { return !(lhs == rhs); } + +#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_BITOPS(type) \ + [[nodiscard]] \ + TOML_ALWAYS_INLINE \ + TOML_ATTR(const) \ + TOML_ATTR(flatten) \ + constexpr type operator & (type lhs, type rhs) noexcept \ + { \ + return static_cast(::toml::impl::unwrap_enum(lhs) & ::toml::impl::unwrap_enum(rhs)); \ + } \ + [[nodiscard]] \ + TOML_ALWAYS_INLINE \ + TOML_ATTR(const) \ + TOML_ATTR(flatten) \ + constexpr type operator | (type lhs, type rhs) noexcept \ + { \ + return static_cast(::toml::impl::unwrap_enum(lhs) | ::toml::impl::unwrap_enum(rhs)); \ + } + +#ifndef TOML_LIFETIME_HOOKS + #define TOML_LIFETIME_HOOKS 0 +#endif + +#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 + +#define TOML_LIB_MAJOR 2 +#define TOML_LIB_MINOR 2 +#define TOML_LIB_PATCH 0 + +#define TOML_LANG_MAJOR 1 +#define TOML_LANG_MINOR 0 +#define TOML_LANG_PATCH 0 + +#define TOML_LIB_SINGLE_HEADER 1 + +#define TOML_MAKE_VERSION(maj, min, rev) \ + ((maj) * 1000 + (min) * 25 + (rev)) + +#if TOML_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(maj, min, rev) \ + (TOML_LANG_EFFECTIVE_VERSION > TOML_MAKE_VERSION(maj, min, rev)) + +#define TOML_LANG_AT_LEAST(maj, min, rev) \ + (TOML_LANG_EFFECTIVE_VERSION >= TOML_MAKE_VERSION(maj, min, rev)) + +#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 } + #define TOML_NAMESPACE ::toml::TOML_CONCAT(v, TOML_LIB_MAJOR) + #define TOML_ABI_NAMESPACE_START(name) inline namespace name { + #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 } +#else + #define TOML_NAMESPACE_START namespace toml + #define TOML_NAMESPACE_END + #define TOML_NAMESPACE toml + #define TOML_ABI_NAMESPACE_START(...) + #define TOML_ABI_NAMESPACE_BOOL(...) + #define TOML_ABI_NAMESPACE_END +#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 TOML_IMPL_NAMESPACE_START + #define TOML_ANON_NAMESPACE_END TOML_IMPL_NAMESPACE_END + #define TOML_ANON_NAMESPACE TOML_NAMESPACE::impl + #define TOML_USING_ANON_NAMESPACE using namespace TOML_ANON_NAMESPACE + #define TOML_EXTERNAL_LINKAGE inline + #define TOML_INTERNAL_LINKAGE inline +#else + #define TOML_ANON_NAMESPACE_START namespace + #define TOML_ANON_NAMESPACE_END + #define TOML_ANON_NAMESPACE + #define TOML_USING_ANON_NAMESPACE (void)0 + #define TOML_EXTERNAL_LINKAGE + #define TOML_INTERNAL_LINKAGE static +#endif + +TOML_DISABLE_WARNINGS +#ifndef TOML_ASSERT + #if defined(NDEBUG) || !defined(_DEBUG) + #define TOML_ASSERT(expr) (void)0 + #else + #ifndef assert + #include + #endif + #define TOML_ASSERT(expr) assert(expr) + #endif +#endif +TOML_ENABLE_WARNINGS + +#endif //------ ↑ toml_preprocessor.h -------------------------------------------------------------------------------- + +TOML_PUSH_WARNINGS +TOML_DISABLE_SPAM_WARNINGS + +#if 1 //---------------------------------- ↓ toml_common.h ---------------------------------------------------------- + +TOML_DISABLE_WARNINGS +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if !TOML_HAS_CUSTOM_OPTIONAL_TYPE + #include +#endif +#if TOML_HAS_INCLUDE() + #include +#endif +TOML_ENABLE_WARNINGS + +#ifdef __cpp_lib_launder + #define TOML_LAUNDER(x) std::launder(x) +#else + #define TOML_LAUNDER(x) x +#endif + +#ifndef DOXYGEN +#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 +#endif // !DOXYGEN + +#ifndef DOXYGEN // undocumented forward declarations are hidden from doxygen because they fuck it up =/ + +namespace toml // non-abi namespace; this is not an error +{ + using namespace std::string_literals; + using namespace std::string_view_literals; + 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; + + // legacy typedefs + using string_char = char; + using string = std::string; + using string_view = std::string_view; +} + +TOML_NAMESPACE_START // abi namespace +{ + 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 + + class node; + class array; + class table; + + template class node_view; + template class value; + template class default_formatter; + template class json_formatter; + + [[nodiscard]] TOML_API bool operator == (const array& lhs, const array& rhs) noexcept; + [[nodiscard]] TOML_API bool operator != (const array& lhs, const array& rhs) noexcept; + [[nodiscard]] TOML_API bool operator == (const table& lhs, const table& rhs) noexcept; + [[nodiscard]] TOML_API bool operator != (const table& lhs, const table& rhs) noexcept; + + template + std::basic_ostream& operator << (std::basic_ostream&, const array&); + template + std::basic_ostream& operator << (std::basic_ostream&, const value&); + template + std::basic_ostream& operator << (std::basic_ostream&, const table&); + template + std::basic_ostream& operator << (std::basic_ostream&, default_formatter&); + template + std::basic_ostream& operator << (std::basic_ostream&, default_formatter&&); + template + std::basic_ostream& operator << (std::basic_ostream&, json_formatter&); + template + std::basic_ostream& operator << (std::basic_ostream&, json_formatter&&); + template + inline std::basic_ostream& operator << (std::basic_ostream&, const node_view&); + + namespace impl + { + template + using string_map = std::map>; // heterogeneous lookup + + template + using remove_cvref_t = std::remove_cv_t>; + + template + inline constexpr bool is_one_of = (false || ... || std::is_same_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< + std::decay_t, + const wchar_t*, + wchar_t*, + std::wstring_view, + std::wstring + >; + + template + inline constexpr bool dependent_false = false; + + #if TOML_WINDOWS_COMPAT + [[nodiscard]] TOML_API std::string narrow(std::wstring_view) noexcept; + [[nodiscard]] TOML_API std::wstring widen(std::string_view) noexcept; + #ifdef __cpp_lib_char8_t + [[nodiscard]] TOML_API std::wstring widen(std::u8string_view) noexcept; + #endif + #endif // TOML_WINDOWS_COMPAT + + #if TOML_ABI_NAMESPACES + #if TOML_EXCEPTIONS + TOML_ABI_NAMESPACE_START(ex) + #define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::ex::parser + #else + TOML_ABI_NAMESPACE_START(noex) + #define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::noex::parser + #endif + #else + #define TOML_PARSER_TYPENAME TOML_NAMESPACE::impl::parser + #endif + class parser; + TOML_ABI_NAMESPACE_END // TOML_EXCEPTIONS + } +} +TOML_NAMESPACE_END + +#endif // !DOXYGEN + +namespace toml { } + +TOML_NAMESPACE_START // abi namespace +{ + inline namespace literals {} + + #if TOML_HAS_CUSTOM_OPTIONAL_TYPE + template + using optional = TOML_OPTIONAL_TYPE; + #else + template + using optional = std::optional; + #endif + + enum class node_type : uint8_t + { + none, + table, + array, + string, + integer, + floating_point, + boolean, + date, + time, + date_time + }; + + using source_path_ptr = std::shared_ptr; + + template + struct TOML_TRIVIAL_ABI inserter + { + T&& value; + }; + template inserter(T&&) -> inserter; +} +TOML_NAMESPACE_END + +TOML_IMPL_NAMESPACE_START +{ + // 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 + 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 {}; + #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 + 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); + + // float value traits + 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; + }; + #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 + 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); + + // string value traits + 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 {}; + #ifdef __cpp_lib_char8_t + 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 + #if TOML_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 + 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