preprocessor.hpp File Reference

#include <cassert>
#include "version.hpp"

Go to the source code of this file.

Macros
#define	TOML_CPP   __cplusplus
#define	TOML_CPP   0
#define	TOML_MAKE_VERSION(major, minor, patch)   (((major)*10000) + ((minor)*100) + ((patch)))
#define	TOML_INTELLISENSE   0
#define	TOML_DOXYGEN   0
#define	TOML_CLANG   0
#define	TOML_ICC   0
#define	TOML_ICC_CL   0
#define	TOML_MSVC_LIKE   0
#define	TOML_MSVC   0
#define	TOML_GCC_LIKE   0
#define	TOML_GCC   0
#define	TOML_CUDA   0
#define	TOML_ARCH_ITANIUM   0
#define	TOML_ARCH_AMD64   0
#define	TOML_ARCH_X86   0
#define	TOML_ARCH_ARM32   0
#define	TOML_ARCH_ARM64   0
#define	TOML_ARCH_ARM   0
#define	TOML_ARCH_BITNESS   0
#define	TOML_ARCH_X64   0
#define	TOML_WINDOWS   0
#define	TOML_UNIX   0
#define	TOML_LINUX   0
#define	TOML_HAS_INCLUDE(header)   0
#define	TOML_HAS_BUILTIN(name)   0
#define	TOML_HAS_FEATURE(name)   0
#define	TOML_HAS_ATTR(attr)   0
#define	TOML_HAS_CPP_ATTR(attr)   0
#define	TOML_ATTR(...)
#define	TOML_DECLSPEC(...)
#define	TOML_COMPILER_HAS_EXCEPTIONS   0
#define	TOML_COMPILER_HAS_RTTI   0
#define	TOML_CONCAT_1(x, y)   x##y
#define	TOML_CONCAT(x, y)   TOML_CONCAT_1(x, y)
#define	TOML_MAKE_STRING_1(s)   #s
#define	TOML_MAKE_STRING(s)   TOML_MAKE_STRING_1(s)
#define	TOML_PRAGMA_CLANG(decl)
#define	TOML_PRAGMA_CLANG_GE_8(decl)
#define	TOML_PRAGMA_CLANG_GE_9(decl)
#define	TOML_PRAGMA_CLANG_GE_10(decl)
#define	TOML_PRAGMA_CLANG_GE_11(decl)
#define	TOML_PRAGMA_GCC(decl)
#define	TOML_PRAGMA_MSVC(...)
#define	TOML_PRAGMA_ICC(...)
#define	TOML_ALWAYS_INLINE   inline
#define	TOML_NEVER_INLINE
#define	TOML_ABSTRACT_INTERFACE   TOML_DECLSPEC(novtable)
#define	TOML_EMPTY_BASES   TOML_DECLSPEC(empty_bases)
#define	TOML_TRIVIAL_ABI
#define	TOML_NODISCARD
#define	TOML_NODISCARD_CTOR
#define	TOML_PURE
#define	TOML_CONST
#define	TOML_INLINE_GETTER
#define	TOML_PURE_GETTER
#define	TOML_PURE_INLINE_GETTER
#define	TOML_CONST_GETTER
#define	TOML_CONST_INLINE_GETTER
#define	TOML_ASSUME(expr)   static_cast<void>(0)
#define	TOML_UNREACHABLE   static_cast<void>(0)
#define	TOML_LIKELY(...)   (__VA_ARGS__)
#define	TOML_LIKELY_CASE
#define	TOML_UNLIKELY(...)   (__VA_ARGS__)
#define	TOML_UNLIKELY_CASE
#define	TOML_FLAGS_ENUM
#define	TOML_OPEN_ENUM
#define	TOML_CLOSED_ENUM
#define	TOML_OPEN_FLAGS_ENUM   TOML_OPEN_ENUM TOML_FLAGS_ENUM
#define	TOML_CLOSED_FLAGS_ENUM   TOML_CLOSED_ENUM TOML_FLAGS_ENUM
#define	TOML_MAKE_FLAGS_2(T, op, linkage)
#define	TOML_MAKE_FLAGS_1(T, linkage)
#define	TOML_MAKE_FLAGS(T)   TOML_MAKE_FLAGS_1(T, )
#define	TOML_UNUSED(...)   static_cast<void>(__VA_ARGS__)
#define	TOML_DELETE_DEFAULTS(T)
#define	TOML_ASYMMETRICAL_EQUALITY_OPS(LHS, RHS, ...)
#define	TOML_EVAL_BOOL_1(T, F)   T
#define	TOML_EVAL_BOOL_0(T, F)   F
#define	POXY_IMPLEMENTATION_DETAIL(...)   __VA_ARGS__
#define	TOML_PUSH_WARNINGS   static_assert(true)
#define	TOML_DISABLE_CODE_ANALYSIS_WARNINGS   static_assert(true)
#define	TOML_DISABLE_SWITCH_WARNINGS   static_assert(true)
#define	TOML_DISABLE_SUGGEST_ATTR_WARNINGS   static_assert(true)
#define	TOML_DISABLE_SPAM_WARNINGS   static_assert(true)
#define	TOML_DISABLE_ARITHMETIC_WARNINGS   static_assert(true)
#define	TOML_POP_WARNINGS   static_assert(true)
#define	TOML_DISABLE_WARNINGS   static_assert(true)
#define	TOML_ENABLE_WARNINGS   static_assert(true)
#define	TOML_SIMPLE_STATIC_ASSERT_MESSAGES   0
#define	TOML_SHARED_LIB   0
#define	TOML_HEADER_ONLY   1
	Sets whether the library is entirely inline. \detail Defaults to 1.
