3rdparty: re-vendor rapidyaml in-tree (revert upstream un-bundling)

Upstream 0beb18c9e ("Deps: Update rapidyaml to v0.11.1", 2026-03-29) deleted the vendored 3rdparty/rapidyaml and switched to find_package(ryml REQUIRED), making ryml a system/external dependency. That breaks self-contained and cross builds (e.g. the rocknix handheld toolchain) which have no system ryml available. Restore the in-tree copy (v0.10.0, from 0beb18c9e^) and point the build back at it: add_subdirectory(3rdparty/rapidyaml) instead of find_package, and link rapidyaml::rapidyaml. The C++ side needs no changes: common/YAML.cpp is already version-guarded (0804b68fc "Common: Fix build with older ryml", RYML_VERSION_MINOR >= 11) so it compiles against v0.10 unchanged. Also drop ryml.dll from the Windows dep-copy list since it's now statically linked. This is a deliberate fork-local divergence from upstream's un-bundling, kept so downstream builders don't have to provision ryml themselves. Configures without a system ryml and builds end-to-end (common + pcsx2-qt) using the in-tree library. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-08-24 16:50:16 -07:00 · 2026-06-21 14:19:13 -07:00
parent 5a8a666dc3
commit 78f84827e6
84 changed files with 34446 additions and 3 deletions
@@ -0,0 +1,91 @@
+add_library(pcsx2-rapidyaml
+  include/c4/base64.hpp
+  include/c4/blob.hpp
+  include/c4/charconv.hpp
+  include/c4/compiler.hpp
+  include/c4/config.hpp
+  include/c4/cpu.hpp
+  include/c4/dump.hpp
+  include/c4/error.hpp
+  include/c4/export.hpp
+  include/c4/format.hpp
+  include/c4/language.hpp
+  include/c4/memory_util.hpp
+  include/c4/platform.hpp
+  include/c4/preprocessor.hpp
+  include/c4/std/std.hpp
+  include/c4/std/std_fwd.hpp
+  include/c4/std/string.hpp
+  include/c4/std/string_fwd.hpp
+  include/c4/std/string_view.hpp
+  include/c4/std/tuple.hpp
+  include/c4/std/vector.hpp
+  include/c4/std/vector_fwd.hpp
+  include/c4/substr.hpp
+  include/c4/substr_fwd.hpp
+  include/c4/szconv.hpp
+  include/c4/types.hpp
+  include/c4/utf.hpp
+  include/c4/windows.hpp
+  include/c4/windows_pop.hpp
+  include/c4/windows_push.hpp
+  include/c4/yml/common.hpp
+  include/c4/yml/detail/dbgprint.hpp
+  include/c4/yml/detail/stack.hpp
+  include/c4/yml/emit.def.hpp
+  include/c4/yml/emit.hpp
+  include/c4/yml/event_handler_stack.hpp
+  include/c4/yml/event_handler_tree.hpp
+  include/c4/yml/filter_processor.hpp
+  include/c4/yml/fwd.hpp
+  include/c4/yml/export.hpp
+  include/c4/yml/node.hpp
+  include/c4/yml/node_type.hpp
+  include/c4/yml/parse.hpp
+  include/c4/yml/parse_engine.def.hpp
+  include/c4/yml/parse_engine.hpp
+  include/c4/yml/parser_state.hpp
+  include/c4/yml/reference_resolver.hpp
+  include/c4/yml/preprocess.hpp
+  include/c4/yml/std/map.hpp
+  include/c4/yml/std/std.hpp
+  include/c4/yml/std/string.hpp
+  include/c4/yml/std/vector.hpp
+  include/c4/yml/tag.hpp
+  include/c4/yml/tree.hpp
+  include/c4/yml/version.hpp
+  include/c4/yml/writer.hpp
+  include/c4/yml/yml.hpp
+  include/ryml.hpp
+  include/ryml_std.hpp
+  src/c4/base64.cpp
+  src/c4/error.cpp
+  src/c4/format.cpp
+  src/c4/language.cpp
+  src/c4/memory_util.cpp
+  src/c4/utf.cpp
+  src/c4/yml/common.cpp
+  src/c4/yml/node.cpp
+  src/c4/yml/parse.cpp
+  src/c4/yml/preprocess.cpp
+  src/c4/yml/tree.cpp
+  src/c4/yml/node_type.cpp
+  src/c4/yml/reference_resolver.cpp
+  src/c4/yml/tag.cpp
+  src/c4/yml/version.cpp
+)
+
+target_include_directories(pcsx2-rapidyaml PRIVATE
+  "${CMAKE_CURRENT_SOURCE_DIR}/include"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../fast_float/include"
+)
+target_include_directories(pcsx2-rapidyaml INTERFACE
+  "${CMAKE_CURRENT_SOURCE_DIR}/include"
+)
+
+target_compile_definitions(pcsx2-rapidyaml PUBLIC
+  "C4_NO_DEBUG_BREAK"
+)
+
+add_library(rapidyaml::rapidyaml ALIAS pcsx2-rapidyaml)
@@ -0,0 +1,141 @@
+#ifndef _C4_BASE64_HPP_
+#define _C4_BASE64_HPP_
+
+/** @file base64.hpp encoding/decoding for base64.
+ * @see https://en.wikipedia.org/wiki/Base64
+ * @see https://www.base64encode.org/
+ * */
+
+#include "c4/charconv.hpp"
+#include "c4/blob.hpp"
+
+namespace c4 {
+
+/** @defgroup doc_base64 Base64 encoding/decoding
+ * @see https://en.wikipedia.org/wiki/Base64
+ * @see https://www.base64encode.org/
+ * @{ */
+
+/** check that the given buffer is a valid base64 encoding
+ * @see https://en.wikipedia.org/wiki/Base64 */
+C4CORE_EXPORT bool base64_valid(csubstr encoded);
+
+
+/** base64-encode binary data.
+ * @param encoded [out] output buffer for encoded data
+ * @param data [in] the input buffer with the binary data
+ *
+ * @return the number of bytes needed to return the output (ie the
+ * required size for @p encoded). No writes occur beyond the end of
+ * the output buffer, so it is safe to do a speculative call where the
+ * encoded buffer is empty, or maybe too small. The caller should
+ * ensure that the returned size is smaller than the size of the
+ * encoded buffer.
+ *
+ * @note the result depends on endianness. If transfer between
+ * little/big endian systems is desired, the caller should normalize
+ * @p data before encoding.
+ *
+ * @see https://en.wikipedia.org/wiki/Base64 */
+C4CORE_EXPORT size_t base64_encode(substr encoded, cblob data);
+
+
+/** decode the base64 encoding in the given buffer
+ * @param encoded [in] the encoded base64
+ * @param data [out] the output buffer
+ *
+ * @return the number of bytes needed to return the output (ie the
+ * required size for @p data). No writes occur beyond the end of the
+ * output buffer, so it is safe to do a speculative call where the
+ * data buffer is empty, or maybe too small. The caller should ensure
+ * that the returned size is smaller than the size of the data buffer.
+ *
+ * @note the result depends on endianness. If transfer between
+ * little/big endian systems is desired, the caller should normalize
+ * @p data after decoding.
+ *
+ * @see https://en.wikipedia.org/wiki/Base64 */
+C4CORE_EXPORT size_t base64_decode(csubstr encoded, blob data);
+
+/** @} */ // base64
+
+namespace fmt {
+
+/** @addtogroup doc_format_specifiers
+ * @{ */
+
+/** @defgroup doc_base64_fmt Base64
+ * @{ */
+
+template<typename CharOrConstChar>
+struct base64_wrapper_
+{
+    blob_<CharOrConstChar> data;
+    base64_wrapper_() : data() {}
+    base64_wrapper_(blob_<CharOrConstChar> blob) : data(blob) {}
+};
+/** a tag type to mark a payload as base64-encoded */
+using const_base64_wrapper = base64_wrapper_<cbyte>;
+/** a tag type to mark a payload to be encoded as base64 */
+using base64_wrapper = base64_wrapper_<byte>;
+
+
+/** mark a variable to be written in base64 format */
+template<class ...Args>
+C4_ALWAYS_INLINE const_base64_wrapper cbase64(Args const& C4_RESTRICT ...args)
+{
+    return const_base64_wrapper(cblob(args...));
+}
+/** mark a csubstr to be written in base64 format */
+C4_ALWAYS_INLINE const_base64_wrapper cbase64(csubstr s)
+{
+    return const_base64_wrapper(cblob(s.str, s.len));
+}
+/** mark a variable to be written in base64 format */
+template<class ...Args>
+C4_ALWAYS_INLINE const_base64_wrapper base64(Args const& C4_RESTRICT ...args)
+{
+    return const_base64_wrapper(cblob(args...));
+}
+/** mark a csubstr to be written in base64 format */
+C4_ALWAYS_INLINE const_base64_wrapper base64(csubstr s)
+{
+    return const_base64_wrapper(cblob(s.str, s.len));
+}
+
+/** mark a variable to be read in base64 format */
+template<class ...Args>
+C4_ALWAYS_INLINE base64_wrapper base64(Args &... args)
+{
+    return base64_wrapper(blob(args...));
+}
+/** mark a variable to be read in base64 format */
+C4_ALWAYS_INLINE base64_wrapper base64(substr s)
+{
+    return base64_wrapper(blob(s.str, s.len));
+}
+
+/** @} */ // base64_fmt
+
+/** @} */ // format_specifiers
+
+} // namespace fmt
+
+
+/** write a variable in base64 format
+ * @ingroup doc_to_chars */
+inline size_t to_chars(substr buf, fmt::const_base64_wrapper b)
+{
+    return base64_encode(buf, b.data);
+}
+
+/** read a variable in base64 format
+ * @ingroup doc_from_chars */
+inline size_t from_chars(csubstr buf, fmt::base64_wrapper *b)
+{
+    return base64_decode(buf, b->data);
+}
+
+} // namespace c4
+
+#endif /* _C4_BASE64_HPP_ */
@@ -0,0 +1,71 @@
+#ifndef _C4_BLOB_HPP_
+#define _C4_BLOB_HPP_
+
+#include "c4/types.hpp"
+#include "c4/error.hpp"
+
+/** @file blob.hpp Mutable and immutable binary data blobs.
+*/
+
+namespace c4 {
+
+template<class T>
+struct blob_;
+
+namespace detail {
+template<class T> struct is_blob_type : std::integral_constant<bool, false> {};
+template<class T> struct is_blob_type<blob_<T>> : std::integral_constant<bool, true> {};
+template<class T> struct is_blob_value_type : std::integral_constant<bool, (std::is_fundamental<T>::value || std::is_trivially_copyable<T>::value)> {};
+} // namespace
+
+// NOLINTBEGIN(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+
+template<class T>
+struct blob_
+{
+    static_assert(std::is_same<T, byte>::value || std::is_same<T, cbyte>::value, "must be either byte or cbyte");
+    static_assert(sizeof(T) == 1u, "must be either byte or cbyte");
+
+public:
+
+    T *    buf;
+    size_t len;
+
+public:
+
+    C4_ALWAYS_INLINE blob_() noexcept = default;
+    C4_ALWAYS_INLINE blob_(blob_ const& that) noexcept = default;
+    C4_ALWAYS_INLINE blob_(blob_     && that) noexcept = default;
+    C4_ALWAYS_INLINE blob_& operator=(blob_     && that) noexcept = default;
+    C4_ALWAYS_INLINE blob_& operator=(blob_ const& that) noexcept = default;
+
+    template<class U, class=typename std::enable_if<std::is_const<T>::value && std::is_same<typename std::add_const<U>::type, T>::value, U>::type> C4_ALWAYS_INLINE blob_(blob_<U> const& that) noexcept : buf(that.buf), len(that.len) {} // NOLINT
+    template<class U, class=typename std::enable_if<std::is_const<T>::value && std::is_same<typename std::add_const<U>::type, T>::value, U>::type> C4_ALWAYS_INLINE blob_(blob_<U>     && that) noexcept : buf(that.buf), len(that.len) {} // NOLINT
+    template<class U, class=typename std::enable_if<std::is_const<T>::value && std::is_same<typename std::add_const<U>::type, T>::value, U>::type> C4_ALWAYS_INLINE blob_& operator=(blob_<U>     && that) noexcept { buf = that.buf; len = that.len; } // NOLINT
+    template<class U, class=typename std::enable_if<std::is_const<T>::value && std::is_same<typename std::add_const<U>::type, T>::value, U>::type> C4_ALWAYS_INLINE blob_& operator=(blob_<U> const& that) noexcept { buf = that.buf; len = that.len; } // NOLINT
+
+    C4_ALWAYS_INLINE blob_(void       *ptr, size_t n) noexcept : buf(reinterpret_cast<T*>(ptr)), len(n) {} // NOLINT
+    C4_ALWAYS_INLINE blob_(void const *ptr, size_t n) noexcept : buf(reinterpret_cast<T*>(ptr)), len(n) {} // NOLINT
+
+    #define _C4_REQUIRE_BLOBTYPE(ty) class=typename std::enable_if<((!detail::is_blob_type<ty>::value) && (detail::is_blob_value_type<ty>::value)), T>::type
+    template<class U, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_(U &var) noexcept : buf(reinterpret_cast<T*>(&var)), len(sizeof(U)) {} // NOLINT
+    template<class U, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_(U *ptr, size_t n) noexcept : buf(reinterpret_cast<T*>(ptr)), len(sizeof(U) * n) { C4_ASSERT(is_aligned(ptr)); } // NOLINT
+    template<class U, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_& operator= (U &var) noexcept { buf = reinterpret_cast<T*>(&var); len = sizeof(U); return *this; } // NOLINT
+    template<class U, size_t N, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_(U (&arr)[N]) noexcept : buf(reinterpret_cast<T*>(arr)), len(sizeof(U) * N) {} // NOLINT
+    template<class U, size_t N, _C4_REQUIRE_BLOBTYPE(U)> C4_ALWAYS_INLINE blob_& operator= (U (&arr)[N]) noexcept { buf = reinterpret_cast<T*>(arr); len = sizeof(U) * N; return *this; } // NOLINT
+    #undef _C4_REQUIRE_BLOBTYPE
+};
+
+// NOLINTEND(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+
+/** an immutable binary blob */
+using cblob = blob_<cbyte>;
+/** a mutable binary blob */
+using  blob = blob_< byte>;
+
+C4_MUST_BE_TRIVIAL_COPY(blob);
+C4_MUST_BE_TRIVIAL_COPY(cblob);
+
+} // namespace c4
+
+#endif // _C4_BLOB_HPP_
@@ -0,0 +1,168 @@
+<?xml version="1.0" encoding="utf-8"?> 
+
+<!--
+Very good intro:
+@see https://code.msdn.microsoft.com/windowsdesktop/Writing-type-visualizers-2eae77a2
+See also:
+@see http://blogs.msdn.com/b/vcblog/archive/2013/06/28/using-visual-studio-2013-to-write-maintainable-native-visualizations-natvis.aspx?PageIndex=2
+@see http://blogs.msdn.com/b/vcblog/archive/2015/09/28/debug-visualizers-in-visual-c-2015.aspx
+@see http://stackoverflow.com/questions/36883414/limit-display-of-char-in-natvis-file-to-specific-length
+-->
+
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+
+  <Type Name="c4::basic_substring&lt;*&gt;">
+    <DisplayString>{str,[len]} (sz={len})</DisplayString>
+    <StringView>str,[len]</StringView>
+    <Expand>
+      <Item Name="[size]">len</Item>
+      <ArrayItems>
+        <Size>len</Size>
+        <ValuePointer>str</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <Type Name="c4::span&lt;*&gt;">
+    <DisplayString>{m_ptr,[m_size]} (sz={m_size})</DisplayString>
+    <Expand>
+      <Item Name="[size]">m_size</Item>
+      <ArrayItems>
+        <Size>m_size</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+  <Type Name="c4::spanrs&lt;*&gt;">
+    <DisplayString>{m_ptr,[m_size]} (sz={m_size}, cap={m_capacity})</DisplayString>
+    <Expand>
+      <Item Name="[size]">m_size</Item>
+      <Item Name="[capacity]">m_capacity</Item>
+      <ArrayItems>
+        <Size>m_size</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+  <!-- display span<char>/span<const char> as a string too -->
+  <Type Name="c4::span&lt;char,*&gt;">
+    <DisplayString>{m_ptr,[m_size]} (sz={m_size})</DisplayString>
+    <StringView>m_ptr,[m_size]</StringView>
+    <Expand>
+      <Item Name="[size]">m_size</Item>
+      <ArrayItems>
+        <Size>m_size</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+  <Type Name="c4::span&lt;const char,*&gt;">
+    <DisplayString>{m_ptr,[m_size]} (sz={m_size})</DisplayString>
+    <StringView>m_ptr,[m_size]</StringView>
+    <Expand>
+      <Item Name="[size]">m_size</Item>
+      <ArrayItems>
+        <Size>m_size</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+  <!-- display spanrs<char>/spanrs<const char> as a string too -->
+  <Type Name="c4::spanrs&lt;char,*&gt;">
+    <DisplayString>{m_ptr,[m_size]} (sz={m_size}, cap={m_capacity})</DisplayString>
+    <StringView>m_ptr,[m_size]</StringView>
+    <Expand>
+      <Item Name="[size]">m_size</Item>
+      <Item Name="[capacity]">m_capacity</Item>
+      <ArrayItems>
+        <Size>m_size</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+  <Type Name="c4::spanrs&lt;const char,*&gt;">
+    <DisplayString>{m_ptr,[m_size]} (sz={m_size}, cap={m_capacity})</DisplayString>
+    <StringView>m_ptr,[m_size]</StringView>
+    <Expand>
+      <Item Name="[size]">m_size</Item>
+      <Item Name="[capacity]">m_capacity</Item>
+      <ArrayItems>
+        <Size>m_size</Size>
+        <ValuePointer>m_ptr</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+  <!-- =========================================================================================== -->
+  <Type Name="c4::string_impl&lt;*,*,*,*&gt;">
+    <DisplayString>{(($T3*)this)->m_str,[(($T3*)this)->m_size]} (sz={(($T3*)this)->m_size})</DisplayString>
+    <StringView>(($T3*)this)->m_str,[(($T3*)this)->m_size]</StringView>
+    <Expand>
+      <Synthetic Name="m_str">
+        <DisplayString>{(($T3*)this)->m_str,[(($T3*)this)->m_size]}</DisplayString>
+        <StringView>(($T3*)this)->m_str,[(($T3*)this)->m_size]</StringView>
+      </Synthetic>
+      <Synthetic Name="m_size">
+        <DisplayString>{(($T3*)this)->m_size}</DisplayString>
+      </Synthetic>
+    </Expand>
+  </Type>
+  <Type Name="c4::basic_substring&lt;*,*&gt;">
+    <DisplayString>{m_str,[m_size]} (sz={m_size})</DisplayString>
+    <StringView>m_str,[m_size]</StringView>
+    <Expand>
+      <Synthetic Name="[size]">
+        <DisplayString>{m_size}</DisplayString>
+      </Synthetic>
+    </Expand>
+  </Type>
+  <Type Name="c4::basic_substringrs&lt;*,*&gt;">
+    <DisplayString>{m_str,[m_size]} (sz={m_size},cap={m_capacity})</DisplayString>
+    <StringView>m_str,[m_size]</StringView>
+    <Expand>
+      <Synthetic Name="[size]">
+        <DisplayString>{m_size}</DisplayString>
+      </Synthetic>
+      <Synthetic Name="[capacity]">
+        <DisplayString>{m_capacity}</DisplayString>
+      </Synthetic>
+      <Synthetic Name="[full]">
+        <DisplayString>{m_str,[m_capacity]}</DisplayString>
+        <StringView>m_str,[m_capacity]</StringView>
+      </Synthetic>
+    </Expand>
+  </Type>
+  <Type Name="c4::basic_string&lt;*,*,*&gt;">
+    <DisplayString>{m_str,[m_size]} (sz={m_size},cap={m_capacity})</DisplayString>
+    <StringView>m_str,[m_size]</StringView>
+    <Expand>
+      <Synthetic Name="[size]">
+        <DisplayString>{m_size}</DisplayString>
+      </Synthetic>
+      <Synthetic Name="[full]">
+        <DisplayString>{m_str,[m_capacity]}</DisplayString>
+        <StringView>m_str,[m_capacity]</StringView>
+      </Synthetic>
+    </Expand>
+  </Type>
+
+  <!-- enum symbols -->
+  <Type Name="c4::EnumSymbols&lt;*&gt;::Sym">
+    <DisplayString>{value} - {name}</DisplayString>
+    <Expand>
+      <Item Name="[value]">value</Item>
+      <Item Name="[name]">name</Item>
+    </Expand>
+  </Type>
+  <Type Name="c4::EnumSymbols&lt;*&gt;">
+    <DisplayString>{m_symbols,[m_num]} (sz={m_num})</DisplayString>
+    <Expand>
+      <Item Name="[size]">m_num</Item>
+      <ArrayItems>
+        <Size>m_num</Size>
+        <ValuePointer>m_symbols</ValuePointer>
+      </ArrayItems>
+    </Expand>
+  </Type>
+
+</AutoVisualizer>
@@ -0,0 +1,120 @@
+#ifndef _C4_COMPILER_HPP_
+#define _C4_COMPILER_HPP_
+
+/** @file compiler.hpp Provides compiler information macros
+ * @ingroup basic_headers */
+
+#include "c4/platform.hpp"
+
+// Compilers:
+//      C4_MSVC
+//             Visual Studio 2022: MSVC++ 17, 1930
+//             Visual Studio 2019: MSVC++ 16, 1920
+//             Visual Studio 2017: MSVC++ 15
+//             Visual Studio 2015: MSVC++ 14
+//             Visual Studio 2013: MSVC++ 13
+//             Visual Studio 2013: MSVC++ 12
+//             Visual Studio 2012: MSVC++ 11
+//             Visual Studio 2010: MSVC++ 10
+//             Visual Studio 2008: MSVC++ 09
+//             Visual Studio 2005: MSVC++ 08
+//      C4_CLANG
+//      C4_GCC
+//      C4_ICC (intel compiler)
+/** @see http://sourceforge.net/p/predef/wiki/Compilers/ for a list of compiler identifier macros */
+/** @see https://msdn.microsoft.com/en-us/library/b0084kay.aspx for VS2013 predefined macros */
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   define C4_MSVC
+#   define C4_MSVC_VERSION_2022 17
+#   define C4_MSVC_VERSION_2019 16
+#   define C4_MSVC_VERSION_2017 15
+#   define C4_MSVC_VERSION_2015 14
+#   define C4_MSVC_VERSION_2013 12
+#   define C4_MSVC_VERSION_2012 11
+#   if _MSC_VER >= 1930
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2022  // visual studio 2022
+#       define C4_MSVC_2022
+#   elif _MSC_VER >= 1920
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2019  // visual studio 2019
+#       define C4_MSVC_2019
+#   elif _MSC_VER >= 1910
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2017  // visual studio 2017
+#       define C4_MSVC_2017
+#   elif _MSC_VER == 1900
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2015  // visual studio 2015
+#       define C4_MSVC_2015
+#   elif _MSC_VER == 1800
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2013  // visual studio 2013
+#       define C4_MSVC_2013
+#   elif _MSC_VER == 1700
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION C4_MSVC_VERSION_2012  // visual studio 2012
+#       define C4_MSVC_2012
+#   elif _MSC_VER == 1600
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION 10  // visual studio 2010
+#       define C4_MSVC_2010
+#   elif _MSC_VER == 1500
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION 09  // visual studio 2008
+#       define C4_MSVC_2008
+#   elif _MSC_VER == 1400
+#       error "MSVC version not supported"
+#       define C4_MSVC_VERSION 08  // visual studio 2005
+#       define C4_MSVC_2005
+#   else
+#       error "MSVC version not supported"
+#   endif // _MSC_VER
+#else
+#   define C4_MSVC_VERSION 0   // visual studio not present
+#   define C4_GCC_LIKE
+#   ifdef __INTEL_COMPILER // check ICC before checking GCC, as ICC defines __GNUC__ too
+#       define C4_ICC
+#       define C4_ICC_VERSION __INTEL_COMPILER
+#   elif defined(__APPLE_CC__)
+#       define C4_XCODE
+#       if defined(__clang__)
+#           define C4_CLANG
+#           ifndef __apple_build_version__
+#               define C4_CLANG_VERSION C4_VERSION_ENCODED(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#           else
+#               define C4_CLANG_VERSION __apple_build_version__
+#           endif
+#       else
+#           define C4_XCODE_VERSION __APPLE_CC__
+#       endif
+#   elif defined(__clang__)
+#       define C4_CLANG
+#       ifndef __apple_build_version__
+#           define C4_CLANG_VERSION C4_VERSION_ENCODED(__clang_major__, __clang_minor__, __clang_patchlevel__)
+#       else
+#           define C4_CLANG_VERSION __apple_build_version__
+#       endif
+#   elif defined(__GNUC__)
+#       ifdef __MINGW32__
+#           define C4_MINGW
+#       endif
+#       define C4_GCC
+#       if defined(__GNUC_PATCHLEVEL__)
+#           define C4_GCC_VERSION C4_VERSION_ENCODED(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#       else
+#           define C4_GCC_VERSION C4_VERSION_ENCODED(__GNUC__, __GNUC_MINOR__, 0)
+#       endif
+#       if __GNUC__ < 5
+#           if __GNUC__ == 4 && __GNUC_MINOR__ >= 8
+// provided by cmake sub-project
+#               include "c4/gcc-4.8.hpp"
+#           else
+// we do not support GCC < 4.8:
+//  * misses std::is_trivially_copyable
+//  * misses std::align
+//  * -Wshadow has false positives when a local function parameter has the same name as a method
+#               error "GCC < 4.8 is not supported"
+#           endif
+#       endif
+#   endif
+#endif // defined(C4_WIN) && defined(_MSC_VER)
+
+#endif /* _C4_COMPILER_HPP_ */
@@ -0,0 +1,39 @@
+#ifndef _C4_CONFIG_HPP_
+#define _C4_CONFIG_HPP_
+
+/** @defgroup basic_headers Basic headers
+ * @brief Headers providing basic macros, platform+cpu+compiler information,
+ * C++ facilities and basic typedefs. */
+
+/** @file config.hpp Contains configuration defines and includes the basic_headers.
+ * @ingroup basic_headers */
+
+//#define C4_DEBUG
+
+#define C4_ERROR_SHOWS_FILELINE
+//#define C4_ERROR_SHOWS_FUNC
+//#define C4_ERROR_THROWS_EXCEPTION
+//#define C4_NO_ALLOC_DEFAULTS
+//#define C4_REDEFINE_CPPNEW
+
+#ifndef C4_SIZE_TYPE
+#   define C4_SIZE_TYPE size_t
+#endif
+
+#ifndef C4_STR_SIZE_TYPE
+#   define C4_STR_SIZE_TYPE C4_SIZE_TYPE
+#endif
+
+#ifndef C4_TIME_TYPE
+#   define C4_TIME_TYPE double
+#endif
+
+#include "c4/export.hpp"
+#include "c4/preprocessor.hpp"
+#include "c4/platform.hpp"
+#include "c4/cpu.hpp"
+#include "c4/compiler.hpp"
+#include "c4/language.hpp"
+#include "c4/types.hpp"
+
+#endif // _C4_CONFIG_HPP_
@@ -0,0 +1,205 @@
+#ifndef _C4_CPU_HPP_
+#define _C4_CPU_HPP_
+
+/** @file cpu.hpp Provides processor information macros
+ * @ingroup basic_headers */
+
+// see also https://sourceforge.net/p/predef/wiki/Architectures/
+// see also https://sourceforge.net/p/predef/wiki/Endianness/
+// see also https://github.com/googlesamples/android-ndk/blob/android-mk/hello-jni/jni/hello-jni.c
+// see also http://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/global/qprocessordetection.h
+
+#ifdef __ORDER_LITTLE_ENDIAN__
+#   define _C4EL __ORDER_LITTLE_ENDIAN__
+#else
+#   define _C4EL 1234
+#endif
+
+#ifdef __ORDER_BIG_ENDIAN__
+#   define _C4EB __ORDER_BIG_ENDIAN__
+#else
+#   define _C4EB 4321
+#endif
+
+// mixed byte order (eg, PowerPC or ia64)
+#define _C4EM 1111 // NOLINT
+
+
+// NOTE: to find defined macros in a platform,
+// g++ <flags> -dM -E - </dev/null | sort
+
+#if defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(_M_X64)
+#    define C4_CPU_X86_64
+#    define C4_WORDSIZE 8
+#    define C4_BYTE_ORDER _C4EL
+
+#elif defined(__i386) || defined(__i386__) || defined(_M_IX86)
+#    define C4_CPU_X86
+#    define C4_WORDSIZE 4
+#    define C4_BYTE_ORDER _C4EL
+
+#elif defined(__arm__) || defined(_M_ARM) \
+    || defined(__TARGET_ARCH_ARM) || defined(__aarch64__) || defined(_M_ARM64)
+#   if defined(__aarch64__) || defined(_M_ARM64)
+#       define C4_CPU_ARM64
+#       define C4_CPU_ARMV8
+#       define C4_WORDSIZE 8
+#   else
+#       define C4_CPU_ARM
+#       define C4_WORDSIZE 4
+#       if defined(__ARM_ARCH_8__) || defined(__ARM_ARCH_8A__)  \
+        || (defined(__ARCH_ARM) && __ARCH_ARM >= 8) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 8)
+#           define C4_CPU_ARMV8
+#       elif defined(__ARM_ARCH_7__) || defined(_ARM_ARCH_7)    \
+        || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) \
+        || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) \
+        || defined(__ARM_ARCH_7EM__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 7) \
+        || (defined(_M_ARM) && _M_ARM >= 7)
+#           define C4_CPU_ARMV7
+#       elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
+        || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_6Z__) \
+        || defined(__ARM_ARCH_6K__)  || defined(__ARM_ARCH_6ZK__) \
+        || defined(__ARM_ARCH_6M__) || defined(__ARM_ARCH_6KZ__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 6)
+#           define C4_CPU_ARMV6
+#       elif (defined(__ARM_ARCH) && __ARM_ARCH == 5) \
+        || defined(__ARM_ARCH_5TEJ__) \
+        || defined(__ARM_ARCH_5TE__) \
+        || defined(__ARM_ARCH_5T__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 5)
+#           define C4_CPU_ARMV5
+#       elif (defined(__ARM_ARCH) && __ARM_ARCH == 4) \
+        || defined(__ARM_ARCH_4T__) \
+        || defined(__ARM_ARCH_4__) \
+        || (defined(__TARGET_ARCH_ARM) && __TARGET_ARCH_ARM >= 4)
+#           define C4_CPU_ARMV4
+#       else
+#           error "unknown CPU architecture: ARM"
+#       endif
+#   endif
+#   if defined(__ARMEL__) || defined(__LITTLE_ENDIAN__) || defined(__AARCH64EL__) \
+       || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) \
+       || defined(_MSC_VER) // winarm64 does not provide any of the above macros,
+                            // but advises little-endianess:
+                            // https://docs.microsoft.com/en-us/cpp/build/overview-of-arm-abi-conventions?view=msvc-170
+                            // So if it is visual studio compiling, we'll assume little endian.
+#       define C4_BYTE_ORDER _C4EL
+#   elif defined(__ARMEB__) || defined(__BIG_ENDIAN__) || defined(__AARCH64EB__) \
+       || (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+#       define C4_BYTE_ORDER _C4EB
+#   elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_PDP_ENDIAN__)
+#       define C4_BYTE_ORDER _C4EM
+#   else
+#       error "unknown endianness"
+#   endif
+
+#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)
+#   define C4_CPU_IA64
+#   define C4_WORDSIZE 8
+#   define C4_BYTE_ORDER _C4EM
+   // itanium is bi-endian - check byte order below
+
+#elif defined(__ppc__) || defined(__ppc) || defined(__powerpc__)       \
+    || defined(_ARCH_COM) || defined(_ARCH_PWR) || defined(_ARCH_PPC)  \
+    || defined(_M_MPPC) || defined(_M_PPC)
+#   if defined(__ppc64__) || defined(__powerpc64__) || defined(__64BIT__)
+#       define C4_CPU_PPC64
+#       define C4_WORDSIZE 8
+#   else
+#       define C4_CPU_PPC
+#       define C4_WORDSIZE 4
+#   endif
+#   define C4_BYTE_ORDER _C4EM
+   // ppc is bi-endian - check byte order below
+
+#elif defined(__s390x__) || defined(__zarch__) || defined(__SYSC_ZARCH_)
+#   define C4_CPU_S390_X
+#   define C4_WORDSIZE 8
+#   define C4_BYTE_ORDER _C4EB
+
+#elif defined(__xtensa__) || defined(__XTENSA__)
+#   define C4_CPU_XTENSA
+#   define C4_WORDSIZE 4
+// not sure about this...
+#   if defined(__XTENSA_EL__) || defined(__xtensa_el__)
+#       define C4_BYTE_ORDER _C4EL
+#   else
+#       define C4_BYTE_ORDER _C4EB
+#   endif
+
+#elif defined(__riscv)
+#   if __riscv_xlen == 64
+#       define C4_CPU_RISCV64
+#       define C4_WORDSIZE 8
+#   else
+#       define C4_CPU_RISCV32
+#       define C4_WORDSIZE 4
+#   endif
+#   define C4_BYTE_ORDER _C4EL
+
+#elif defined(__EMSCRIPTEN__)
+#   define C4_BYTE_ORDER _C4EL
+#   define C4_WORDSIZE 4
+
+#elif defined(__loongarch__)
+#   if defined(__loongarch64)
+#       define C4_CPU_LOONGARCH64
+#       define C4_WORDSIZE 8
+#   else
+#       define C4_CPU_LOONGARCH
+#       define C4_WORDSIZE 4
+#   endif
+#   define C4_BYTE_ORDER _C4EL
+
+#elif defined(__mips__) || defined(_mips) || defined(mips)
+#   if defined(__mips)
+#       if __mips == 64
+#           define C4_CPU_MIPS64
+#           define C4_WORDSIZE 8
+#       elif __mips == 32
+#           define C4_CPU_MIPS32
+#           define C4_WORDSIZE 4
+#       endif
+#   elif defined(__arch64__) || (defined(__SIZE_WIDTH__) && __SIZE_WIDTH__ == 64) || (defined(__LP64__) && __LP64__)
+#       define C4_CPU_MIPS64
+#       define C4_WORDSIZE 8
+#   elif defined(__arch32__) || (defined(__SIZE_WIDTH__) && __SIZE_WIDTH__ == 32) || (defined(__LP32__) && __LP32__)
+#       define C4_CPU_MIPS32
+#       define C4_WORDSIZE 4
+#   else
+#       error "unknown mips architecture"
+#   endif
+#   if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#       define C4_BYTE_ORDER _C4EB
+#   elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#       define C4_BYTE_ORDER _C4EL
+#   else
+#       error "unknown mips endianness"
+#   endif
+
+#elif defined(__sparc__) || defined(__sparc) || defined(sparc)
+#   if defined(__arch64__) || (defined(__SIZE_WIDTH__) && __SIZE_WIDTH__ == 64) || (defined(__LP64__) && __LP64__)
+#       define C4_CPU_SPARC64
+#       define C4_WORDSIZE 8
+#   elif defined(__arch32__) || (defined(__SIZE_WIDTH__) && __SIZE_WIDTH__ == 32) || (defined(__LP32__) && __LP32__)
+#       define C4_CPU_SPARC32
+#       define C4_WORDSIZE 4
+#   else
+#       error "unknown sparc architecture"
+#   endif
+#   define C4_BYTE_ORDER _C4EB
+
+#elif defined(SWIG)
+#   error "please define CPU architecture macros when compiling with swig"
+
+#else
+#   error "unknown CPU architecture"
+#endif
+
+#define C4_LITTLE_ENDIAN (C4_BYTE_ORDER == _C4EL)
+#define C4_BIG_ENDIAN (C4_BYTE_ORDER == _C4EB)
+#define C4_MIXED_ENDIAN (C4_BYTE_ORDER == _C4EM)
+
+#endif /* _C4_CPU_HPP_ */
@@ -0,0 +1,440 @@
+#ifndef _C4_ERROR_HPP_
+#define _C4_ERROR_HPP_
+
+/** @file error.hpp Facilities for error reporting and runtime assertions. */
+
+/** @defgroup error_checking Error checking */
+
+#include "c4/config.hpp"
+
+#ifdef _DOXYGEN_
+    /** if this is defined and exceptions are enabled, then calls to C4_ERROR()
+     * will throw an exception
+     * @ingroup error_checking */
+#   define C4_EXCEPTIONS_ENABLED
+    /** if this is defined and exceptions are enabled, then calls to C4_ERROR()
+     *  will throw an exception
+     * @see C4_EXCEPTIONS_ENABLED
+     * @ingroup error_checking */
+#   define C4_ERROR_THROWS_EXCEPTION
+    /** evaluates to noexcept when C4_ERROR might be called and
+     * exceptions are disabled. Otherwise, defaults to nothing.
+     * @ingroup error_checking */
+#   define C4_NOEXCEPT
+#endif // _DOXYGEN_
+
+#if defined(C4_EXCEPTIONS_ENABLED) && defined(C4_ERROR_THROWS_EXCEPTION)
+#   define C4_NOEXCEPT
+#else
+#   define C4_NOEXCEPT noexcept
+#endif
+
+
+namespace c4 {
+namespace detail {
+struct fail_type__ {};
+} // detail
+} // c4
+#define C4_STATIC_ERROR(dummy_type, errmsg)                             \
+    static_assert(std::is_same<dummy_type, c4::detail::fail_type__>::value, errmsg)
+
+
+//-----------------------------------------------------------------------------
+
+#define C4_ASSERT_SAME_TYPE(ty1, ty2)                       \
+    C4_STATIC_ASSERT(std::is_same<ty1 C4_COMMA_X ty2>::value)
+
+#define C4_ASSERT_DIFF_TYPE(ty1, ty2)                       \
+    C4_STATIC_ASSERT( ! std::is_same<ty1 C4_COMMA_X ty2>::value)
+
+
+//-----------------------------------------------------------------------------
+
+#ifdef _DOXYGEN_
+/** utility macro that triggers a breakpoint when
+ * the debugger is attached and NDEBUG is not defined.
+ * @ingroup error_checking */
+#   define C4_DEBUG_BREAK()
+#endif // _DOXYGEN_
+
+
+#if defined(NDEBUG) || defined(C4_NO_DEBUG_BREAK)
+#   define C4_DEBUG_BREAK()
+#else
+#   ifdef __clang__
+#       pragma clang diagnostic push
+#       pragma clang diagnostic ignored "-Wundef"
+#       if !defined(__APPLE_CC__)
+#           if __clang_major__ >= 10
+#               pragma clang diagnostic ignored "-Wgnu-inline-cpp-without-extern" // debugbreak/debugbreak.h:50:16: error: 'gnu_inline' attribute without 'extern' in C++ treated as externally available, this changed in Clang 10 [-Werror,-Wgnu-inline-cpp-without-extern]
+#           endif
+#       else
+#           if __clang_major__ >= 13
+#               pragma clang diagnostic ignored "-Wgnu-inline-cpp-without-extern" // debugbreak/debugbreak.h:50:16: error: 'gnu_inline' attribute without 'extern' in C++ treated as externally available, this changed in Clang 10 [-Werror,-Wgnu-inline-cpp-without-extern]
+#           endif
+#       endif
+#   elif defined(__GNUC__)
+#       pragma GCC diagnostic push
+#       pragma GCC diagnostic ignored "-Wundef"
+#   endif
+#   include <c4/ext/debugbreak/debugbreak.h>
+#   define C4_DEBUG_BREAK() if(c4::is_debugger_attached()) { ::debug_break(); }
+#   ifdef __clang__
+#       pragma clang diagnostic pop
+#   elif defined(__GNUC__)
+#       pragma GCC diagnostic pop
+#   endif
+#endif
+
+namespace c4 {
+C4CORE_EXPORT bool is_debugger_attached();
+} // namespace c4
+
+
+//-----------------------------------------------------------------------------
+
+#ifdef __clang__
+    /* NOTE: using , ## __VA_ARGS__ to deal with zero-args calls to
+     * variadic macros is not portable, but works in clang, gcc, msvc, icc.
+     * clang requires switching off compiler warnings for pedantic mode.
+     * @see http://stackoverflow.com/questions/32047685/variadic-macro-without-arguments */
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" // warning: token pasting of ',' and __VA_ARGS__ is a GNU extension
+#elif defined(__GNUC__)
+    /* GCC also issues a warning for zero-args calls to variadic macros.
+     * This warning is switched on with -pedantic and apparently there is no
+     * easy way to turn it off as with clang. But marking this as a system
+     * header works.
+     * @see https://gcc.gnu.org/onlinedocs/cpp/System-Headers.html
+     * @see http://stackoverflow.com/questions/35587137/ */
+#   pragma GCC system_header
+#endif
+
+
+//-----------------------------------------------------------------------------
+
+namespace c4 {
+
+typedef enum : uint32_t {
+    /** when an error happens and the debugger is attached, call C4_DEBUG_BREAK().
+     * Without effect otherwise. */
+    ON_ERROR_DEBUGBREAK = 0x01u << 0u,
+    /** when an error happens log a message. */
+    ON_ERROR_LOG = 0x01u << 1u,
+    /** when an error happens invoke a callback if it was set with
+     * set_error_callback(). */
+    ON_ERROR_CALLBACK = 0x01u << 2u,
+    /** when an error happens call std::terminate(). */
+    ON_ERROR_ABORT = 0x01u << 3u,
+    /** when an error happens and exceptions are enabled throw an exception.
+     * Without effect otherwise. */
+    ON_ERROR_THROW = 0x01u << 4u,
+    /** the default flags. */
+    ON_ERROR_DEFAULTS = ON_ERROR_DEBUGBREAK|ON_ERROR_LOG|ON_ERROR_CALLBACK|ON_ERROR_ABORT
+} ErrorFlags_e;
+using error_flags = uint32_t;
+C4CORE_EXPORT void set_error_flags(error_flags f);
+C4CORE_EXPORT error_flags get_error_flags();
+
+
+using error_callback_type = void (*)(const char* msg, size_t msg_size);
+C4CORE_EXPORT void set_error_callback(error_callback_type cb);
+C4CORE_EXPORT error_callback_type get_error_callback();
+
+
+//-----------------------------------------------------------------------------
+/** RAII class controling the error settings inside a scope. */
+struct ScopedErrorSettings // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+    error_flags m_flags;
+    error_callback_type m_callback;
+
+    explicit ScopedErrorSettings(error_callback_type cb)
+    :   m_flags(get_error_flags()),
+        m_callback(get_error_callback())
+    {
+        set_error_callback(cb);
+    }
+    explicit ScopedErrorSettings(error_flags flags)
+    :   m_flags(get_error_flags()),
+        m_callback(get_error_callback())
+    {
+        set_error_flags(flags);
+    }
+    explicit ScopedErrorSettings(error_flags flags, error_callback_type cb)
+    :   m_flags(get_error_flags()),
+        m_callback(get_error_callback())
+    {
+        set_error_flags(flags);
+        set_error_callback(cb);
+    }
+    ~ScopedErrorSettings()
+    {
+        set_error_flags(m_flags);
+        set_error_callback(m_callback);
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+
+/** source location */
+struct srcloc;
+
+// watchout: for VS the [[noreturn]] needs to come before other annotations like C4CORE_EXPORT
+[[noreturn]] C4CORE_EXPORT void handle_error(srcloc s, const char *fmt, ...);
+C4CORE_EXPORT void handle_warning(srcloc s, const char *fmt, ...);
+
+
+#   define C4_ERROR(msg, ...)                               \
+    do {                                                    \
+        if(c4::get_error_flags() & c4::ON_ERROR_DEBUGBREAK) \
+        {                                                   \
+            C4_DEBUG_BREAK()                                \
+        }                                                   \
+        c4::handle_error(C4_SRCLOC(), msg, ## __VA_ARGS__); \
+    } while(0)
+
+
+#   define C4_WARNING(msg, ...)                             \
+    c4::handle_warning(C4_SRCLOC(), msg, ## __VA_ARGS__)
+
+
+#if defined(C4_ERROR_SHOWS_FILELINE) && defined(C4_ERROR_SHOWS_FUNC)
+
+struct srcloc
+{
+    const char *file = "";
+    const char *func = "";
+    int line = 0;
+};
+#define C4_SRCLOC() c4::srcloc{__FILE__, C4_PRETTY_FUNC, __LINE__}
+
+#elif defined(C4_ERROR_SHOWS_FILELINE)
+
+struct srcloc
+{
+    const char *file;
+    int line;
+};
+#define C4_SRCLOC() c4::srcloc{__FILE__, __LINE__}
+
+#elif ! defined(C4_ERROR_SHOWS_FUNC)
+
+struct srcloc
+{
+};
+#define C4_SRCLOC() c4::srcloc()
+
+#else
+#   error not implemented
+#endif
+
+
+//-----------------------------------------------------------------------------
+// assertions
+
+// Doxygen needs this so that only one definition counts
+#ifdef _DOXYGEN_
+    /** Explicitly enables assertions, independently of NDEBUG status.
+     * This is meant to allow enabling assertions even when NDEBUG is defined.
+     * Defaults to undefined.
+     * @ingroup error_checking */
+#   define C4_USE_ASSERT
+    /** assert that a condition is true; this is turned off when NDEBUG
+     * is defined and C4_USE_ASSERT is not true.
+     * @ingroup error_checking  */
+#   define C4_ASSERT
+    /** same as C4_ASSERT(), additionally prints a printf-formatted message
+     * @ingroup error_checking */
+#   define C4_ASSERT_MSG
+    /** evaluates to C4_NOEXCEPT when C4_XASSERT is disabled; otherwise, defaults
+     * to noexcept
+     * @ingroup error_checking */
+#   define C4_NOEXCEPT_A
+#endif // _DOXYGEN_
+
+#ifndef C4_USE_ASSERT
+#   ifdef NDEBUG
+#       define C4_USE_ASSERT 0
+#   else
+#       define C4_USE_ASSERT 1
+#   endif
+#endif
+
+#if C4_USE_ASSERT
+#   define C4_ASSERT(cond) C4_CHECK(cond)
+#   define C4_ASSERT_MSG(cond, /*fmt, */...) C4_CHECK_MSG(cond, ## __VA_ARGS__)
+#   define C4_ASSERT_IF(predicate, cond) if(predicate) { C4_ASSERT(cond); }
+#   define C4_NOEXCEPT_A C4_NOEXCEPT
+#else
+#   define C4_ASSERT(cond)
+#   define C4_ASSERT_MSG(cond, /*fmt, */...)
+#   define C4_ASSERT_IF(predicate, cond)
+#   define C4_NOEXCEPT_A noexcept
+#endif
+
+
+//-----------------------------------------------------------------------------
+// extreme assertions
+
+// Doxygen needs this so that only one definition counts
+#ifdef _DOXYGEN_
+    /** Explicitly enables extreme assertions; this is meant to allow enabling
+     * assertions even when NDEBUG is defined. Defaults to undefined.
+     * @ingroup error_checking */
+#   define C4_USE_XASSERT
+    /** extreme assertion: can be switched off independently of
+     * the regular assertion; use for example for bounds checking in hot code.
+     * Turned on only when C4_USE_XASSERT is defined
+     * @ingroup error_checking */
+#   define C4_XASSERT
+    /** same as C4_XASSERT(), and additionally prints a printf-formatted message
+     * @ingroup error_checking */
+#   define C4_XASSERT_MSG
+    /** evaluates to C4_NOEXCEPT when C4_XASSERT is disabled; otherwise, defaults to noexcept
+     * @ingroup error_checking */
+#   define C4_NOEXCEPT_X
+#endif // _DOXYGEN_
+
+#ifndef C4_USE_XASSERT
+#   define C4_USE_XASSERT C4_USE_ASSERT
+#endif
+
+#if C4_USE_XASSERT
+#   define C4_XASSERT(cond) C4_CHECK(cond)
+#   define C4_XASSERT_MSG(cond, /*fmt, */...) C4_CHECK_MSG(cond, ## __VA_ARGS__)
+#   define C4_XASSERT_IF(predicate, cond) if(predicate) { C4_XASSERT(cond); }
+#   define C4_NOEXCEPT_X C4_NOEXCEPT
+#else
+#   define C4_XASSERT(cond)
+#   define C4_XASSERT_MSG(cond, /*fmt, */...)
+#   define C4_XASSERT_IF(predicate, cond)
+#   define C4_NOEXCEPT_X noexcept
+#endif
+
+
+//-----------------------------------------------------------------------------
+// checks: never switched-off
+
+/** Check that a condition is true, or raise an error when not
+ * true. Unlike C4_ASSERT(), this check is not disabled in non-debug
+ * builds.
+ * @see C4_ASSERT
+ * @ingroup error_checking
+ *
+ * @todo add constexpr-compatible compile-time assert:
+ * https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
+ */
+#define C4_CHECK(cond)                              \
+    do {                                            \
+        if(C4_UNLIKELY(!(cond)))                    \
+        {                                           \
+            C4_ERROR("check failed: %s", #cond);    \
+        }                                           \
+    } while(0)
+
+
+/** like C4_CHECK(), and additionally log a printf-style message.
+ * @see C4_CHECK
+ * @ingroup error_checking */
+#define C4_CHECK_MSG(cond, fmt, ...)                                    \
+    do {                                                                \
+        if(C4_UNLIKELY(!(cond)))                                        \
+        {                                                               \
+            C4_ERROR("check failed: " #cond "\n" fmt, ## __VA_ARGS__);  \
+        }                                                               \
+    } while(0)
+
+
+//-----------------------------------------------------------------------------
+// Common error conditions
+
+#define C4_NOT_IMPLEMENTED() C4_ERROR("NOT IMPLEMENTED")
+#define C4_NOT_IMPLEMENTED_MSG(/*msg, */...) C4_ERROR("NOT IMPLEMENTED: " __VA_ARGS__)
+#define C4_NOT_IMPLEMENTED_IF(condition) do { if(C4_UNLIKELY(condition)) { C4_ERROR("NOT IMPLEMENTED"); } } while(0)
+#define C4_NOT_IMPLEMENTED_IF_MSG(condition, /*msg, */...) do { if(C4_UNLIKELY(condition)) { C4_ERROR("NOT IMPLEMENTED: " __VA_ARGS__); } } while(0)
+
+#define C4_NEVER_REACH() do { C4_ERROR("never reach this point"); C4_UNREACHABLE(); } while(0)
+#define C4_NEVER_REACH_MSG(/*msg, */...) do { C4_ERROR("never reach this point: " __VA_ARGS__); C4_UNREACHABLE(); } while(0)
+
+
+
+//-----------------------------------------------------------------------------
+// helpers for warning suppression
+// idea adapted from https://github.com/onqtam/doctest/
+
+// TODO: add C4_MESSAGE() https://stackoverflow.com/questions/18252351/custom-preprocessor-macro-for-a-conditional-pragma-message-xxx?rq=1
+
+
+#ifdef C4_MSVC
+#define C4_SUPPRESS_WARNING_MSVC_PUSH __pragma(warning(push))
+#define C4_SUPPRESS_WARNING_MSVC(w)  __pragma(warning(disable : w))
+#define C4_SUPPRESS_WARNING_MSVC_POP __pragma(warning(pop))
+#else // C4_MSVC
+#define C4_SUPPRESS_WARNING_MSVC_PUSH
+#define C4_SUPPRESS_WARNING_MSVC(w)
+#define C4_SUPPRESS_WARNING_MSVC_POP
+#endif // C4_MSVC
+
+
+#ifdef C4_CLANG
+#define C4_PRAGMA_TO_STR(x) _Pragma(#x)
+#define C4_SUPPRESS_WARNING_CLANG_PUSH _Pragma("clang diagnostic push")
+#define C4_SUPPRESS_WARNING_CLANG(w) C4_PRAGMA_TO_STR(clang diagnostic ignored w)
+#define C4_SUPPRESS_WARNING_CLANG_POP _Pragma("clang diagnostic pop")
+#else // C4_CLANG
+#define C4_SUPPRESS_WARNING_CLANG_PUSH
+#define C4_SUPPRESS_WARNING_CLANG(w)
+#define C4_SUPPRESS_WARNING_CLANG_POP
+#endif // C4_CLANG
+
+
+#ifdef C4_GCC
+#define C4_PRAGMA_TO_STR(x) _Pragma(#x)
+#define C4_SUPPRESS_WARNING_GCC_PUSH _Pragma("GCC diagnostic push")
+#define C4_SUPPRESS_WARNING_GCC(w) C4_PRAGMA_TO_STR(GCC diagnostic ignored w)
+#define C4_SUPPRESS_WARNING_GCC_POP _Pragma("GCC diagnostic pop")
+#else // C4_GCC
+#define C4_SUPPRESS_WARNING_GCC_PUSH
+#define C4_SUPPRESS_WARNING_GCC(w)
+#define C4_SUPPRESS_WARNING_GCC_POP
+#endif // C4_GCC
+
+
+#define C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(w)   \
+    C4_SUPPRESS_WARNING_MSVC_PUSH               \
+    C4_SUPPRESS_WARNING_MSVC(w)
+
+#define C4_SUPPRESS_WARNING_CLANG_WITH_PUSH(w)  \
+    C4_SUPPRESS_WARNING_CLANG_PUSH              \
+    C4_SUPPRESS_WARNING_CLANG(w)
+
+#define C4_SUPPRESS_WARNING_GCC_WITH_PUSH(w)    \
+    C4_SUPPRESS_WARNING_GCC_PUSH                \
+    C4_SUPPRESS_WARNING_GCC(w)
+
+
+#define C4_SUPPRESS_WARNING_GCC_CLANG_PUSH \
+    C4_SUPPRESS_WARNING_GCC_PUSH     \
+    C4_SUPPRESS_WARNING_CLANG_PUSH
+
+#define C4_SUPPRESS_WARNING_GCC_CLANG(w) \
+    C4_SUPPRESS_WARNING_GCC(w)     \
+    C4_SUPPRESS_WARNING_CLANG(w)
+
+#define C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH(w) \
+    C4_SUPPRESS_WARNING_GCC_WITH_PUSH(w)     \
+    C4_SUPPRESS_WARNING_CLANG_WITH_PUSH(w)
+
+#define C4_SUPPRESS_WARNING_GCC_CLANG_POP \
+    C4_SUPPRESS_WARNING_GCC_POP     \
+    C4_SUPPRESS_WARNING_CLANG_POP
+
+} // namespace c4
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif /* _C4_ERROR_HPP_ */
@@ -0,0 +1,18 @@
+#ifndef C4_EXPORT_HPP_
+#define C4_EXPORT_HPP_
+
+#ifdef _WIN32
+    #ifdef C4CORE_SHARED
+        #ifdef C4CORE_EXPORTS
+            #define C4CORE_EXPORT __declspec(dllexport)
+        #else
+            #define C4CORE_EXPORT __declspec(dllimport)
+        #endif
+    #else
+        #define C4CORE_EXPORT
+    #endif
+#else
+    #define C4CORE_EXPORT
+#endif
+
+#endif /* C4CORE_EXPORT_HPP_ */
@@ -0,0 +1,358 @@
+#ifndef _C4_LANGUAGE_HPP_
+#define _C4_LANGUAGE_HPP_
+
+/** @file language.hpp Provides language standard information macros and
+ * compiler agnostic utility macros: namespace facilities, function attributes,
+ * variable attributes, etc.
+ * @ingroup basic_headers */
+
+#include "c4/preprocessor.hpp"
+#include "c4/compiler.hpp"
+
+/* Detect C++ standard.
+ * @see http://stackoverflow.com/a/7132549/5875572 */
+#ifndef C4_CPP
+#   if defined(_MSC_VER) && !defined(__clang__)
+#       if _MSC_VER >= 1910  // >VS2015: VS2017, VS2019, VS2022
+#           if (!defined(_MSVC_LANG))
+#               error _MSVC not defined
+#           endif
+#           if _MSVC_LANG >= 201705L
+#               define C4_CPP 20
+#               define C4_CPP20
+#           elif _MSVC_LANG == 201703L
+#               define C4_CPP 17
+#               define C4_CPP17
+#           elif _MSVC_LANG >= 201402L
+#               define C4_CPP 14
+#               define C4_CPP14
+#           elif _MSVC_LANG >= 201103L
+#               define C4_CPP 11
+#               define C4_CPP11
+#           else
+#               error C++ lesser than C++11 not supported
+#           endif
+#       else
+#           if _MSC_VER == 1900
+#               define C4_CPP 14  // VS2015 is c++14 https://devblogs.microsoft.com/cppblog/c111417-features-in-vs-2015-rtm/
+#               define C4_CPP14
+#           elif _MSC_VER == 1800 // VS2013
+#               define C4_CPP 11
+#               define C4_CPP11
+#           else
+#               error C++ lesser than C++11 not supported
+#           endif
+#       endif
+#   elif defined(__INTEL_COMPILER) // https://software.intel.com/en-us/node/524490
+#       ifdef __INTEL_CXX20_MODE__ // not sure about this
+#           define C4_CPP 20
+#           define C4_CPP20
+#       elif defined __INTEL_CXX17_MODE__ // not sure about this
+#           define C4_CPP 17
+#           define C4_CPP17
+#       elif defined __INTEL_CXX14_MODE__ // not sure about this
+#           define C4_CPP 14
+#           define C4_CPP14
+#       elif defined __INTEL_CXX11_MODE__
+#           define C4_CPP 11
+#           define C4_CPP11
+#       else
+#           error C++ lesser than C++11 not supported
+#       endif
+#   else
+#       ifndef __cplusplus
+#           error __cplusplus is not defined?
+#       endif
+#       if __cplusplus == 1
+#           error cannot handle __cplusplus==1
+#       elif __cplusplus >= 201709L
+#           define C4_CPP 20
+#           define C4_CPP20
+#       elif __cplusplus >= 201703L
+#           define C4_CPP 17
+#           define C4_CPP17
+#       elif __cplusplus >= 201402L
+#           define C4_CPP 14
+#           define C4_CPP14
+#       elif __cplusplus >= 201103L
+#           define C4_CPP 11
+#           define C4_CPP11
+#       elif __cplusplus >= 199711L
+#           error C++ lesser than C++11 not supported
+#       endif
+#   endif
+#else
+#   ifdef C4_CPP == 20
+#       define C4_CPP20
+#   elif C4_CPP == 17
+#       define C4_CPP17
+#   elif C4_CPP == 14
+#       define C4_CPP14
+#   elif C4_CPP == 11
+#       define C4_CPP11
+#   elif C4_CPP == 98
+#       define C4_CPP98
+#       error C++ lesser than C++11 not supported
+#   else
+#       error C4_CPP must be one of 20, 17, 14, 11, 98
+#   endif
+#endif
+
+#ifdef C4_CPP20
+#   define C4_CPP17
+#   define C4_CPP14
+#   define C4_CPP11
+#elif defined(C4_CPP17)
+#   define C4_CPP14
+#   define C4_CPP11
+#elif defined(C4_CPP14)
+#   define C4_CPP11
+#endif
+
+/** lifted from this answer: http://stackoverflow.com/a/20170989/5875572 */
+#if defined(_MSC_VER) && !defined(__clang__)
+#  if _MSC_VER < 1900
+#    define C4_CONSTEXPR11
+#    define C4_CONSTEXPR14
+#  elif _MSC_VER < 2000
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14
+#  else
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14 constexpr
+#  endif
+#else
+#  if __cplusplus < 201103
+#    define C4_CONSTEXPR11
+#    define C4_CONSTEXPR14
+#  elif __cplusplus == 201103
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14
+#  else
+#    define C4_CONSTEXPR11 constexpr
+#    define C4_CONSTEXPR14 constexpr
+#  endif
+#endif  // _MSC_VER
+
+
+#if C4_CPP < 17
+#define C4_IF_CONSTEXPR
+#define C4_INLINE_CONSTEXPR constexpr
+#else
+#define C4_IF_CONSTEXPR constexpr
+#define C4_INLINE_CONSTEXPR inline constexpr
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#  if (defined(_CPPUNWIND) && (_CPPUNWIND == 1))
+#    define C4_EXCEPTIONS
+#  endif
+#else
+#  if defined(__EXCEPTIONS) || defined(__cpp_exceptions)
+#    define C4_EXCEPTIONS
+#  endif
+#endif
+
+#ifdef C4_EXCEPTIONS
+#  define C4_IF_EXCEPTIONS_(exc_code, setjmp_code) exc_code
+#  define C4_IF_EXCEPTIONS(exc_code, setjmp_code) do { exc_code } while(0)
+#else
+#  define C4_IF_EXCEPTIONS_(exc_code, setjmp_code) setjmp_code
+#  define C4_IF_EXCEPTIONS(exc_code, setjmp_code) do { setjmp_code } while(0)
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#  if defined(_CPPRTTI)
+#    define C4_RTTI
+#  endif
+#else
+#  if defined(__GXX_RTTI)
+#    define C4_RTTI
+#  endif
+#endif
+
+#ifdef C4_RTTI
+#  define C4_IF_RTTI_(code_rtti, code_no_rtti) code_rtti
+#  define C4_IF_RTTI(code_rtti, code_no_rtti) do { code_rtti } while(0)
+#else
+#  define C4_IF_RTTI_(code_rtti, code_no_rtti) code_no_rtti
+#  define C4_IF_RTTI(code_rtti, code_no_rtti) do { code_no_rtti } while(0)
+#endif
+
+
+//------------------------------------------------------------
+
+#define _C4_BEGIN_NAMESPACE(ns) namespace ns {
+#define _C4_END_NAMESPACE(ns)   }
+
+// MSVC cant handle the C4_FOR_EACH macro... need to fix this
+//#define C4_BEGIN_NAMESPACE(...) C4_FOR_EACH_SEP(_C4_BEGIN_NAMESPACE, , __VA_ARGS__)
+//#define C4_END_NAMESPACE(...) C4_FOR_EACH_SEP(_C4_END_NAMESPACE, , __VA_ARGS__)
+#define C4_BEGIN_NAMESPACE(ns) namespace ns {
+#define C4_END_NAMESPACE(ns) }
+
+#define C4_BEGIN_HIDDEN_NAMESPACE namespace /*hidden*/ {
+#define C4_END_HIDDEN_NAMESPACE } /* namespace hidden */
+
+//------------------------------------------------------------
+
+#ifndef C4_API
+#   if defined(_MSC_VER) && !defined(__clang__)
+#       if defined(C4_EXPORT)
+#           define C4_API __declspec(dllexport)
+#       elif defined(C4_IMPORT)
+#           define C4_API __declspec(dllimport)
+#       else
+#           define C4_API
+#       endif
+#   else
+#       define C4_API
+#   endif
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#   define C4_RESTRICT __restrict
+#   define C4_RESTRICT_FN __declspec(restrict)
+#   define C4_NO_INLINE __declspec(noinline)
+#   define C4_ALWAYS_INLINE inline __forceinline
+/** these are not available in VS AFAIK */
+#   define C4_CONST
+#   define C4_PURE
+#   define C4_FLATTEN
+#   define C4_HOT         /** @todo */
+#   define C4_COLD        /** @todo */
+#   define C4_ASSUME(...) __assume(__VA_ARGS__)
+#   define C4_EXPECT(x, y) x /** @todo */
+#   define C4_LIKELY(x)   x
+#   define C4_UNLIKELY(x) x
+#   define C4_UNREACHABLE() _c4_msvc_unreachable()
+#   define C4_ATTR_FORMAT(...) /** */
+#   define C4_NORETURN [[noreturn]]
+#   if _MSC_VER >= 1700 // VS2012
+#       define C4_NODISCARD _Check_return_
+#   else
+#       define C4_NODISCARD
+#   endif
+[[noreturn]] __forceinline void _c4_msvc_unreachable() { __assume(false); } ///< https://stackoverflow.com/questions/60802864/emulating-gccs-builtin-unreachable-in-visual-studio
+#   define C4_UNREACHABLE_AFTER_ERR() /* */
+#else
+    ///< @todo assuming gcc-like compiler. check it is actually so.
+/** for function attributes in GCC,
+ * @see https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes */
+/** for __builtin functions in GCC,
+ * @see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html */
+#   define C4_RESTRICT __restrict__
+#   define C4_RESTRICT_FN __attribute__((restrict))
+#   define C4_NO_INLINE __attribute__((noinline))
+#   define C4_ALWAYS_INLINE inline __attribute__((always_inline))
+#   define C4_CONST __attribute__((const))
+#   define C4_PURE __attribute__((pure))
+/** force inlining of every callee function */
+#   define C4_FLATTEN __atribute__((flatten))
+/** mark a function as hot, ie as having a visible impact in CPU time
+ * thus making it more likely to inline, etc
+ * @see http://stackoverflow.com/questions/15028990/semantics-of-gcc-hot-attribute */
+#   define C4_HOT __attribute__((hot))
+/** mark a function as cold, ie as NOT having a visible impact in CPU time
+ * @see http://stackoverflow.com/questions/15028990/semantics-of-gcc-hot-attribute */
+#   define C4_COLD __attribute__((cold))
+#   define C4_EXPECT(x, y) __builtin_expect(x, y) ///< @see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
+#   define C4_LIKELY(x)   __builtin_expect(x, 1)
+#   define C4_UNLIKELY(x) __builtin_expect(x, 0)
+#   define C4_UNREACHABLE() __builtin_unreachable()
+#   define C4_ATTR_FORMAT(...) //__attribute__((format (__VA_ARGS__))) ///< @see https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#Common-Function-Attributes
+#   define C4_NORETURN __attribute__((noreturn))
+#   define C4_NODISCARD __attribute__((warn_unused_result))
+#   define C4_UNREACHABLE_AFTER_ERR() C4_UNREACHABLE()
+// C4_ASSUME
+// see https://stackoverflow.com/questions/63493968/reproducing-clangs-builtin-assume-for-gcc
+// preferred option: C++ standard attribute
+#   ifdef __has_cpp_attribute
+#       if __has_cpp_attribute(assume) >= 202207L
+#           define C4_ASSUME(...) [[assume(__VA_ARGS__)]]
+#       endif
+#   endif
+// first fallback: compiler intrinsics/attributes for assumptions
+#   ifndef C4_ASSUME
+#       if defined(__clang__)
+#           define C4_ASSUME(...) __builtin_assume(__VA_ARGS__)
+#       elif defined(__GNUC__)
+#       if __GNUC__ >= 13
+#           define C4_ASSUME(...) __attribute__((__assume__(__VA_ARGS__)))
+#       endif
+#       endif
+#   endif
+// second fallback: possibly evaluating uses of unreachable()
+// Set this to 1 if you want to allow assumptions to possibly evaluate.
+#   ifndef C4_ASSUME_ALLOW_EVAL
+#       define C4_ASSUME_ALLOW_EVAL 0
+#   endif
+#   if !defined(C4_ASSUME) && (C4_ASSUME_ALLOW_EVAL)
+#       define C4_ASSUME(...) do { if (!bool(__VA_ARGS__)) C4_UNREACHABLE(); ) while(0)
+#   endif
+// last fallback: define macro as doing nothing
+#   ifndef C4_ASSUME
+#       define C4_ASSUME(...)
+#   endif
+#endif
+
+
+#if C4_CPP >= 14
+#   define C4_DEPRECATED(msg) [[deprecated(msg)]]
+#else
+#   if defined(_MSC_VER)
+#       define C4_DEPRECATED(msg) __declspec(deprecated(msg))
+#   else // defined(__GNUC__) || defined(__clang__)
+#       define C4_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#   endif
+#endif
+
+
+#ifdef _MSC_VER
+#   define C4_FUNC __FUNCTION__
+#   define C4_PRETTY_FUNC __FUNCSIG__
+#else /// @todo assuming gcc-like compiler. check it is actually so.
+#   define C4_FUNC __FUNCTION__
+#   define C4_PRETTY_FUNC __PRETTY_FUNCTION__
+#endif
+
+/** prevent compiler warnings about a specific var being unused */
+#define C4_UNUSED(var) (void)var
+
+#if C4_CPP >= 17
+#define C4_STATIC_ASSERT(cond) static_assert(cond)
+#else
+#define C4_STATIC_ASSERT(cond) static_assert((cond), #cond)
+#endif
+#define C4_STATIC_ASSERT_MSG(cond, msg) static_assert((cond), #cond ": " msg)
+
+/** @def C4_DONT_OPTIMIZE idea lifted from GoogleBenchmark.
+ * @see https://github.com/google/benchmark/blob/master/include/benchmark/benchmark_api.h */
+namespace c4 {
+namespace detail {
+#ifdef __GNUC__
+#   define C4_DONT_OPTIMIZE(var) c4::detail::dont_optimize(var)
+template< class T >
+C4_ALWAYS_INLINE void dont_optimize(T const& value) { asm volatile("" : : "g"(value) : "memory"); } // NOLINT
+#else
+#   define C4_DONT_OPTIMIZE(var) c4::detail::use_char_pointer(reinterpret_cast< const char* >(&var))
+void use_char_pointer(char const volatile*);
+#endif
+} // namespace detail
+} // namespace c4
+
+/** @def C4_KEEP_EMPTY_LOOP prevent an empty loop from being optimized out.
+ * @see http://stackoverflow.com/a/7084193/5875572 */
+#if defined(_MSC_VER) && !defined(__clang__)
+#   define C4_KEEP_EMPTY_LOOP { char c; C4_DONT_OPTIMIZE(c); }
+#else
+#   define C4_KEEP_EMPTY_LOOP { asm(""); }
+#endif
+
+/** @def C4_VA_LIST_REUSE_MUST_COPY
+ * @todo <jpmag> I strongly suspect that this is actually only in UNIX platforms. revisit this. */
+#ifdef __GNUC__
+#   define C4_VA_LIST_REUSE_MUST_COPY
+#endif
+
+#endif /* _C4_LANGUAGE_HPP_ */
@@ -0,0 +1,46 @@
+#ifndef _C4_PLATFORM_HPP_
+#define _C4_PLATFORM_HPP_
+
+/** @file platform.hpp Provides platform information macros
+ * @ingroup basic_headers */
+
+// see also https://sourceforge.net/p/predef/wiki/OperatingSystems/
+
+#if defined(_WIN64)
+#   define C4_WIN
+#   define C4_WIN64
+#elif defined(_WIN32)
+#   define C4_WIN
+#   define C4_WIN32
+#elif defined(__ANDROID__)
+#   define C4_ANDROID
+#elif defined(__APPLE__)
+#   include "TargetConditionals.h"
+#   if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+#       define C4_IOS
+#   elif TARGET_OS_MAC || TARGET_OS_OSX
+#       define C4_MACOS
+#   else
+#       error "Unknown Apple platform"
+#   endif
+#elif defined(__linux__) || defined(__linux)
+#   define C4_UNIX
+#   define C4_LINUX
+#elif defined(__unix__) || defined(__unix)
+#   define C4_UNIX
+#elif defined(__arm__) || defined(__aarch64__)
+#   define C4_ARM
+#elif defined(__xtensa__) || defined(__XTENSA__)
+#   define C4_XTENSA
+#elif defined(SWIG)
+#   define C4_SWIG
+#else
+#   error "unknown platform"
+#endif
+
+#if defined(__posix) || defined(C4_UNIX) || defined(C4_LINUX)
+#   define C4_POSIX
+#endif
+
+
+#endif /* _C4_PLATFORM_HPP_ */
@@ -0,0 +1,123 @@
+#ifndef _C4_PREPROCESSOR_HPP_
+#define _C4_PREPROCESSOR_HPP_
+
+/** @file preprocessor.hpp Contains basic macros and preprocessor utilities.
+ * @ingroup basic_headers */
+
+#ifdef __clang__
+    /* NOTE: using , ## __VA_ARGS__ to deal with zero-args calls to
+     * variadic macros is not portable, but works in clang, gcc, msvc, icc.
+     * clang requires switching off compiler warnings for pedantic mode.
+     * @see http://stackoverflow.com/questions/32047685/variadic-macro-without-arguments */
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments" // warning: token pasting of ',' and __VA_ARGS__ is a GNU extension
+#elif defined(__GNUC__)
+    /* GCC also issues a warning for zero-args calls to variadic macros.
+     * This warning is switched on with -pedantic and apparently there is no
+     * easy way to turn it off as with clang. But marking this as a system
+     * header works.
+     * @see https://gcc.gnu.org/onlinedocs/cpp/System-Headers.html
+     * @see http://stackoverflow.com/questions/35587137/ */
+#   pragma GCC system_header
+#endif
+
+#define C4_WIDEN(str) L"" str
+
+#define C4_COUNTOF(arr) (sizeof(arr)/sizeof((arr)[0]))
+
+#define C4_EXPAND(arg) arg
+
+/** useful in some macro calls with template arguments */
+#define C4_COMMA ,
+/** useful in some macro calls with template arguments
+ * @see C4_COMMA */
+#define C4_COMMA_X C4_COMMA
+
+/** expand and quote */
+#define C4_XQUOTE(arg) _C4_XQUOTE(arg)
+#define _C4_XQUOTE(arg) C4_QUOTE(arg)
+#define C4_QUOTE(arg) #arg
+
+/** expand and concatenate */
+#define C4_XCAT(arg1, arg2) _C4_XCAT(arg1, arg2)
+#define _C4_XCAT(arg1, arg2) C4_CAT(arg1, arg2)
+#define C4_CAT(arg1, arg2) arg1##arg2
+
+#define C4_VERSION_CAT(major, minor, patch) ((major)*10000 + (minor)*100 + (patch))
+
+/** A preprocessor foreach. Spectacular trick taken from:
+ * http://stackoverflow.com/a/1872506/5875572
+ * The first argument is for a macro receiving a single argument,
+ * which will be called with every subsequent argument. There is
+ * currently a limit of 32 arguments, and at least 1 must be provided.
+ *
+Example:
+@code{.cpp}
+struct Example {
+    int a;
+    int b;
+    int c;
+};
+// define a one-arg macro to be called
+#define PRN_STRUCT_OFFSETS(field) PRN_STRUCT_OFFSETS_(Example, field)
+#define PRN_STRUCT_OFFSETS_(structure, field) printf(C4_XQUOTE(structure) ":" C4_XQUOTE(field)" - offset=%zu\n", offsetof(structure, field));
+
+// now call the macro for a, b and c
+C4_FOR_EACH(PRN_STRUCT_OFFSETS, a, b, c);
+@endcode */
+#define C4_FOR_EACH(what, ...) C4_FOR_EACH_SEP(what, ;, __VA_ARGS__)
+
+/** same as C4_FOR_EACH(), but use a custom separator between statements.
+ * If a comma is needed as the separator, use the C4_COMMA macro.
+ * @see C4_FOR_EACH
+ * @see C4_COMMA
+ */
+#define C4_FOR_EACH_SEP(what, sep, ...) _C4_FOR_EACH_(_C4_FOR_EACH_NARG(__VA_ARGS__), what, sep, __VA_ARGS__)
+
+/// @cond dev
+
+#define _C4_FOR_EACH_01(what, sep, x) what(x) sep
+#define _C4_FOR_EACH_02(what, sep, x, ...) what(x) sep _C4_FOR_EACH_01(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_03(what, sep, x, ...) what(x) sep _C4_FOR_EACH_02(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_04(what, sep, x, ...) what(x) sep _C4_FOR_EACH_03(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_05(what, sep, x, ...) what(x) sep _C4_FOR_EACH_04(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_06(what, sep, x, ...) what(x) sep _C4_FOR_EACH_05(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_07(what, sep, x, ...) what(x) sep _C4_FOR_EACH_06(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_08(what, sep, x, ...) what(x) sep _C4_FOR_EACH_07(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_09(what, sep, x, ...) what(x) sep _C4_FOR_EACH_08(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_10(what, sep, x, ...) what(x) sep _C4_FOR_EACH_09(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_11(what, sep, x, ...) what(x) sep _C4_FOR_EACH_10(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_12(what, sep, x, ...) what(x) sep _C4_FOR_EACH_11(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_13(what, sep, x, ...) what(x) sep _C4_FOR_EACH_12(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_14(what, sep, x, ...) what(x) sep _C4_FOR_EACH_13(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_15(what, sep, x, ...) what(x) sep _C4_FOR_EACH_14(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_16(what, sep, x, ...) what(x) sep _C4_FOR_EACH_15(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_17(what, sep, x, ...) what(x) sep _C4_FOR_EACH_16(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_18(what, sep, x, ...) what(x) sep _C4_FOR_EACH_17(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_19(what, sep, x, ...) what(x) sep _C4_FOR_EACH_18(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_20(what, sep, x, ...) what(x) sep _C4_FOR_EACH_19(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_21(what, sep, x, ...) what(x) sep _C4_FOR_EACH_20(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_22(what, sep, x, ...) what(x) sep _C4_FOR_EACH_21(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_23(what, sep, x, ...) what(x) sep _C4_FOR_EACH_22(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_24(what, sep, x, ...) what(x) sep _C4_FOR_EACH_23(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_25(what, sep, x, ...) what(x) sep _C4_FOR_EACH_24(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_26(what, sep, x, ...) what(x) sep _C4_FOR_EACH_25(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_27(what, sep, x, ...) what(x) sep _C4_FOR_EACH_26(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_28(what, sep, x, ...) what(x) sep _C4_FOR_EACH_27(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_29(what, sep, x, ...) what(x) sep _C4_FOR_EACH_28(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_30(what, sep, x, ...) what(x) sep _C4_FOR_EACH_29(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_31(what, sep, x, ...) what(x) sep _C4_FOR_EACH_30(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_32(what, sep, x, ...) what(x) sep _C4_FOR_EACH_31(what, sep, __VA_ARGS__)
+#define _C4_FOR_EACH_NARG(...) _C4_FOR_EACH_NARG_(__VA_ARGS__, _C4_FOR_EACH_RSEQ_N())
+#define _C4_FOR_EACH_NARG_(...) _C4_FOR_EACH_ARG_N(__VA_ARGS__)
+#define _C4_FOR_EACH_ARG_N(_01, _02, _03, _04, _05, _06, _07, _08, _09, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, N, ...) N
+#define _C4_FOR_EACH_RSEQ_N() 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 09, 08, 07, 06, 05, 04, 03, 02, 01
+#define _C4_FOR_EACH_(N, what, sep, ...) C4_XCAT(_C4_FOR_EACH_, N)(what, sep, __VA_ARGS__)
+
+/// @endcond
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+#endif /* _C4_PREPROCESSOR_HPP_ */
@@ -0,0 +1,11 @@
+#ifndef _C4_STD_STD_HPP_
+#define _C4_STD_STD_HPP_
+
+/** @file std.hpp includes all c4-std interop files */
+
+#include "c4/std/vector.hpp"
+#include "c4/std/string.hpp"
+#include "c4/std/string_view.hpp"
+#include "c4/std/tuple.hpp"
+
+#endif // _C4_STD_STD_HPP_
@@ -0,0 +1,10 @@
+#ifndef _C4_STD_STD_FWD_HPP_
+#define _C4_STD_STD_FWD_HPP_
+
+/** @file std_fwd.hpp includes all c4-std interop fwd files */
+
+#include "c4/std/vector_fwd.hpp"
+#include "c4/std/string_fwd.hpp"
+//#include "c4/std/tuple_fwd.hpp"
+
+#endif // _C4_STD_STD_FWD_HPP_
@@ -0,0 +1,97 @@
+#ifndef _C4_STD_STRING_HPP_
+#define _C4_STD_STRING_HPP_
+
+/** @file string.hpp */
+
+#ifndef C4CORE_SINGLE_HEADER
+#include "c4/substr.hpp"
+#endif
+
+#include <string>
+
+namespace c4 {
+
+//-----------------------------------------------------------------------------
+
+/** get a writeable view to an existing std::string.
+ * When the string is empty, the returned view will be pointing
+ * at the character with value '\0', but the size will be zero.
+ * @see https://en.cppreference.com/w/cpp/string/basic_string/operator_at
+ */
+C4_ALWAYS_INLINE c4::substr to_substr(std::string &s) noexcept
+{
+    #if C4_CPP < 11
+    #error this function will have undefined behavior
+    #endif
+    // since c++11 it is legal to call s[s.size()].
+    return c4::substr(&s[0], s.size()); // NOLINT(readability-container-data-pointer)
+}
+
+/** get a readonly view to an existing std::string.
+ * When the string is empty, the returned view will be pointing
+ * at the character with value '\0', but the size will be zero.
+ * @see https://en.cppreference.com/w/cpp/string/basic_string/operator_at
+ */
+C4_ALWAYS_INLINE c4::csubstr to_csubstr(std::string const& s) noexcept
+{
+    #if C4_CPP < 11
+    #error this function will have undefined behavior
+    #endif
+    // since c++11 it is legal to call s[s.size()].
+    return c4::csubstr(&s[0], s.size()); // NOLINT(readability-container-data-pointer)
+}
+
+//-----------------------------------------------------------------------------
+
+C4_ALWAYS_INLINE bool operator== (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) == 0; }
+C4_ALWAYS_INLINE bool operator!= (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) != 0; }
+C4_ALWAYS_INLINE bool operator>= (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) >= 0; }
+C4_ALWAYS_INLINE bool operator>  (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) >  0; }
+C4_ALWAYS_INLINE bool operator<= (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) <= 0; }
+C4_ALWAYS_INLINE bool operator<  (c4::csubstr ss, std::string const& s) { return ss.compare(to_csubstr(s)) <  0; }
+
+C4_ALWAYS_INLINE bool operator== (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) == 0; }
+C4_ALWAYS_INLINE bool operator!= (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) != 0; }
+C4_ALWAYS_INLINE bool operator>= (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) <= 0; }
+C4_ALWAYS_INLINE bool operator>  (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) <  0; }
+C4_ALWAYS_INLINE bool operator<= (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) >= 0; }
+C4_ALWAYS_INLINE bool operator<  (std::string const& s, c4::csubstr ss) { return ss.compare(to_csubstr(s)) >  0; }
+
+//-----------------------------------------------------------------------------
+
+/** copy an std::string to a writeable string view */
+inline size_t to_chars(c4::substr buf, std::string const& s)
+{
+    C4_ASSERT(!buf.overlaps(to_csubstr(s)));
+    size_t len = buf.len < s.size() ? buf.len : s.size();
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(len)
+    {
+        C4_ASSERT(s.data() != nullptr);
+        C4_ASSERT(buf.str != nullptr);
+        memcpy(buf.str, s.data(), len);
+    }
+    return s.size(); // return the number of needed chars
+}
+
+/** copy a string view to an existing std::string */
+inline bool from_chars(c4::csubstr buf, std::string * s)
+{
+    s->resize(buf.len);
+    C4_ASSERT(!buf.overlaps(to_csubstr(*s)));
+    // calling memcpy with null strings is undefined behavior
+    // and will wreak havoc in calling code's branches.
+    // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
+    if(buf.len)
+    {
+        C4_ASSERT(buf.str != nullptr);
+        memcpy(&(*s)[0], buf.str, buf.len); // NOLINT(readability-container-data-pointer)
+    }
+    return true;
+}
+
+} // namespace c4
+
+#endif // _C4_STD_STRING_HPP_
@@ -0,0 +1,59 @@
+#ifndef _C4_STD_STRING_FWD_HPP_
+#define _C4_STD_STRING_FWD_HPP_
+
+/** @file string_fwd.hpp */
+
+#ifndef DOXYGEN
+
+#ifndef C4CORE_SINGLE_HEADER
+#include "c4/substr_fwd.hpp"
+#endif
+
+#include <cstddef>
+
+// forward declarations for std::string
+#if defined(__GLIBCXX__) || defined(__GLIBCPP__)
+#include <bits/stringfwd.h>  // use the fwd header in glibcxx
+#elif defined(_LIBCPP_VERSION) || defined(__APPLE_CC__)
+#include <iosfwd>  // use the fwd header in stdlibc++
+#elif defined(_MSC_VER)
+#include "c4/error.hpp"
+//! @todo is there a fwd header in msvc?
+namespace std {
+C4_SUPPRESS_WARNING_MSVC_WITH_PUSH(4643) // Forward declaring 'char_traits' in namespace std is not permitted by the C++ Standard.
+template<typename> struct char_traits;
+template<typename> class allocator;
+template<typename _CharT, typename _Traits, typename _Alloc> class basic_string;
+using string = basic_string<char, char_traits<char>, allocator<char>>;
+C4_SUPPRESS_WARNING_MSVC_POP
+} /* namespace std */
+#else
+#error "unknown standard library"
+#endif
+
+namespace c4 {
+
+c4::substr to_substr(std::string &s) noexcept;
+c4::csubstr to_csubstr(std::string const& s) noexcept;
+
+bool operator== (c4::csubstr ss, std::string const& s);
+bool operator!= (c4::csubstr ss, std::string const& s);
+bool operator>= (c4::csubstr ss, std::string const& s);
+bool operator>  (c4::csubstr ss, std::string const& s);
+bool operator<= (c4::csubstr ss, std::string const& s);
+bool operator<  (c4::csubstr ss, std::string const& s);
+
+bool operator== (std::string const& s, c4::csubstr ss);
+bool operator!= (std::string const& s, c4::csubstr ss);
+bool operator>= (std::string const& s, c4::csubstr ss);
+bool operator>  (std::string const& s, c4::csubstr ss);
+bool operator<= (std::string const& s, c4::csubstr ss);
+bool operator<  (std::string const& s, c4::csubstr ss);
+
+size_t to_chars(c4::substr buf, std::string const& s);
+bool from_chars(c4::csubstr buf, std::string * s);
+
+} // namespace c4
+
+#endif // DOXYGEN
+#endif // _C4_STD_STRING_FWD_HPP_
--- a/Show More
+++ b/Show More