NeBuild dev
Loading...
Searching...
No Matches
preprocessor.hpp
Go to the documentation of this file.
1//# This file is a part of toml++ and is subject to the the terms of the MIT license.
2//# Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
3//# See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
4// SPDX-License-Identifier: MIT
5#pragma once
6
7//#=====================================================================================================================
8//# C++ VERSION
9//#=====================================================================================================================
10
11#ifndef __cplusplus
12#error toml++ is a C++ library.
13#endif
14
15#ifndef TOML_CPP
16#ifdef _MSVC_LANG
17#if _MSVC_LANG > __cplusplus
18#define TOML_CPP _MSVC_LANG
19#endif
20#endif
21#ifndef TOML_CPP
22#define TOML_CPP __cplusplus
23#endif
24#if TOML_CPP >= 202900L
25#undef TOML_CPP
26#define TOML_CPP 29
27#elif TOML_CPP >= 202600L
28#undef TOML_CPP
29#define TOML_CPP 26
30#elif TOML_CPP >= 202302L
31#undef TOML_CPP
32#define TOML_CPP 23
33#elif TOML_CPP >= 202002L
34#undef TOML_CPP
35#define TOML_CPP 20
36#elif TOML_CPP >= 201703L
37#undef TOML_CPP
38#define TOML_CPP 17
39#elif TOML_CPP >= 201402L
40#undef TOML_CPP
41#define TOML_CPP 14
42#elif TOML_CPP >= 201103L
43#undef TOML_CPP
44#define TOML_CPP 11
45#else
46#undef TOML_CPP
47#define TOML_CPP 0
48#endif
49#endif
50
51#if !TOML_CPP
52#error toml++ requires C++17 or higher. For a pre-C++11 TOML library see https://github.com/ToruNiina/Boost.toml
53#elif TOML_CPP < 17
54#error toml++ requires C++17 or higher. For a C++11 TOML library see https://github.com/ToruNiina/toml11
55#endif
56
57//#=====================================================================================================================
58//# COMPILER
59//#=====================================================================================================================
60
61#ifndef TOML_MAKE_VERSION
62#define TOML_MAKE_VERSION(major, minor, patch) (((major)*10000) + ((minor)*100) + ((patch)))
63#endif
64
65#ifndef TOML_INTELLISENSE
66#ifdef __INTELLISENSE__
67#define TOML_INTELLISENSE 1
68#else
69#define TOML_INTELLISENSE 0
70#endif
71#endif
72
73#ifndef TOML_DOXYGEN
74#if defined(DOXYGEN) || defined(__DOXYGEN) || defined(__DOXYGEN__) || defined(__doxygen__) || defined(__POXY__) \
75 || defined(__poxy__)
76#define TOML_DOXYGEN 1
77#else
78#define TOML_DOXYGEN 0
79#endif
80#endif
81
82#ifndef TOML_CLANG
83#ifdef __clang__
84#define TOML_CLANG __clang_major__
85#else
86#define TOML_CLANG 0
87#endif
88
89// special handling for apple clang; see:
90// - https://github.com/marzer/tomlplusplus/issues/189
91// - https://en.wikipedia.org/wiki/Xcode
92// -
93// https://stackoverflow.com/questions/19387043/how-can-i-reliably-detect-the-version-of-clang-at-preprocessing-time
94#if TOML_CLANG && defined(__apple_build_version__)
95#undef TOML_CLANG
96#define TOML_CLANG_VERSION TOML_MAKE_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
97#if TOML_CLANG_VERSION >= TOML_MAKE_VERSION(15, 0, 0)
98#define TOML_CLANG 16
99#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(14, 3, 0)
100#define TOML_CLANG 15
101#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(14, 0, 0)
102#define TOML_CLANG 14
103#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(13, 1, 6)
104#define TOML_CLANG 13
105#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(13, 0, 0)
106#define TOML_CLANG 12
107#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(12, 0, 5)
108#define TOML_CLANG 11
109#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(12, 0, 0)
110#define TOML_CLANG 10
111#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(11, 0, 3)
112#define TOML_CLANG 9
113#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(11, 0, 0)
114#define TOML_CLANG 8
115#elif TOML_CLANG_VERSION >= TOML_MAKE_VERSION(10, 0, 1)
116#define TOML_CLANG 7
117#else
118#define TOML_CLANG 6 // not strictly correct but doesn't matter below this
119#endif
120#undef TOML_CLANG_VERSION
121#endif
122#endif
123
124#ifndef TOML_ICC
125#ifdef __INTEL_COMPILER
126#define TOML_ICC __INTEL_COMPILER
127#ifdef __ICL
128#define TOML_ICC_CL TOML_ICC
129#else
130#define TOML_ICC_CL 0
131#endif
132#else
133#define TOML_ICC 0
134#define TOML_ICC_CL 0
135#endif
136#endif
137
138#ifndef TOML_MSVC_LIKE
139#ifdef _MSC_VER
140#define TOML_MSVC_LIKE _MSC_VER
141#else
142#define TOML_MSVC_LIKE 0
143#endif
144#endif
145
146#ifndef TOML_MSVC
147#if TOML_MSVC_LIKE && !TOML_CLANG && !TOML_ICC
148#define TOML_MSVC TOML_MSVC_LIKE
149#else
150#define TOML_MSVC 0
151#endif
152#endif
153
154#ifndef TOML_GCC_LIKE
155#ifdef __GNUC__
156#define TOML_GCC_LIKE __GNUC__
157#else
158#define TOML_GCC_LIKE 0
159#endif
160#endif
161
162#ifndef TOML_GCC
163#if TOML_GCC_LIKE && !TOML_CLANG && !TOML_ICC
164#define TOML_GCC TOML_GCC_LIKE
165#else
166#define TOML_GCC 0
167#endif
168#endif
169
170#ifndef TOML_CUDA
171#if defined(__CUDACC__) || defined(__CUDA_ARCH__) || defined(__CUDA_LIBDEVICE__)
172#define TOML_CUDA 1
173#else
174#define TOML_CUDA 0
175#endif
176#endif
177
178//#=====================================================================================================================
179//# ARCHITECTURE
180//#=====================================================================================================================
181
182#ifndef TOML_ARCH_ITANIUM
183#if defined(__ia64__) || defined(__ia64) || defined(_IA64) || defined(__IA64__) || defined(_M_IA64)
184#define TOML_ARCH_ITANIUM 1
185#define TOML_ARCH_BITNESS 64
186#else
187#define TOML_ARCH_ITANIUM 0
188#endif
189#endif
190
191#ifndef TOML_ARCH_AMD64
192#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64)
193#define TOML_ARCH_AMD64 1
194#define TOML_ARCH_BITNESS 64
195#else
196#define TOML_ARCH_AMD64 0
197#endif
198#endif
199
200#ifndef TOML_ARCH_X86
201#if defined(__i386__) || defined(_M_IX86)
202#define TOML_ARCH_X86 1
203#define TOML_ARCH_BITNESS 32
204#else
205#define TOML_ARCH_X86 0
206#endif
207#endif
208
209#ifndef TOML_ARCH_ARM
210#if defined(__aarch64__) || defined(__ARM_ARCH_ISA_A64) || defined(_M_ARM64) || defined(__ARM_64BIT_STATE) \
211 || defined(_M_ARM64EC)
212#define TOML_ARCH_ARM32 0
213#define TOML_ARCH_ARM64 1
214#define TOML_ARCH_ARM 1
215#define TOML_ARCH_BITNESS 64
216#elif defined(__arm__) || defined(_M_ARM) || defined(__ARM_32BIT_STATE)
217#define TOML_ARCH_ARM32 1
218#define TOML_ARCH_ARM64 0
219#define TOML_ARCH_ARM 1
220#define TOML_ARCH_BITNESS 32
221#else
222#define TOML_ARCH_ARM32 0
223#define TOML_ARCH_ARM64 0
224#define TOML_ARCH_ARM 0
225#endif
226#endif
227
228#ifndef TOML_ARCH_BITNESS
229#define TOML_ARCH_BITNESS 0
230#endif
231
232#ifndef TOML_ARCH_X64
233#if TOML_ARCH_BITNESS == 64
234#define TOML_ARCH_X64 1
235#else
236#define TOML_ARCH_X64 0
237#endif
238#endif
239
240//#=====================================================================================================================
241//# OS
242//#=====================================================================================================================
243
244#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined(__CYGWIN__)
245#define TOML_WINDOWS 1
246#else
247#define TOML_WINDOWS 0
248#endif
249
250#ifdef __unix__
251#define TOML_UNIX 1
252#else
253#define TOML_UNIX 0
254#endif
255
256#ifdef __linux__
257#define TOML_LINUX 1
258#else
259#define TOML_LINUX 0
260#endif
261
262//#=====================================================================================================================
263//# ATTRIBUTES / FEATURE DETECTION / UTILITY MACROS
264//#=====================================================================================================================
265
266// TOML_HAS_INCLUDE
267#ifndef TOML_HAS_INCLUDE
268#ifdef __has_include
269#define TOML_HAS_INCLUDE(header) __has_include(header)
270#else
271#define TOML_HAS_INCLUDE(header) 0
272#endif
273#endif
274
275// TOML_HAS_BUILTIN
276#ifndef TOML_HAS_BUILTIN
277#ifdef __has_builtin
278#define TOML_HAS_BUILTIN(name) __has_builtin(name)
279#else
280#define TOML_HAS_BUILTIN(name) 0
281#endif
282#endif
283
284// TOML_HAS_FEATURE
285#ifndef TOML_HAS_FEATURE
286#ifdef __has_feature
287#define TOML_HAS_FEATURE(name) __has_feature(name)
288#else
289#define TOML_HAS_FEATURE(name) 0
290#endif
291#endif
292
293// TOML_HAS_ATTR
294#ifndef TOML_HAS_ATTR
295#ifdef __has_attribute
296#define TOML_HAS_ATTR(attr) __has_attribute(attr)
297#else
298#define TOML_HAS_ATTR(attr) 0
299#endif
300#endif
301
302// TOML_HAS_CPP_ATTR
303#ifndef TOML_HAS_CPP_ATTR
304#ifdef __has_cpp_attribute
305#define TOML_HAS_CPP_ATTR(attr) __has_cpp_attribute(attr)
306#else
307#define TOML_HAS_CPP_ATTR(attr) 0
308#endif
309#endif
310
311// TOML_ATTR (gnu attributes)
312#ifndef TOML_ATTR
313#if TOML_CLANG || TOML_GCC_LIKE
314#define TOML_ATTR(...) __attribute__((__VA_ARGS__))
315#else
316#define TOML_ATTR(...)
317#endif
318#endif
319
320// TOML_DECLSPEC (msvc attributes)
321#ifndef TOML_DECLSPEC
322#if TOML_MSVC_LIKE
323#define TOML_DECLSPEC(...) __declspec(__VA_ARGS__)
324#else
325#define TOML_DECLSPEC(...)
326#endif
327#endif
328
329// TOML_COMPILER_HAS_EXCEPTIONS
330#ifndef TOML_COMPILER_HAS_EXCEPTIONS
331#if defined(__EXCEPTIONS) || defined(_CPPUNWIND) || defined(__cpp_exceptions)
332#define TOML_COMPILER_HAS_EXCEPTIONS 1
333#else
334#define TOML_COMPILER_HAS_EXCEPTIONS 0
335#endif
336#endif
337
338// TOML_COMPILER_HAS_RTTI
339#ifndef TOML_COMPILER_HAS_RTTI
340#if defined(_CPPRTTI) || defined(__GXX_RTTI) || TOML_HAS_FEATURE(cxx_rtti)
341#define TOML_COMPILER_HAS_RTTI 1
342#else
343#define TOML_COMPILER_HAS_RTTI 0
344#endif
345#endif
346
347// TOML_CONCAT
348#define TOML_CONCAT_1(x, y) x##y
349#define TOML_CONCAT(x, y) TOML_CONCAT_1(x, y)
350
351// TOML_MAKE_STRING
352#define TOML_MAKE_STRING_1(s) #s
353#define TOML_MAKE_STRING(s) TOML_MAKE_STRING_1(s)
354
355// TOML_PRAGMA_XXXX (compiler-specific pragmas)
356#if TOML_CLANG
357#define TOML_PRAGMA_CLANG(decl) _Pragma(TOML_MAKE_STRING(clang decl))
358#else
359#define TOML_PRAGMA_CLANG(decl)
360#endif
361#if TOML_CLANG >= 8
362#define TOML_PRAGMA_CLANG_GE_8(decl) TOML_PRAGMA_CLANG(decl)
363#else
364#define TOML_PRAGMA_CLANG_GE_8(decl)
365#endif
366#if TOML_CLANG >= 9
367#define TOML_PRAGMA_CLANG_GE_9(decl) TOML_PRAGMA_CLANG(decl)
368#else
369#define TOML_PRAGMA_CLANG_GE_9(decl)
370#endif
371#if TOML_CLANG >= 10
372#define TOML_PRAGMA_CLANG_GE_10(decl) TOML_PRAGMA_CLANG(decl)
373#else
374#define TOML_PRAGMA_CLANG_GE_10(decl)
375#endif
376#if TOML_CLANG >= 11
377#define TOML_PRAGMA_CLANG_GE_11(decl) TOML_PRAGMA_CLANG(decl)
378#else
379#define TOML_PRAGMA_CLANG_GE_11(decl)
380#endif
381#if TOML_GCC
382#define TOML_PRAGMA_GCC(decl) _Pragma(TOML_MAKE_STRING(GCC decl))
383#else
384#define TOML_PRAGMA_GCC(decl)
385#endif
386#if TOML_MSVC
387#define TOML_PRAGMA_MSVC(...) __pragma(__VA_ARGS__)
388#else
389#define TOML_PRAGMA_MSVC(...)
390#endif
391#if TOML_ICC
392#define TOML_PRAGMA_ICC(...) __pragma(__VA_ARGS__)
393#else
394#define TOML_PRAGMA_ICC(...)
395#endif
396
397// TOML_ALWAYS_INLINE
398#ifdef _MSC_VER
399#define TOML_ALWAYS_INLINE __forceinline
400#elif TOML_GCC || TOML_CLANG || TOML_HAS_ATTR(__always_inline__)
401#define TOML_ALWAYS_INLINE \
402 TOML_ATTR(__always_inline__) \
403 inline
404#else
405#define TOML_ALWAYS_INLINE inline
406#endif
407
408// TOML_NEVER_INLINE
409#ifdef _MSC_VER
410#define TOML_NEVER_INLINE TOML_DECLSPEC(noinline)
411#elif TOML_CUDA // https://gitlab.gnome.org/GNOME/glib/-/issues/2555
412#define TOML_NEVER_INLINE TOML_ATTR(noinline)
413#else
414#if TOML_GCC || TOML_CLANG || TOML_HAS_ATTR(__noinline__)
415#define TOML_NEVER_INLINE TOML_ATTR(__noinline__)
416#endif
417#endif
418#ifndef TOML_NEVER_INLINE
419#define TOML_NEVER_INLINE
420#endif
421
422// MSVC attributes
423#define TOML_ABSTRACT_INTERFACE TOML_DECLSPEC(novtable)
424#define TOML_EMPTY_BASES TOML_DECLSPEC(empty_bases)
425
426// TOML_TRIVIAL_ABI
427#if TOML_CLANG || TOML_HAS_ATTR(__trivial_abi__)
428#define TOML_TRIVIAL_ABI TOML_ATTR(__trivial_abi__)
429#else
430#define TOML_TRIVIAL_ABI
431#endif
432
433// TOML_NODISCARD
434#if TOML_CPP >= 17 && TOML_HAS_CPP_ATTR(nodiscard) >= 201603
435#define TOML_NODISCARD [[nodiscard]]
436#elif TOML_CLANG || TOML_GCC || TOML_HAS_ATTR(__warn_unused_result__)
437#define TOML_NODISCARD TOML_ATTR(__warn_unused_result__)
438#else
439#define TOML_NODISCARD
440#endif
441
442// TOML_NODISCARD_CTOR
443#if TOML_CPP >= 17 && TOML_HAS_CPP_ATTR(nodiscard) >= 201907
444#define TOML_NODISCARD_CTOR [[nodiscard]]
445#else
446#define TOML_NODISCARD_CTOR
447#endif
448
449// pure + const
450#ifndef TOML_PURE
451#ifdef NDEBUG
452#define TOML_PURE \
453 TOML_DECLSPEC(noalias) \
454 TOML_ATTR(pure)
455#else
456#define TOML_PURE
457#endif
458#endif
459#ifndef TOML_CONST
460#ifdef NDEBUG
461#define TOML_CONST \
462 TOML_DECLSPEC(noalias) \
463 TOML_ATTR(const)
464#else
465#define TOML_CONST
466#endif
467#endif
468#ifndef TOML_INLINE_GETTER
469#define TOML_INLINE_GETTER \
470 TOML_NODISCARD \
471 TOML_ALWAYS_INLINE
472#endif
473#ifndef TOML_PURE_GETTER
474#define TOML_PURE_GETTER \
475 TOML_NODISCARD \
476 TOML_PURE
477#endif
478#ifndef TOML_PURE_INLINE_GETTER
479#define TOML_PURE_INLINE_GETTER \
480 TOML_NODISCARD \
481 TOML_ALWAYS_INLINE \
482 TOML_PURE
483#endif
484#ifndef TOML_CONST_GETTER
485#define TOML_CONST_GETTER \
486 TOML_NODISCARD \
487 TOML_CONST
488#endif
489#ifndef TOML_CONST_INLINE_GETTER
490#define TOML_CONST_INLINE_GETTER \
491 TOML_NODISCARD \
492 TOML_ALWAYS_INLINE \
493 TOML_CONST
494#endif
495
496// TOML_ASSUME
497#ifdef _MSC_VER
498#define TOML_ASSUME(expr) __assume(expr)
499#elif TOML_ICC || TOML_CLANG || TOML_HAS_BUILTIN(__builtin_assume)
500#define TOML_ASSUME(expr) __builtin_assume(expr)
501#elif TOML_HAS_CPP_ATTR(assume) >= 202207
502#define TOML_ASSUME(expr) [[assume(expr)]]
503#elif TOML_HAS_ATTR(__assume__)
504#define TOML_ASSUME(expr) __attribute__((__assume__(expr)))
505#else
506#define TOML_ASSUME(expr) static_cast<void>(0)
507#endif
508
509// TOML_UNREACHABLE
510#ifdef _MSC_VER
511#define TOML_UNREACHABLE __assume(0)
512#elif TOML_ICC || TOML_CLANG || TOML_GCC || TOML_HAS_BUILTIN(__builtin_unreachable)
513#define TOML_UNREACHABLE __builtin_unreachable()
514#else
515#define TOML_UNREACHABLE static_cast<void>(0)
516#endif
517
518// TOML_LIKELY
519#if TOML_CPP >= 20 && TOML_HAS_CPP_ATTR(likely) >= 201803
520#define TOML_LIKELY(...) (__VA_ARGS__) [[likely]]
521#define TOML_LIKELY_CASE [[likely]]
522#elif TOML_GCC || TOML_CLANG || TOML_HAS_BUILTIN(__builtin_expect)
523#define TOML_LIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 1))
524#else
525#define TOML_LIKELY(...) (__VA_ARGS__)
526#endif
527#ifndef TOML_LIKELY_CASE
528#define TOML_LIKELY_CASE
529#endif
530
531// TOML_UNLIKELY
532#if TOML_CPP >= 20 && TOML_HAS_CPP_ATTR(unlikely) >= 201803
533#define TOML_UNLIKELY(...) (__VA_ARGS__) [[unlikely]]
534#define TOML_UNLIKELY_CASE [[unlikely]]
535#elif TOML_GCC || TOML_CLANG || TOML_HAS_BUILTIN(__builtin_expect)
536#define TOML_UNLIKELY(...) (__builtin_expect(!!(__VA_ARGS__), 0))
537#else
538#define TOML_UNLIKELY(...) (__VA_ARGS__)
539#endif
540#ifndef TOML_UNLIKELY_CASE
541#define TOML_UNLIKELY_CASE
542#endif
543
544// TOML_FLAGS_ENUM
545#if TOML_CLANG || TOML_HAS_ATTR(flag_enum)
546#define TOML_FLAGS_ENUM __attribute__((flag_enum))
547#else
548#define TOML_FLAGS_ENUM
549#endif
550
551// TOML_OPEN_ENUM + TOML_CLOSED_ENUM
552#if TOML_CLANG || TOML_HAS_ATTR(enum_extensibility)
553#define TOML_OPEN_ENUM __attribute__((enum_extensibility(open)))
554#define TOML_CLOSED_ENUM __attribute__((enum_extensibility(closed)))
555#else
556#define TOML_OPEN_ENUM
557#define TOML_CLOSED_ENUM
558#endif
559
560// TOML_OPEN_FLAGS_ENUM + TOML_CLOSED_FLAGS_ENUM
561#define TOML_OPEN_FLAGS_ENUM TOML_OPEN_ENUM TOML_FLAGS_ENUM
562#define TOML_CLOSED_FLAGS_ENUM TOML_CLOSED_ENUM TOML_FLAGS_ENUM
563
564// TOML_MAKE_FLAGS
565#define TOML_MAKE_FLAGS_2(T, op, linkage) \
566 TOML_CONST_INLINE_GETTER \
567 linkage constexpr T operator op(T lhs, T rhs) noexcept \
568 { \
569 using under = std::underlying_type_t<T>; \
570 return static_cast<T>(static_cast<under>(lhs) op static_cast<under>(rhs)); \
571 } \
572 \
573 linkage constexpr T& operator TOML_CONCAT(op, =)(T & lhs, T rhs) noexcept \
574 { \
575 return lhs = (lhs op rhs); \
576 } \
577 \
578 static_assert(true)
579#define TOML_MAKE_FLAGS_1(T, linkage) \
580 static_assert(std::is_enum_v<T>); \
581 \
582 TOML_MAKE_FLAGS_2(T, &, linkage); \
583 TOML_MAKE_FLAGS_2(T, |, linkage); \
584 TOML_MAKE_FLAGS_2(T, ^, linkage); \
585 \
586 TOML_CONST_INLINE_GETTER \
587 linkage constexpr T operator~(T val) noexcept \
588 { \
589 using under = std::underlying_type_t<T>; \
590 return static_cast<T>(~static_cast<under>(val)); \
591 } \
592 \
593 TOML_CONST_INLINE_GETTER \
594 linkage constexpr bool operator!(T val) noexcept \
595 { \
596 using under = std::underlying_type_t<T>; \
597 return !static_cast<under>(val); \
598 } \
599 \
600 static_assert(true)
601#define TOML_MAKE_FLAGS(T) TOML_MAKE_FLAGS_1(T, )
602
603#define TOML_UNUSED(...) static_cast<void>(__VA_ARGS__)
604
605#define TOML_DELETE_DEFAULTS(T) \
606 T(const T&) = delete; \
607 T(T&&) = delete; \
608 T& operator=(const T&) = delete; \
609 T& operator=(T&&) = delete
610
611#define TOML_ASYMMETRICAL_EQUALITY_OPS(LHS, RHS, ...) \
612 __VA_ARGS__ TOML_NODISCARD \
613 friend bool operator==(RHS rhs, LHS lhs) noexcept \
614 { \
615 return lhs == rhs; \
616 } \
617 __VA_ARGS__ TOML_NODISCARD \
618 friend bool operator!=(LHS lhs, RHS rhs) noexcept \
619 { \
620 return !(lhs == rhs); \
621 } \
622 __VA_ARGS__ TOML_NODISCARD \
623 friend bool operator!=(RHS rhs, LHS lhs) noexcept \
624 { \
625 return !(lhs == rhs); \
626 } \
627 static_assert(true)
628
629#define TOML_EVAL_BOOL_1(T, F) T
630#define TOML_EVAL_BOOL_0(T, F) F
631
632#if !defined(__POXY__) && !defined(POXY_IMPLEMENTATION_DETAIL)
633#define POXY_IMPLEMENTATION_DETAIL(...) __VA_ARGS__
634#endif
635
636//======================================================================================================================
637// COMPILER-SPECIFIC WARNING MANAGEMENT
638//======================================================================================================================
639
640#if TOML_CLANG
641
642#define TOML_PUSH_WARNINGS \
643 TOML_PRAGMA_CLANG(diagnostic push) \
644 TOML_PRAGMA_CLANG(diagnostic ignored "-Wunknown-warning-option") \
645 static_assert(true)
646
647#define TOML_DISABLE_SWITCH_WARNINGS \
648 TOML_PRAGMA_CLANG(diagnostic ignored "-Wswitch") \
649 static_assert(true)
650
651#define TOML_DISABLE_ARITHMETIC_WARNINGS \
652 TOML_PRAGMA_CLANG_GE_10(diagnostic ignored "-Wimplicit-int-float-conversion") \
653 TOML_PRAGMA_CLANG(diagnostic ignored "-Wfloat-equal") \
654 TOML_PRAGMA_CLANG(diagnostic ignored "-Wdouble-promotion") \
655 TOML_PRAGMA_CLANG(diagnostic ignored "-Wchar-subscripts") \
656 TOML_PRAGMA_CLANG(diagnostic ignored "-Wshift-sign-overflow") \
657 static_assert(true)
658
659#define TOML_DISABLE_SPAM_WARNINGS \
660 TOML_PRAGMA_CLANG_GE_8(diagnostic ignored "-Wdefaulted-function-deleted") \
661 TOML_PRAGMA_CLANG_GE_9(diagnostic ignored "-Wctad-maybe-unsupported") \
662 TOML_PRAGMA_CLANG_GE_10(diagnostic ignored "-Wzero-as-null-pointer-constant") \
663 TOML_PRAGMA_CLANG_GE_11(diagnostic ignored "-Wsuggest-destructor-override") \
664 TOML_PRAGMA_CLANG(diagnostic ignored "-Wweak-vtables") \
665 TOML_PRAGMA_CLANG(diagnostic ignored "-Wweak-template-vtables") \
666 TOML_PRAGMA_CLANG(diagnostic ignored "-Wdouble-promotion") \
667 TOML_PRAGMA_CLANG(diagnostic ignored "-Wchar-subscripts") \
668 TOML_PRAGMA_CLANG(diagnostic ignored "-Wmissing-field-initializers") \
669 TOML_PRAGMA_CLANG(diagnostic ignored "-Wpadded") \
670 static_assert(true)
671
672#define TOML_POP_WARNINGS \
673 TOML_PRAGMA_CLANG(diagnostic pop) \
674 static_assert(true)
675
676#define TOML_DISABLE_WARNINGS \
677 TOML_PRAGMA_CLANG(diagnostic push) \
678 TOML_PRAGMA_CLANG(diagnostic ignored "-Weverything") \
679 static_assert(true, "")
680
681#define TOML_ENABLE_WARNINGS \
682 TOML_PRAGMA_CLANG(diagnostic pop) \
683 static_assert(true)
684
685#define TOML_SIMPLE_STATIC_ASSERT_MESSAGES 1
686
687#elif TOML_MSVC
688
689#define TOML_PUSH_WARNINGS \
690 __pragma(warning(push)) \
691 static_assert(true)
692
693#if TOML_HAS_INCLUDE(<CodeAnalysis/Warnings.h>)
694#pragma warning(push, 0)
695#include <CodeAnalysis/Warnings.h>
696#pragma warning(pop)
697#define TOML_DISABLE_CODE_ANALYSIS_WARNINGS \
698 __pragma(warning(disable : ALL_CODE_ANALYSIS_WARNINGS)) \
699 static_assert(true)
700#else
701#define TOML_DISABLE_CODE_ANALYSIS_WARNINGS static_assert(true)
702#endif
703
704#define TOML_DISABLE_SWITCH_WARNINGS \
705 __pragma(warning(disable : 4061)) \
706 __pragma(warning(disable : 4062)) \
707 __pragma(warning(disable : 4063)) \
708 __pragma(warning(disable : 5262)) /* switch-case implicit fallthrough (false-positive) */ \
709 __pragma(warning(disable : 26819)) /* cg: unannotated fallthrough */ \
710 static_assert(true)
711
712#define TOML_DISABLE_SPAM_WARNINGS \
713 __pragma(warning(disable : 4127)) /* conditional expr is constant */ \
714 __pragma(warning(disable : 4324)) /* structure was padded due to alignment specifier */ \
715 __pragma(warning(disable : 4348)) \
716 __pragma(warning(disable : 4464)) /* relative include path contains '..' */ \
717 __pragma(warning(disable : 4505)) /* unreferenced local function removed */ \
718 __pragma(warning(disable : 4514)) /* unreferenced inline function has been removed */ \
719 __pragma(warning(disable : 4582)) /* constructor is not implicitly called */ \
720 __pragma(warning(disable : 4619)) /* there is no warning number 'XXXX' */ \
721 __pragma(warning(disable : 4623)) /* default constructor was implicitly defined as deleted */ \
722 __pragma(warning(disable : 4625)) /* copy constructor was implicitly defined as deleted */ \
723 __pragma(warning(disable : 4626)) /* assignment operator was implicitly defined as deleted */ \
724 __pragma(warning(disable : 4710)) /* function not inlined */ \
725 __pragma(warning(disable : 4711)) /* function selected for automatic expansion */ \
726 __pragma(warning(disable : 4820)) /* N bytes padding added */ \
727 __pragma(warning(disable : 4946)) /* reinterpret_cast used between related classes */ \
728 __pragma(warning(disable : 5026)) /* move constructor was implicitly defined as deleted */ \
729 __pragma(warning(disable : 5027)) /* move assignment operator was implicitly defined as deleted */ \
730 __pragma(warning(disable : 5039)) /* potentially throwing function passed to 'extern "C"' function */ \
731 __pragma(warning(disable : 5045)) /* Compiler will insert Spectre mitigation */ \
732 __pragma(warning(disable : 5264)) /* const variable is not used (false-positive) */ \
733 __pragma(warning(disable : 26451)) \
734 __pragma(warning(disable : 26490)) \
735 __pragma(warning(disable : 26495)) \
736 __pragma(warning(disable : 26812)) \
737 __pragma(warning(disable : 26819)) \
738 static_assert(true)
739
740#define TOML_DISABLE_ARITHMETIC_WARNINGS \
741 __pragma(warning(disable : 4365)) /* argument signed/unsigned mismatch */ \
742 __pragma(warning(disable : 4738)) /* storing 32-bit float result in memory */ \
743 __pragma(warning(disable : 5219)) /* implicit conversion from integral to float */ \
744 static_assert(true)
745
746#define TOML_POP_WARNINGS \
747 __pragma(warning(pop)) \
748 static_assert(true)
749
750#define TOML_DISABLE_WARNINGS \
751 __pragma(warning(push, 0)) \
752 __pragma(warning(disable : 4348)) \
753 __pragma(warning(disable : 4668)) \
754 __pragma(warning(disable : 5105)) \
755 __pragma(warning(disable : 5264)) \
756 TOML_DISABLE_CODE_ANALYSIS_WARNINGS; \
757 TOML_DISABLE_SWITCH_WARNINGS; \
758 TOML_DISABLE_SPAM_WARNINGS; \
759 TOML_DISABLE_ARITHMETIC_WARNINGS; \
760 static_assert(true)
761
762#define TOML_ENABLE_WARNINGS TOML_POP_WARNINGS
763
764#elif TOML_ICC
765
766#define TOML_PUSH_WARNINGS \
767 __pragma(warning(push)) \
768 static_assert(true)
769
770#define TOML_DISABLE_SPAM_WARNINGS \
771 __pragma(warning(disable : 82)) /* storage class is not first */ \
772 __pragma(warning(disable : 111)) /* statement unreachable (false-positive) */ \
773 __pragma(warning(disable : 869)) /* unreferenced parameter */ \
774 __pragma(warning(disable : 1011)) /* missing return (false-positive) */ \
775 __pragma(warning(disable : 2261)) /* assume expr side-effects discarded */ \
776 static_assert(true)
777
778#define TOML_POP_WARNINGS \
779 __pragma(warning(pop)) \
780 static_assert(true)
781
782#define TOML_DISABLE_WARNINGS \
783 __pragma(warning(push, 0)) \
784 TOML_DISABLE_SPAM_WARNINGS
785
786#define TOML_ENABLE_WARNINGS \
787 __pragma(warning(pop)) \
788 static_assert(true)
789
790#elif TOML_GCC
791
792#define TOML_PUSH_WARNINGS \
793 TOML_PRAGMA_GCC(diagnostic push) \
794 static_assert(true)
795
796#define TOML_DISABLE_SWITCH_WARNINGS \
797 TOML_PRAGMA_GCC(diagnostic ignored "-Wswitch") \
798 TOML_PRAGMA_GCC(diagnostic ignored "-Wswitch-enum") \
799 TOML_PRAGMA_GCC(diagnostic ignored "-Wswitch-default") \
800 static_assert(true)
801
802#define TOML_DISABLE_ARITHMETIC_WARNINGS \
803 TOML_PRAGMA_GCC(diagnostic ignored "-Wfloat-equal") \
804 TOML_PRAGMA_GCC(diagnostic ignored "-Wsign-conversion") \
805 TOML_PRAGMA_GCC(diagnostic ignored "-Wchar-subscripts") \
806 static_assert(true)
807
808#define TOML_DISABLE_SUGGEST_ATTR_WARNINGS \
809 TOML_PRAGMA_GCC(diagnostic ignored "-Wsuggest-attribute=const") \
810 TOML_PRAGMA_GCC(diagnostic ignored "-Wsuggest-attribute=pure") \
811 static_assert(true)
812
813#define TOML_DISABLE_SPAM_WARNINGS \
814 TOML_PRAGMA_GCC(diagnostic ignored "-Wpadded") \
815 TOML_PRAGMA_GCC(diagnostic ignored "-Wcast-align") \
816 TOML_PRAGMA_GCC(diagnostic ignored "-Wcomment") \
817 TOML_PRAGMA_GCC(diagnostic ignored "-Wtype-limits") \
818 TOML_PRAGMA_GCC(diagnostic ignored "-Wuseless-cast") \
819 TOML_PRAGMA_GCC(diagnostic ignored "-Wchar-subscripts") \
820 TOML_PRAGMA_GCC(diagnostic ignored "-Wsubobject-linkage") \
821 TOML_PRAGMA_GCC(diagnostic ignored "-Wmissing-field-initializers") \
822 TOML_PRAGMA_GCC(diagnostic ignored "-Wmaybe-uninitialized") \
823 TOML_PRAGMA_GCC(diagnostic ignored "-Wnoexcept") \
824 TOML_PRAGMA_GCC(diagnostic ignored "-Wnull-dereference") \
825 TOML_PRAGMA_GCC(diagnostic ignored "-Wduplicated-branches") \
826 static_assert(true)
827
828#define TOML_POP_WARNINGS \
829 TOML_PRAGMA_GCC(diagnostic pop) \
830 static_assert(true)
831
832#define TOML_DISABLE_WARNINGS \
833 TOML_PRAGMA_GCC(diagnostic push) \
834 TOML_PRAGMA_GCC(diagnostic ignored "-Wall") \
835 TOML_PRAGMA_GCC(diagnostic ignored "-Wextra") \
836 TOML_PRAGMA_GCC(diagnostic ignored "-Wpedantic") \
837 TOML_DISABLE_SWITCH_WARNINGS; \
838 TOML_DISABLE_ARITHMETIC_WARNINGS; \
839 TOML_DISABLE_SUGGEST_ATTR_WARNINGS; \
840 TOML_DISABLE_SPAM_WARNINGS; \
841 static_assert(true)
842
843#define TOML_ENABLE_WARNINGS \
844 TOML_PRAGMA_GCC(diagnostic pop) \
845 static_assert(true)
846
847#endif
848
849#ifndef TOML_PUSH_WARNINGS
850#define TOML_PUSH_WARNINGS static_assert(true)
851#endif
852#ifndef TOML_DISABLE_CODE_ANALYSIS_WARNINGS
853#define TOML_DISABLE_CODE_ANALYSIS_WARNINGS static_assert(true)
854#endif
855#ifndef TOML_DISABLE_SWITCH_WARNINGS
856#define TOML_DISABLE_SWITCH_WARNINGS static_assert(true)
857#endif
858#ifndef TOML_DISABLE_SUGGEST_ATTR_WARNINGS
859#define TOML_DISABLE_SUGGEST_ATTR_WARNINGS static_assert(true)
860#endif
861#ifndef TOML_DISABLE_SPAM_WARNINGS
862#define TOML_DISABLE_SPAM_WARNINGS static_assert(true)
863#endif
864#ifndef TOML_DISABLE_ARITHMETIC_WARNINGS
865#define TOML_DISABLE_ARITHMETIC_WARNINGS static_assert(true)
866#endif
867#ifndef TOML_POP_WARNINGS
868#define TOML_POP_WARNINGS static_assert(true)
869#endif
870#ifndef TOML_DISABLE_WARNINGS
871#define TOML_DISABLE_WARNINGS static_assert(true)
872#endif
873#ifndef TOML_ENABLE_WARNINGS
874#define TOML_ENABLE_WARNINGS static_assert(true)
875#endif
876#ifndef TOML_SIMPLE_STATIC_ASSERT_MESSAGES
877#define TOML_SIMPLE_STATIC_ASSERT_MESSAGES 0
878#endif
879
880//#====================================================================================================================
881//# USER CONFIGURATION
882//#====================================================================================================================
889
890#ifdef TOML_CONFIG_HEADER
891#include TOML_CONFIG_HEADER
892#endif
893//# {{
894#if TOML_DOXYGEN
895#define TOML_CONFIG_HEADER
896#endif
900//# }}
901
902// is the library being built as a shared lib/dll using meson and friends?
903#ifndef TOML_SHARED_LIB
904#define TOML_SHARED_LIB 0
905#endif
906
907// header-only mode
908#if !defined(TOML_HEADER_ONLY) && defined(TOML_ALL_INLINE) // was TOML_ALL_INLINE pre-2.0
909#define TOML_HEADER_ONLY TOML_ALL_INLINE
910#endif
911#if !defined(TOML_HEADER_ONLY) || (defined(TOML_HEADER_ONLY) && TOML_HEADER_ONLY) || TOML_INTELLISENSE
912#undef TOML_HEADER_ONLY
913#define TOML_HEADER_ONLY 1
914#endif
915#if TOML_DOXYGEN || TOML_SHARED_LIB
916#undef TOML_HEADER_ONLY
917#define TOML_HEADER_ONLY 0
918#endif
933
934// internal implementation switch
935#if defined(TOML_IMPLEMENTATION) || TOML_HEADER_ONLY
936#undef TOML_IMPLEMENTATION
937#define TOML_IMPLEMENTATION 1
938#else
939#define TOML_IMPLEMENTATION 0
940#endif
944
945// dll/shared lib function exports (legacy - TOML_API was the old name for this setting)
946#if !defined(TOML_EXPORTED_MEMBER_FUNCTION) && !defined(TOML_EXPORTED_STATIC_FUNCTION) \
947 && !defined(TOML_EXPORTED_FREE_FUNCTION) && !defined(TOML_EXPORTED_CLASS) && defined(TOML_API)
948#define TOML_EXPORTED_MEMBER_FUNCTION TOML_API
949#define TOML_EXPORTED_STATIC_FUNCTION TOML_API
950#define TOML_EXPORTED_FREE_FUNCTION TOML_API
951#endif
952
953// dll/shared lib exports
954#if TOML_SHARED_LIB
955#undef TOML_API
956#undef TOML_EXPORTED_CLASS
957#undef TOML_EXPORTED_MEMBER_FUNCTION
958#undef TOML_EXPORTED_STATIC_FUNCTION
959#undef TOML_EXPORTED_FREE_FUNCTION
960#if TOML_WINDOWS
961#if TOML_IMPLEMENTATION
962#define TOML_EXPORTED_CLASS __declspec(dllexport)
963#define TOML_EXPORTED_FREE_FUNCTION __declspec(dllexport)
964#else
965#define TOML_EXPORTED_CLASS __declspec(dllimport)
966#define TOML_EXPORTED_FREE_FUNCTION __declspec(dllimport)
967#endif
968#ifndef TOML_CALLCONV
969#define TOML_CALLCONV __cdecl
970#endif
971#elif defined(__GNUC__) && __GNUC__ >= 4
972#define TOML_EXPORTED_CLASS __attribute__((visibility("default")))
973#define TOML_EXPORTED_MEMBER_FUNCTION __attribute__((visibility("default")))
974#define TOML_EXPORTED_STATIC_FUNCTION __attribute__((visibility("default")))
975#define TOML_EXPORTED_FREE_FUNCTION __attribute__((visibility("default")))
976#endif
977#endif
978#ifndef TOML_EXPORTED_CLASS
979#define TOML_EXPORTED_CLASS
980#endif
981#ifndef TOML_EXPORTED_MEMBER_FUNCTION
982#define TOML_EXPORTED_MEMBER_FUNCTION
983#endif
984#ifndef TOML_EXPORTED_STATIC_FUNCTION
985#define TOML_EXPORTED_STATIC_FUNCTION
986#endif
987#ifndef TOML_EXPORTED_FREE_FUNCTION
988#define TOML_EXPORTED_FREE_FUNCTION
989#endif
1013
1014// experimental language features
1015#if !defined(TOML_ENABLE_UNRELEASED_FEATURES) && defined(TOML_UNRELEASED_FEATURES) // was TOML_UNRELEASED_FEATURES
1016 // pre-3.0
1017#define TOML_ENABLE_UNRELEASED_FEATURES TOML_UNRELEASED_FEATURES
1018#endif
1019#if (defined(TOML_ENABLE_UNRELEASED_FEATURES) && TOML_ENABLE_UNRELEASED_FEATURES) || TOML_INTELLISENSE
1020#undef TOML_ENABLE_UNRELEASED_FEATURES
1021#define TOML_ENABLE_UNRELEASED_FEATURES 1
1022#endif
1023#ifndef TOML_ENABLE_UNRELEASED_FEATURES
1024#define TOML_ENABLE_UNRELEASED_FEATURES 0
1025#endif
1031
1032// parser
1033#if !defined(TOML_ENABLE_PARSER) && defined(TOML_PARSER) // was TOML_PARSER pre-3.0
1034#define TOML_ENABLE_PARSER TOML_PARSER
1035#endif
1036#if !defined(TOML_ENABLE_PARSER) || (defined(TOML_ENABLE_PARSER) && TOML_ENABLE_PARSER) || TOML_INTELLISENSE
1037#undef TOML_ENABLE_PARSER
1038#define TOML_ENABLE_PARSER 1
1039#endif
1045
1046// formatters
1047#if !defined(TOML_ENABLE_FORMATTERS) || (defined(TOML_ENABLE_FORMATTERS) && TOML_ENABLE_FORMATTERS) || TOML_INTELLISENSE
1048#undef TOML_ENABLE_FORMATTERS
1049#define TOML_ENABLE_FORMATTERS 1
1050#endif
1060
1061// SIMD
1062#if !defined(TOML_ENABLE_SIMD) || (defined(TOML_ENABLE_SIMD) && TOML_ENABLE_SIMD) || TOML_INTELLISENSE
1063#undef TOML_ENABLE_SIMD
1064#define TOML_ENABLE_SIMD 1
1065#endif
1066
1067// windows compat
1068#if !defined(TOML_ENABLE_WINDOWS_COMPAT) && defined(TOML_WINDOWS_COMPAT) // was TOML_WINDOWS_COMPAT pre-3.0
1069#define TOML_ENABLE_WINDOWS_COMPAT TOML_WINDOWS_COMPAT
1070#endif
1071#if !defined(TOML_ENABLE_WINDOWS_COMPAT) || (defined(TOML_ENABLE_WINDOWS_COMPAT) && TOML_ENABLE_WINDOWS_COMPAT) \
1072 || TOML_INTELLISENSE
1073#undef TOML_ENABLE_WINDOWS_COMPAT
1074#define TOML_ENABLE_WINDOWS_COMPAT 1
1075#endif
1077#if !TOML_WINDOWS
1078#undef TOML_ENABLE_WINDOWS_COMPAT
1079#define TOML_ENABLE_WINDOWS_COMPAT 0
1080#endif
1082#ifndef TOML_INCLUDE_WINDOWS_H
1083#define TOML_INCLUDE_WINDOWS_H 0
1084#endif
1096
1097// custom optional
1098#ifdef TOML_OPTIONAL_TYPE
1099#define TOML_HAS_CUSTOM_OPTIONAL_TYPE 1
1100#else
1101#define TOML_HAS_CUSTOM_OPTIONAL_TYPE 0
1102#endif
1103//# {{
1104#if TOML_DOXYGEN
1105#define TOML_OPTIONAL_TYPE
1106#endif
1113//# }}
1114
1115// exceptions (library use)
1116#if TOML_COMPILER_HAS_EXCEPTIONS
1117#if !defined(TOML_EXCEPTIONS) || (defined(TOML_EXCEPTIONS) && TOML_EXCEPTIONS)
1118#undef TOML_EXCEPTIONS
1119#define TOML_EXCEPTIONS 1
1120#endif
1121#else
1122#if defined(TOML_EXCEPTIONS) && TOML_EXCEPTIONS
1123#error TOML_EXCEPTIONS was explicitly enabled but exceptions are disabled/unsupported by the compiler.
1124#endif
1125#undef TOML_EXCEPTIONS
1126#define TOML_EXCEPTIONS 0
1127#endif
1131
1132// calling convention for static/free/friend functions
1133#ifndef TOML_CALLCONV
1134#define TOML_CALLCONV
1135#endif
1139
1140//# {{
1141#if TOML_DOXYGEN
1142#define TOML_SMALL_FLOAT_TYPE
1143#endif
1147//# }}
1148
1149#ifndef TOML_UNDEF_MACROS
1150#define TOML_UNDEF_MACROS 1
1151#endif
1152
1153#ifndef TOML_MAX_NESTED_VALUES
1154#define TOML_MAX_NESTED_VALUES 256
1155// this refers to the depth of nested values, e.g. inline tables and arrays.
1156// 256 is crazy high! if you're hitting this limit with real input, TOML is probably the wrong tool for the job...
1157#endif
1158
1159#ifdef TOML_CHAR_8_STRINGS
1160#if TOML_CHAR_8_STRINGS
1161#error TOML_CHAR_8_STRINGS was removed in toml++ 2.0.0; all value setters and getters now work with char8_t strings implicitly.
1162#endif
1163#endif
1164
1165#ifdef TOML_LARGE_FILES
1166#if !TOML_LARGE_FILES
1167#error Support for !TOML_LARGE_FILES (i.e. 'small files') was removed in toml++ 3.0.0.
1168#endif
1169#endif
1170
1171#ifndef TOML_LIFETIME_HOOKS
1172#define TOML_LIFETIME_HOOKS 0
1173#endif
1174
1175#ifdef NDEBUG
1176#undef TOML_ASSERT
1177#define TOML_ASSERT(expr) static_assert(true)
1178#endif
1179#ifndef TOML_ASSERT
1180#ifndef assert
1181TOML_DISABLE_WARNINGS;
1182#include <cassert>
1183TOML_ENABLE_WARNINGS;
1184#endif
1185#define TOML_ASSERT(expr) assert(expr)
1186#endif
1187#ifdef NDEBUG
1188#define TOML_ASSERT_ASSUME(expr) TOML_ASSUME(expr)
1189#else
1190#define TOML_ASSERT_ASSUME(expr) TOML_ASSERT(expr)
1191#endif
1195
1196//# {{
1197#if TOML_DOXYGEN
1198#define TOML_SMALL_INT_TYPE
1199#endif
1203//# }}
1204
1205#ifndef TOML_ENABLE_FLOAT16
1206#define TOML_ENABLE_FLOAT16 0
1207#endif
1208//# {{
1212//# }}
1213
1215//#====================================================================================================================
1216//# CHARCONV SUPPORT
1217//#====================================================================================================================
1218
1219#if !defined(TOML_FLOAT_CHARCONV) && (TOML_GCC || TOML_CLANG || (TOML_ICC && !TOML_ICC_CL))
1220// not supported by any version of GCC or Clang as of 26/11/2020
1221// not supported by any version of ICC on Linux as of 11/01/2021
1222#define TOML_FLOAT_CHARCONV 0
1223#endif
1224#if !defined(TOML_INT_CHARCONV) && (defined(__EMSCRIPTEN__) || defined(__APPLE__))
1225// causes link errors on emscripten
1226// causes Mac OS SDK version errors on some versions of Apple Clang
1227#define TOML_INT_CHARCONV 0
1228#endif
1229#ifndef TOML_INT_CHARCONV
1230#define TOML_INT_CHARCONV 1
1231#endif
1232#ifndef TOML_FLOAT_CHARCONV
1233#define TOML_FLOAT_CHARCONV 1
1234#endif
1235#if (TOML_INT_CHARCONV || TOML_FLOAT_CHARCONV) && !TOML_HAS_INCLUDE(<charconv>)
1236#undef TOML_INT_CHARCONV
1237#undef TOML_FLOAT_CHARCONV
1238#define TOML_INT_CHARCONV 0
1239#define TOML_FLOAT_CHARCONV 0
1240#endif
1241
1242//#=====================================================================================================================
1243//# SFINAE
1244//#=====================================================================================================================
1245
1247#if defined(__cpp_concepts) && __cpp_concepts >= 201907
1248#define TOML_REQUIRES(...) requires(__VA_ARGS__)
1249#else
1250#define TOML_REQUIRES(...)
1251#endif
1252#define TOML_ENABLE_IF(...) , typename std::enable_if<(__VA_ARGS__), int>::type = 0
1253#define TOML_CONSTRAINED_TEMPLATE(condition, ...) \
1254 template <__VA_ARGS__ TOML_ENABLE_IF(condition)> \
1255 TOML_REQUIRES(condition)
1256#define TOML_HIDDEN_CONSTRAINT(condition, ...) TOML_CONSTRAINED_TEMPLATE(condition, __VA_ARGS__)
1258//# {{
1259#ifndef TOML_CONSTRAINED_TEMPLATE
1260#define TOML_CONSTRAINED_TEMPLATE(condition, ...) template <__VA_ARGS__>
1261#endif
1262#ifndef TOML_HIDDEN_CONSTRAINT
1263#define TOML_HIDDEN_CONSTRAINT(condition, ...)
1264#endif
1265//# }}
1266
1267//#=====================================================================================================================
1268//# FLOAT128
1269//#=====================================================================================================================
1270
1271#if defined(__SIZEOF_FLOAT128__) && defined(__FLT128_MANT_DIG__) && defined(__LDBL_MANT_DIG__) \
1272 && __FLT128_MANT_DIG__ > __LDBL_MANT_DIG__
1273#define TOML_FLOAT128 __float128
1274#endif
1275
1276//#=====================================================================================================================
1277//# INT128
1278//#=====================================================================================================================
1279
1280#ifdef __SIZEOF_INT128__
1281#define TOML_INT128 __int128_t
1282#define TOML_UINT128 __uint128_t
1283#endif
1284
1285//#====================================================================================================================
1286//# VERSIONS AND NAMESPACES
1287//#====================================================================================================================
1288// clang-format off
1289
1290#include "version.hpp"
1291
1292#define TOML_LIB_SINGLE_HEADER 0
1293
1294#if TOML_ENABLE_UNRELEASED_FEATURES
1295 #define TOML_LANG_EFFECTIVE_VERSION \
1296 TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH+1)
1297#else
1298 #define TOML_LANG_EFFECTIVE_VERSION \
1299 TOML_MAKE_VERSION(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)
1300#endif
1301
1302#define TOML_LANG_HIGHER_THAN(major, minor, patch) \
1303 (TOML_LANG_EFFECTIVE_VERSION > TOML_MAKE_VERSION(major, minor, patch))
1304
1305#define TOML_LANG_AT_LEAST(major, minor, patch) \
1306 (TOML_LANG_EFFECTIVE_VERSION >= TOML_MAKE_VERSION(major, minor, patch))
1307
1308#define TOML_LANG_UNRELEASED \
1309 TOML_LANG_HIGHER_THAN(TOML_LANG_MAJOR, TOML_LANG_MINOR, TOML_LANG_PATCH)
1310
1311#ifndef TOML_ABI_NAMESPACES
1312 #if TOML_DOXYGEN
1313 #define TOML_ABI_NAMESPACES 0
1314 #else
1315 #define TOML_ABI_NAMESPACES 1
1316 #endif
1317#endif
1318#if TOML_ABI_NAMESPACES
1319 #define TOML_NAMESPACE_START namespace toml { inline namespace TOML_CONCAT(v, TOML_LIB_MAJOR)
1320 #define TOML_NAMESPACE_END } static_assert(true)
1321 #define TOML_NAMESPACE ::toml::TOML_CONCAT(v, TOML_LIB_MAJOR)
1322 #define TOML_ABI_NAMESPACE_START(name) inline namespace name { static_assert(true)
1323 #define TOML_ABI_NAMESPACE_BOOL(cond, T, F) TOML_ABI_NAMESPACE_START(TOML_CONCAT(TOML_EVAL_BOOL_, cond)(T, F))
1324 #define TOML_ABI_NAMESPACE_END } static_assert(true)
1325#else
1326 #define TOML_NAMESPACE_START namespace toml
1327 #define TOML_NAMESPACE_END static_assert(true)
1328 #define TOML_NAMESPACE toml
1329 #define TOML_ABI_NAMESPACE_START(...) static_assert(true)
1330 #define TOML_ABI_NAMESPACE_BOOL(...) static_assert(true)
1331 #define TOML_ABI_NAMESPACE_END static_assert(true)
1332#endif
1333#define TOML_IMPL_NAMESPACE_START TOML_NAMESPACE_START { namespace impl
1334#define TOML_IMPL_NAMESPACE_END } TOML_NAMESPACE_END
1335#if TOML_HEADER_ONLY
1336 #define TOML_ANON_NAMESPACE_START static_assert(TOML_IMPLEMENTATION); TOML_IMPL_NAMESPACE_START
1337 #define TOML_ANON_NAMESPACE_END TOML_IMPL_NAMESPACE_END
1338 #define TOML_ANON_NAMESPACE TOML_NAMESPACE::impl
1339 #define TOML_EXTERNAL_LINKAGE inline
1340 #define TOML_INTERNAL_LINKAGE inline
1341#else
1342 #define TOML_ANON_NAMESPACE_START static_assert(TOML_IMPLEMENTATION); \
1343 using namespace toml; \
1344 namespace
1345 #define TOML_ANON_NAMESPACE_END static_assert(true)
1346 #define TOML_ANON_NAMESPACE
1347 #define TOML_EXTERNAL_LINKAGE
1348 #define TOML_INTERNAL_LINKAGE static
1349#endif
1350
1351// clang-format on
1352//#====================================================================================================================
1353//# ASSERT
1354//#====================================================================================================================
1355
1356//#====================================================================================================================
1357//# STATIC ASSERT MESSAGE FORMATTING
1358//#====================================================================================================================
1359// clang-format off
1361
1362#if TOML_SIMPLE_STATIC_ASSERT_MESSAGES
1363
1364 #define TOML_SA_NEWLINE " "
1365 #define TOML_SA_LIST_SEP ", "
1366 #define TOML_SA_LIST_BEG " ("
1367 #define TOML_SA_LIST_END ")"
1368 #define TOML_SA_LIST_NEW " "
1369 #define TOML_SA_LIST_NXT ", "
1370
1371#else
1372
1373 #define TOML_SA_NEWLINE "\n| "
1374 #define TOML_SA_LIST_SEP TOML_SA_NEWLINE " - "
1375 #define TOML_SA_LIST_BEG TOML_SA_LIST_SEP
1376 #define TOML_SA_LIST_END
1377 #define TOML_SA_LIST_NEW TOML_SA_NEWLINE TOML_SA_NEWLINE
1378 #define TOML_SA_LIST_NXT TOML_SA_LIST_NEW
1379
1380#endif
1381
1382#define TOML_SA_NATIVE_VALUE_TYPE_LIST \
1383 TOML_SA_LIST_BEG "std::string" \
1384 TOML_SA_LIST_SEP "int64_t" \
1385 TOML_SA_LIST_SEP "double" \
1386 TOML_SA_LIST_SEP "bool" \
1387 TOML_SA_LIST_SEP "toml::date" \
1388 TOML_SA_LIST_SEP "toml::time" \
1389 TOML_SA_LIST_SEP "toml::date_time" \
1390 TOML_SA_LIST_END
1391
1392#define TOML_SA_NODE_TYPE_LIST \
1393 TOML_SA_LIST_BEG "toml::table" \
1394 TOML_SA_LIST_SEP "toml::array" \
1395 TOML_SA_LIST_SEP "toml::value<std::string>" \
1396 TOML_SA_LIST_SEP "toml::value<int64_t>" \
1397 TOML_SA_LIST_SEP "toml::value<double>" \
1398 TOML_SA_LIST_SEP "toml::value<bool>" \
1399 TOML_SA_LIST_SEP "toml::value<toml::date>" \
1400 TOML_SA_LIST_SEP "toml::value<toml::time>" \
1401 TOML_SA_LIST_SEP "toml::value<toml::date_time>" \
1402 TOML_SA_LIST_END
1403
1404#define TOML_SA_UNWRAPPED_NODE_TYPE_LIST \
1405 TOML_SA_LIST_NEW "A native TOML value type" \
1406 TOML_SA_NATIVE_VALUE_TYPE_LIST \
1407 \
1408 TOML_SA_LIST_NXT "A TOML node type" \
1409 TOML_SA_NODE_TYPE_LIST
1410
1412// clang-format on
TOML_DISABLE_WARNINGS
#define TOML_DISABLE_WARNINGS
Definition preprocessor.hpp:871
TOML_ENABLE_WARNINGS
#define TOML_ENABLE_WARNINGS
Definition preprocessor.hpp:874