#define	TOML_IMPLEMENTATION   1
	Enables the library's implementation when TOML_HEADER_ONLY is disabled. \detail Not defined by default. Meaningless when TOML_HEADER_ONLY is enabled.
#define	TOML_EXPORTED_CLASS
	An 'export' annotation to add to classes. \detail Not defined by default.
#define	TOML_EXPORTED_MEMBER_FUNCTION
	An 'export' annotation to add to non-static class member functions. \detail Not defined by default.
#define	TOML_EXPORTED_STATIC_FUNCTION
	An 'export' annotation to add to static class member functions. \detail Not defined by default.
#define	TOML_EXPORTED_FREE_FUNCTION
	An 'export' annotation to add to free functions. \detail Not defined by default.
#define	TOML_ENABLE_UNRELEASED_FEATURES   0
	Enables support for unreleased TOML language features not yet part of a numbered version. \detail Defaults to 0.
#define	TOML_ENABLE_PARSER   1
	Sets whether the parser-related parts of the library are included. \detail Defaults to 1.
#define	TOML_ENABLE_FORMATTERS   1
	Sets whether the various formatter classes are enabled. \detail Defaults to 1.
#define	TOML_ENABLE_SIMD   1
#define	TOML_ENABLE_WINDOWS_COMPAT   1
	Enables the use of wide strings (wchar_t, std::wstring) in various places throughout the library when building for Windows. \detail Defaults to 1 when building for Windows, 0 otherwise. Has no effect when building for anything other than Windows.
#define	TOML_INCLUDE_WINDOWS_H   0
#define	TOML_HAS_CUSTOM_OPTIONAL_TYPE   0
#define	TOML_EXCEPTIONS   0
	Sets whether the library uses exceptions to report parsing failures. \detail Defaults to 1 or 0 according to your compiler's exception mode.
#define	TOML_CALLCONV
	Calling convention to apply to exported free/static functions. \detail Not defined by default (let the compiler decide).
#define	TOML_UNDEF_MACROS   1
#define	TOML_MAX_NESTED_VALUES   256
#define	TOML_LIFETIME_HOOKS   0
#define	TOML_ASSERT(expr)   assert(expr)
	Sets the assert function used by the library. \detail Defaults to the standard C assert().
#define	TOML_ASSERT_ASSUME(expr)   TOML_ASSERT(expr)
#define	TOML_ENABLE_FLOAT16   0
	Enable support for the built-in _Float16 type. \detail Defaults to 0.
