update c4core post-rebase

Author: biojppm

.github/workflows/infra.yml

@@ -43,6 +43,8 @@ jobs:
           echo "ERROR: generated workflows are out of date"
         fi
         exit $status
+        make -C proj workflows-check || \
+          ( echo "ERROR: generated workflows are out of date" ; exit 1 )
     - name: check cmake presets
       run: |
         make -C proj presets-check || \

ext/c4core.dev/c4/enum.hpp

@@ -2,8 +2,10 @@
 #define _C4_ENUM_HPP_
 
 #include "c4/error.hpp"
-#include <cstddef>
+
+#include <stddef.h>
 #include <string.h>
+#include <type_traits>
 
 /** @file enum.hpp utilities for enums: convert to/from string
  */
@@ -22,7 +24,7 @@ using is_scoped_enum = std::integral_constant<bool, std::is_enum<Enum>::value &&
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 
-typedef enum {
+typedef enum { // NOLINT(cert-int09-c,readability-enum-initial-value)
     EOFFS_NONE = 0,  ///< no offset
     EOFFS_CLS = 1,   ///< get the enum offset for the class name. @see eoffs_cls()
     EOFFS_PFX = 2,   ///< get the enum offset for the enum prefix. @see eoffs_pfx()

ext/c4core.dev/c4/memory_resource.cpp

@@ -26,7 +26,7 @@ arealloc_pfn s_arealloc = nullptr;
 #else
 
 
-void afree_impl(void *ptr)
+void afree_impl(void *ptr) // NOLINT(misc-use-internal-linkage)
 {
 #if defined(C4_WIN) || defined(C4_XBOX)
     ::_aligned_free(ptr);
@@ -36,7 +36,7 @@ void afree_impl(void *ptr)
 }
 
 
-void* aalloc_impl(size_t size, size_t alignment)
+void* aalloc_impl(size_t size, size_t alignment) // NOLINT(misc-use-internal-linkage)
 {
     // alignment must be nonzero and a power of 2
     C4_CHECK(alignment > 0 && (alignment & (alignment - 1u)) == 0);
@@ -77,7 +77,7 @@ void* aalloc_impl(size_t size, size_t alignment)
 }
 
 
-void* arealloc_impl(void* ptr, size_t oldsz, size_t newsz, size_t alignment)
+void* arealloc_impl(void* ptr, size_t oldsz, size_t newsz, size_t alignment) // NOLINT(misc-use-internal-linkage)
 {
     /** @todo make this more efficient
      * @see https://stackoverflow.com/questions/9078259/does-realloc-keep-the-memory-alignment-of-posix-memalign
@@ -97,9 +97,9 @@ void* arealloc_impl(void* ptr, size_t oldsz, size_t newsz, size_t alignment)
     return tmp;
 }
 
-aalloc_pfn s_aalloc = aalloc_impl;
-afree_pfn s_afree = afree_impl;
-arealloc_pfn s_arealloc = arealloc_impl;
+aalloc_pfn s_aalloc = aalloc_impl;       // NOLINT(misc-use-internal-linkage)
+afree_pfn s_afree = afree_impl;          // NOLINT(misc-use-internal-linkage)
+arealloc_pfn s_arealloc = arealloc_impl; // NOLINT(misc-use-internal-linkage)
 
 #endif // C4_NO_ALLOC_DEFAULTS
 

ext/c4core.dev/c4/span.hpp

@@ -43,7 +43,7 @@ C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
  * @see cspanrsl
  */
 template<class T, class I, class SpanImpl>
-class span_crtp
+class span_crtp // NOLINT(*crtp-constructor-accessibility)
 {
 // some utility defines, undefined at the end of this class
 #define _c4this  ((SpanImpl      *)this)

ext/c4core.dev/c4/szconv.hpp

@@ -7,6 +7,7 @@
 #include "c4/error.hpp"
 
 #include <limits>
+#include <type_traits>
 
 namespace c4 {
 

ext/c4core.mk

@@ -2,4 +2,4 @@
 
 C4CORE_REPO := https://github.com/biojppm/c4core
 # must be tag or a FULL commit hash; cannot be a branch name.
-C4CORE_TAG := 1f2c1a87ba28344909ff4249d461d190c2dd5de1
+C4CORE_TAG := v0.2.10

ext/c4core.src.txt

@@ -22,6 +22,8 @@ c4/memory_util.cpp
 c4/memory_util.hpp
 c4/platform.hpp
 c4/preprocessor.hpp
+c4/std/span_fwd.hpp
+c4/std/span.hpp
 c4/std/std.hpp
 c4/std/std_fwd.hpp
 c4/std/string.hpp

ext/c4core.src/c4/base64.cpp

@@ -76,7 +76,7 @@ constexpr static const char base64_char_to_sextet_[128] = {
 };
 
 #ifndef NDEBUG
-void base64_test_tables()
+void base64_test_tables() // NOLINT(*use-internal-linkage*)
 {
     for(size_t i = 0; i < C4_COUNTOF(detail::base64_sextet_to_char_); ++i)
     {

ext/c4core.src/c4/charconv.hpp

@@ -867,7 +867,7 @@ C4_ALWAYS_INLINE bool read_dec(csubstr s, I *C4_RESTRICT v) noexcept
     {
         if(C4_UNLIKELY(c < '0' || c > '9'))
             return false;
-        *v = (*v) * I(10) + (I(c) - I('0'));
+        *v = ((*v) * I(10)) + (I(c) - I('0'));
     }
     return true;
 }
@@ -902,7 +902,7 @@ C4_ALWAYS_INLINE bool read_hex(csubstr s, I *C4_RESTRICT v) noexcept
             cv = I(10) + (I(c) - I('A'));
         else
             return false;
-        *v = (*v) * I(16) + cv;
+        *v = ((*v) * I(16)) + cv;
     }
     return true;
 }
@@ -960,7 +960,7 @@ C4_ALWAYS_INLINE bool read_oct(csubstr s, I *C4_RESTRICT v) noexcept
     {
         if(C4_UNLIKELY(c < '0' || c > '7'))
             return false;
-        *v = (*v) * I(8) + (I(c) - I('0'));
+        *v = ((*v) * I(8)) + (I(c) - I('0'));
     }
     return true;
 }
@@ -1974,11 +1974,11 @@ C4_ALWAYS_INLINE bool scan_rhex(csubstr s, T *C4_RESTRICT val) noexcept
     {
         const char c = s.str[pos];
         if(c >= '0' && c <= '9')
-            *val = *val * T(16) + T(c - '0');
+            *val = (*val * T(16)) + T(c - '0');
         else if(c >= 'a' && c <= 'f')
-            *val = *val * T(16) + T(c - 'a');
+            *val = (*val * T(16)) + T(c - 'a');
         else if(c >= 'A' && c <= 'F')
-            *val = *val * T(16) + T(c - 'A');
+            *val = (*val * T(16)) + T(c - 'A');
         else if(c == '.')
         {
             ++pos;
@@ -2179,7 +2179,11 @@ C4_ALWAYS_INLINE bool atod(csubstr str, double * C4_RESTRICT v) noexcept
     if(!(rem.len >= 2 && (rem.str[0] == '0' && (rem.str[1] == 'x' || rem.str[1] == 'X'))))
     {
         fast_float::from_chars_result result;
+        #ifndef CLANG_TIDY   // suppress a false-positive error (cannot be done with NOLINT: https://stackoverflow.com/questions/62838193/ )
         result = fast_float::from_chars(str.str, str.str + str.len, *v);
+        #else
+        result = {};
+        #endif
         return result.ec == std::errc();
     }
     else if(detail::scan_rhex(rem.sub(2), v))

ext/c4core.src/c4/dump.hpp

@@ -2,6 +2,8 @@
 #define C4_DUMP_HPP_
 
 #include <c4/substr.hpp>
+#include <utility> // for std::forward
+
 
 /** @file dump.hpp This file provides functions to dump several
  * arguments as strings to a user-provided function sink, for example
@@ -52,29 +54,24 @@ C4_SUPPRESS_WARNING_GCC_CLANG_WITH_PUSH("-Wold-style-cast")
 using SinkPfn = void (*)(csubstr str);
 
 
-/** a traits class to use in SFINAE with @ref c4::dump() to select if
- * a type is treated as string type (which is dumped directly to the
- * sink, using to_csubstr()), or if the type is treated as a value,
- * which is first serialized to a buffer using to_chars(), and then
- * the serialization serialized as */
-template<class T> struct dump_directly : public std::false_type {};
-template<> struct dump_directly<csubstr> : public std::true_type {};
-template<> struct dump_directly< substr> : public std::true_type {};
-template<> struct dump_directly<const char*> : public std::true_type {};
-template<> struct dump_directly<      char*> : public std::true_type {};
-template<size_t N> struct dump_directly<const char (&)[N]> : public std::true_type {};
-template<size_t N> struct dump_directly<      char (&)[N]> : public std::true_type {};
-template<size_t N> struct dump_directly<const char[N]> : public std::true_type {};
-template<size_t N> struct dump_directly<      char[N]> : public std::true_type {};
+template<class T> struct is_string; // fwd-decl
+
+/** a traits class used by @ref c4::dump() to decide whether a type is
+ * treated as a string type (which is dumped directly to the sink via
+ * to_csubstr()), or if the type is treated as a value, which is first
+ * serialized to the dump buffer using to_chars() prior to dumping it
+ * to the sink. This type defaults to @ref c4::is_string, but can be
+ * overriden independently. */
+template<class T> struct dump_directly : public is_string<T> {};
 
 
 #if (C4_CPP >= 17) || defined(__DOXYGEN__)
 /** Dump a serializable object to the (statically dispatched)
  * sink. Before dumping, the object may be serialized to a string if
  * @ref c4::dump_directly<Arg> is a false type (the default if
  * dump_directly does not have a specialization). Otherwise the object
- * is considered a string object is dumped directly, without any
- * intermediate serialization.
+ * is considered a string object and is therefore dumped directly,
+ * without any intermediate serialization.
  *
  * @return the number of bytes needed to serialize the string-type
  * object, which may be 0 when there is no serialization
@@ -97,10 +94,11 @@ size_t dump(substr buf, Arg const& a)
 {
     if constexpr (dump_directly<Arg>::value)
     {
-        C4_ASSERT(!buf.overlaps(a));
         C4_UNUSED(buf);
+        csubstr sa = to_csubstr(a);
+        C4_ASSERT(!buf.overlaps(sa));
         // dump directly, no need to serialize to the buffer
-        sinkfn(to_csubstr(a));
+        sinkfn(sa);
         return 0; // no space was used in the buffer
     }
     else
@@ -151,9 +149,10 @@ size_t dump(SinkFn &&sinkfn, substr buf, Arg const& a)
     if constexpr (dump_directly<Arg>::value)
     {
         C4_UNUSED(buf);
-        C4_ASSERT(!buf.overlaps(a));
+        csubstr sa = to_csubstr(a);
+        C4_ASSERT(!buf.overlaps(sa));
         // dump directly, no need to serialize to the buffer
-        std::forward<SinkFn>(sinkfn)(to_csubstr(a));
+        std::forward<SinkFn>(sinkfn)(sa);
         return 0; // no space was used in the buffer
     }
     else
@@ -181,20 +180,22 @@ template<SinkPfn sinkfn, class Arg>
 inline auto dump(substr buf, Arg const& a)
     -> typename std::enable_if<dump_directly<Arg>::value, size_t>::type
 {
-    C4_ASSERT(!buf.overlaps(a));
     C4_UNUSED(buf);
+    csubstr sa = to_csubstr(a);
+    C4_ASSERT(!buf.overlaps(sa));
     // dump directly, no need to serialize to the buffer
-    sinkfn(to_csubstr(a));
+    sinkfn(sa);
     return 0; // no space was used in the buffer
 }
 template<class SinkFn, class Arg>
 inline auto dump(SinkFn &&sinkfn, substr buf, Arg const& a)
     -> typename std::enable_if<dump_directly<Arg>::value, size_t>::type
 {
     C4_UNUSED(buf);
-    C4_ASSERT(!buf.overlaps(a));
+    csubstr sa = to_csubstr(a);
+    C4_ASSERT(!buf.overlaps(sa));
     // dump directly, no need to serialize to the buffer
-    std::forward<SinkFn>(sinkfn)(to_csubstr(a));
+    std::forward<SinkFn>(sinkfn)(sa);
     return 0; // no space was used in the buffer
 }