#define	TOML_INT_CHARCONV   1
#define	TOML_FLOAT_CHARCONV   1
#define	TOML_INT_CHARCONV   0
#define	TOML_FLOAT_CHARCONV   0
#define	TOML_CONSTRAINED_TEMPLATE(condition, ...)   template <__VA_ARGS__>
#define	TOML_HIDDEN_CONSTRAINT(condition, ...)
#define	TOML_LIB_SINGLE_HEADER   0
#define	TOML_LANG_EFFECTIVE_VERSION    TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)
#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)
#define	TOML_ABI_NAMESPACES   1
#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)
#define	TOML_IMPL_NAMESPACE_START   TOML_NAMESPACE_START { namespace impl
#define	TOML_IMPL_NAMESPACE_END   } TOML_NAMESPACE_END
#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

Variables
	TOML_DISABLE_WARNINGS
	TOML_ENABLE_WARNINGS

Macro Definition Documentation

POXY_IMPLEMENTATION_DETAIL

#define POXY_IMPLEMENTATION_DETAIL

(

...

)

__VA_ARGS__

TOML_ABI_NAMESPACE_BOOL

#define TOML_ABI_NAMESPACE_BOOL	(		cond,
			T,
			F
	)		TOML_ABI_NAMESPACE_START(TOML_CONCAT(TOML_EVAL_BOOL_, cond)(T, F))

TOML_ABI_NAMESPACE_END

#define TOML_ABI_NAMESPACE_END   } static_assert(true)

TOML_ABI_NAMESPACE_START

#define TOML_ABI_NAMESPACE_START

(

name

)

inline namespace name { static_assert(true)

TOML_ABI_NAMESPACES

#define TOML_ABI_NAMESPACES   1

TOML_ABSTRACT_INTERFACE

#define TOML_ABSTRACT_INTERFACE   TOML_DECLSPEC(novtable)

TOML_ALWAYS_INLINE

#define TOML_ALWAYS_INLINE   inline

TOML_ANON_NAMESPACE

#define TOML_ANON_NAMESPACE   TOML_NAMESPACE::impl

TOML_ANON_NAMESPACE_END

#define TOML_ANON_NAMESPACE_END   TOML_IMPL_NAMESPACE_END

TOML_ANON_NAMESPACE_START

#define TOML_ANON_NAMESPACE_START   static_assert(TOML_IMPLEMENTATION); TOML_IMPL_NAMESPACE_START

TOML_ARCH_AMD64

#define TOML_ARCH_AMD64   0

TOML_ARCH_ARM

#define TOML_ARCH_ARM   0

TOML_ARCH_ARM32

#define TOML_ARCH_ARM32   0

TOML_ARCH_ARM64

#define TOML_ARCH_ARM64   0

TOML_ARCH_BITNESS

#define TOML_ARCH_BITNESS   0

TOML_ARCH_ITANIUM

#define TOML_ARCH_ITANIUM   0

TOML_ARCH_X64

#define TOML_ARCH_X64   0

TOML_ARCH_X86

#define TOML_ARCH_X86   0

TOML_ASSUME

#define TOML_ASSUME

(

expr

)

static_cast<void>(0)

TOML_ASYMMETRICAL_EQUALITY_OPS

#define TOML_ASYMMETRICAL_EQUALITY_OPS	(		LHS,
			RHS,
			...
	)

Value:

    __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)

TOML_ATTR

#define TOML_ATTR

(

...

)

TOML_CLANG

#define TOML_CLANG   0

TOML_CLOSED_ENUM

#define TOML_CLOSED_ENUM

TOML_CLOSED_FLAGS_ENUM

#define TOML_CLOSED_FLAGS_ENUM   TOML_CLOSED_ENUM TOML_FLAGS_ENUM

TOML_COMPILER_HAS_EXCEPTIONS

#define TOML_COMPILER_HAS_EXCEPTIONS   0

TOML_COMPILER_HAS_RTTI

#define TOML_COMPILER_HAS_RTTI   0

TOML_CONCAT

#define TOML_CONCAT	(		x,
			y
	)		TOML_CONCAT_1(x, y)

TOML_CONCAT_1

#define TOML_CONCAT_1	(		x,
			y
	)		x##y

TOML_CONST

#define TOML_CONST

TOML_CONST_GETTER

#define TOML_CONST_GETTER

Value:

    TOML_NODISCARD                                                                                                     \
    TOML_CONST

TOML_CONST_INLINE_GETTER

#define TOML_CONST_INLINE_GETTER

Value:

    TOML_NODISCARD                                                                                                     \
    TOML_ALWAYS_INLINE                                                                                                 \
    TOML_CONST

TOML_CONSTRAINED_TEMPLATE

#define TOML_CONSTRAINED_TEMPLATE	(		condition,
			...
	)		template <__VA_ARGS__>

TOML_CPP [1/2]

#define TOML_CPP   __cplusplus

TOML_CPP [2/2]

#define TOML_CPP   0

TOML_CUDA

#define TOML_CUDA   0

TOML_DECLSPEC

#define TOML_DECLSPEC

(

...

)

TOML_DELETE_DEFAULTS

#define TOML_DELETE_DEFAULTS

(

T

)

Value:

    T(const T&)            = delete;                                                                                   \
    T(T&&)                 = delete;                                                                                   \
    T& operator=(const T&) = delete;                                                                                   \
    T& operator=(T&&)      = delete

TOML_DISABLE_ARITHMETIC_WARNINGS

#define TOML_DISABLE_ARITHMETIC_WARNINGS   static_assert(true)

TOML_DISABLE_CODE_ANALYSIS_WARNINGS

#define TOML_DISABLE_CODE_ANALYSIS_WARNINGS   static_assert(true)

TOML_DISABLE_SPAM_WARNINGS

#define TOML_DISABLE_SPAM_WARNINGS   static_assert(true)

TOML_DISABLE_SUGGEST_ATTR_WARNINGS

#define TOML_DISABLE_SUGGEST_ATTR_WARNINGS   static_assert(true)

TOML_DISABLE_SWITCH_WARNINGS

#define TOML_DISABLE_SWITCH_WARNINGS   static_assert(true)

TOML_DISABLE_WARNINGS

#define TOML_DISABLE_WARNINGS   static_assert(true)

TOML_DOXYGEN

#define TOML_DOXYGEN   0

TOML_EMPTY_BASES

#define TOML_EMPTY_BASES   TOML_DECLSPEC(empty_bases)

TOML_ENABLE_WARNINGS

#define TOML_ENABLE_WARNINGS   static_assert(true)

TOML_EVAL_BOOL_0

#define TOML_EVAL_BOOL_0	(		T,
			F
	)		F

TOML_EVAL_BOOL_1

#define TOML_EVAL_BOOL_1	(		T,
			F
	)		T

TOML_EXTERNAL_LINKAGE

#define TOML_EXTERNAL_LINKAGE   inline

TOML_FLAGS_ENUM

#define TOML_FLAGS_ENUM

TOML_FLOAT_CHARCONV [1/2]

#define TOML_FLOAT_CHARCONV   1

TOML_FLOAT_CHARCONV [2/2]

#define TOML_FLOAT_CHARCONV   0

TOML_GCC

#define TOML_GCC   0

TOML_GCC_LIKE

#define TOML_GCC_LIKE   0

TOML_HAS_ATTR

#define TOML_HAS_ATTR

(

attr

)

0

TOML_HAS_BUILTIN

#define TOML_HAS_BUILTIN

(

name

)

0

TOML_HAS_CPP_ATTR

#define TOML_HAS_CPP_ATTR

(

attr

)

0

TOML_HAS_FEATURE

#define TOML_HAS_FEATURE

(

name

)

0

TOML_HAS_INCLUDE

#define TOML_HAS_INCLUDE

(

header

)

0

TOML_HIDDEN_CONSTRAINT

#define TOML_HIDDEN_CONSTRAINT	(		condition,
			...
	)

TOML_ICC

#define TOML_ICC   0

TOML_ICC_CL

#define TOML_ICC_CL   0

TOML_IMPL_NAMESPACE_END

#define TOML_IMPL_NAMESPACE_END   } TOML_NAMESPACE_END

TOML_IMPL_NAMESPACE_START

#define TOML_IMPL_NAMESPACE_START   TOML_NAMESPACE_START { namespace impl

TOML_INLINE_GETTER

#define TOML_INLINE_GETTER

Value:

    TOML_NODISCARD                                                                                                     \
    TOML_ALWAYS_INLINE

TOML_INT_CHARCONV [1/2]

#define TOML_INT_CHARCONV   1

TOML_INT_CHARCONV [2/2]

#define TOML_INT_CHARCONV   0

TOML_INTELLISENSE

#define TOML_INTELLISENSE   0

TOML_INTERNAL_LINKAGE

#define TOML_INTERNAL_LINKAGE   inline

TOML_LANG_AT_LEAST

#define TOML_LANG_AT_LEAST	(		major,
			minor,
			patch
	)		(TOML_LANG_EFFECTIVE_VERSION >= TOML_MAKE_VERSION(major, minor, patch))

TOML_LANG_EFFECTIVE_VERSION

#define TOML_LANG_EFFECTIVE_VERSION    TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)

TOML_LANG_HIGHER_THAN

#define TOML_LANG_HIGHER_THAN	(		major,
			minor,
			patch
	)		(TOML_LANG_EFFECTIVE_VERSION > TOML_MAKE_VERSION(major, minor, patch))

TOML_LANG_UNRELEASED

#define TOML_LANG_UNRELEASED    TOML_LANG_HIGHER_THAN(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)

TOML_LIB_SINGLE_HEADER

#define TOML_LIB_SINGLE_HEADER   0

TOML_LIKELY

#define TOML_LIKELY

(

...

)

(__VA_ARGS__)

TOML_LIKELY_CASE

#define TOML_LIKELY_CASE

TOML_LINUX

#define TOML_LINUX   0

TOML_MAKE_FLAGS

#define TOML_MAKE_FLAGS

(

T

)

TOML_MAKE_FLAGS_1(T, )

TOML_MAKE_FLAGS_1

#define TOML_MAKE_FLAGS_1	(		T,
			linkage
	)

Value:

    static_assert(std::is_enum_v<T>);                                                                                  \
                                                                                                                       \
    TOML_MAKE_FLAGS_2(T, &, linkage);                                                                                  \
    TOML_MAKE_FLAGS_2(T, |, linkage);                                                                                  \
    TOML_MAKE_FLAGS_2(T, ^, linkage);                                                                                  \
                                                                                                                       \
    TOML_CONST_INLINE_GETTER                                                                                           \
    linkage constexpr T operator~(T val) noexcept                                                                      \
    {                                                                                                                  \
        using under = std::underlying_type_t<T>;                                                                       \
        return static_cast<T>(~static_cast<under>(val));                                                               \
    }                                                                                                                  \
                                                                                                                       \
    TOML_CONST_INLINE_GETTER                                                                                           \
    linkage constexpr bool operator!(T val) noexcept                                                                   \
    {                                                                                                                  \
        using under = std::underlying_type_t<T>;                                                                       \
        return !static_cast<under>(val);                                                                               \
    }                                                                                                                  \
                                                                                                                       \
    static_assert(true)

TOML_MAKE_FLAGS_2

#define TOML_MAKE_FLAGS_2	(		T,
			op,
			linkage
	)

Value:

    TOML_CONST_INLINE_GETTER                                                                                           \
    linkage constexpr T operator op(T lhs, T rhs) noexcept                                                             \
    {                                                                                                                  \
        using under = std::underlying_type_t<T>;                                                                       \
        return static_cast<T>(static_cast<under>(lhs) op static_cast<under>(rhs));                                     \
    }                                                                                                                  \
                                                                                                                       \
    linkage constexpr T& operator TOML_CONCAT(op, =)(T & lhs, T rhs) noexcept                                          \
    {                                                                                                                  \
        return lhs = (lhs op rhs);                                                                                     \
    }                                                                                                                  \
                                                                                                                       \
    static_assert(true)

TOML_MAKE_STRING

#define TOML_MAKE_STRING

(

s

)

TOML_MAKE_STRING_1(s)

TOML_MAKE_STRING_1

#define TOML_MAKE_STRING_1

(

s

)

#s

TOML_MAKE_VERSION

#define TOML_MAKE_VERSION	(		major,
			minor,
			patch
	)		(((major)*10000) + ((minor)*100) + ((patch)))

TOML_MSVC

#define TOML_MSVC   0

TOML_MSVC_LIKE

#define TOML_MSVC_LIKE   0

TOML_NAMESPACE

#define TOML_NAMESPACE   ::toml::TOML_CONCAT(v, TOML_LIB_MAJOR)

TOML_NAMESPACE_END

#define TOML_NAMESPACE_END   } static_assert(true)

TOML_NAMESPACE_START

#define TOML_NAMESPACE_START   namespace toml { inline namespace TOML_CONCAT(v, TOML_LIB_MAJOR)

TOML_NEVER_INLINE

#define TOML_NEVER_INLINE

TOML_NODISCARD

#define TOML_NODISCARD

TOML_NODISCARD_CTOR

#define TOML_NODISCARD_CTOR

TOML_OPEN_ENUM

#define TOML_OPEN_ENUM

TOML_OPEN_FLAGS_ENUM

#define TOML_OPEN_FLAGS_ENUM   TOML_OPEN_ENUM TOML_FLAGS_ENUM

TOML_POP_WARNINGS

#define TOML_POP_WARNINGS   static_assert(true)

TOML_PRAGMA_CLANG

#define TOML_PRAGMA_CLANG

(

decl

)

TOML_PRAGMA_CLANG_GE_10

#define TOML_PRAGMA_CLANG_GE_10

(

decl

)

TOML_PRAGMA_CLANG_GE_11

#define TOML_PRAGMA_CLANG_GE_11

(

decl

)

TOML_PRAGMA_CLANG_GE_8

#define TOML_PRAGMA_CLANG_GE_8

(

decl

)

TOML_PRAGMA_CLANG_GE_9

#define TOML_PRAGMA_CLANG_GE_9

(

decl

)

TOML_PRAGMA_GCC

#define TOML_PRAGMA_GCC

(

decl

)

TOML_PRAGMA_ICC

#define TOML_PRAGMA_ICC

(

...

)

TOML_PRAGMA_MSVC

#define TOML_PRAGMA_MSVC

(

...

)

TOML_PURE

#define TOML_PURE

TOML_PURE_GETTER

#define TOML_PURE_GETTER

Value:

    TOML_NODISCARD                                                                                                     \
    TOML_PURE

TOML_PURE_INLINE_GETTER

#define TOML_PURE_INLINE_GETTER

Value:

    TOML_NODISCARD                                                                                                     \
    TOML_ALWAYS_INLINE                                                                                                 \
    TOML_PURE

TOML_PUSH_WARNINGS

#define TOML_PUSH_WARNINGS   static_assert(true)

TOML_SIMPLE_STATIC_ASSERT_MESSAGES

#define TOML_SIMPLE_STATIC_ASSERT_MESSAGES   0

TOML_TRIVIAL_ABI

#define TOML_TRIVIAL_ABI

TOML_UNIX

#define TOML_UNIX   0

TOML_UNLIKELY

#define TOML_UNLIKELY

(

...

)

(__VA_ARGS__)

TOML_UNLIKELY_CASE

#define TOML_UNLIKELY_CASE

TOML_UNREACHABLE

#define TOML_UNREACHABLE   static_cast<void>(0)

TOML_UNUSED

#define TOML_UNUSED

(

...

)

static_cast<void>(__VA_ARGS__)

TOML_WINDOWS

#define TOML_WINDOWS   0