Import official C23 code examples for Modern C (Jens Gustedt, 2024)HEADupstream-importmain

- Add official C source files, Makefile, c23-fallback.h, and LICENSE
- Update README.md with study mirror notice

1 files changed, 1325 insertions, 0 deletions

diff --git a/c23-fallback.h b/c23-fallback.h
new file mode 100644
index 0000000..3331631
--- /dev/null
+++ b/c23-fallback.h
@@ -0,0 +1,1325 @@
+#ifndef C23_FALLBACK_H
+#define C23_FALLBACK_H
+
+/** @file
+ ** @brief A header file to augment compatibility of older compilers with C23.
+ **
+ ** This has only been tested with the open source compilers
+ **
+ ** - gcc
+ ** - clang
+ **
+ ** and the C libraries
+ **
+ ** - glibc
+ ** - musl
+ **
+ ** The newer the version of these compilers or C libraries you can
+ ** get, the better. If you use another compiler or C library and have
+ ** adjustments to make to this file, please share. I will try to
+ ** include such changes in the future.
+ **
+ ** Commonly supported C23 features that are required are
+ ** - digit separators such as in `0xAB'CD`
+ ** - binary integer literals such as `0b1010` or `0B0101`
+ ** - the new attribute syntax such as `[[deprecated]]`
+ **
+ ** The first two are not easy to circumvent, so probably you should
+ ** not even try to use C23 enabled code without having support for
+ ** them.
+ **
+ ** For the attribute syntax there is a feature test
+ ** __has_c_attribute. It can be used with define (or #ifdef) to test
+ ** for the syntax itself and with #if and an argument to test for an
+ ** individual attribute, see below.
+ **
+ ** Another feature test is __has_include, which similarly can be used
+ ** to test for the preprocessor feature itself and if that is
+ ** available to test for the availability of a specific header. This
+ ** can be used to
+ **
+ ** - test for optional headers such as <complex.h>, <threads.h>, or
+ **   <stdatomic.h>. This now allows to use the corresponding feature
+ **   test macro (__STDC_NO_COMPLEX__, __STDC_NO_ATOMICS__,
+ **   __STDC_NO_THREADS__) to test for compiler support of these
+ **   features, separately from the availability of library
+ **   interfaces.
+ **
+ ** - test for new headers that come with C23, namely <stdckdint.h>
+ **   and <stdbit.h>. Even if your C library does not support these,
+ **   their functionality should mostly be available through
+ **   type-generic macros that we emulate. Prefer them over function
+ **   symbols, those may depend on linker symbols that are not yet
+ **   available.
+ **
+ ** This header here unconditionally includes a bunch of C library
+ ** headers (see below) and augments them with C23 features if
+ ** possible. You should not include them yourself, such that we are
+ ** sure in what we get. This also concerns the new C23 header
+ ** <stdckdint.h>.
+ **
+ ** Other headers also may be included conditionally, namely
+ ** <threads.h> and <stdatomic.h>.
+ **
+ ** When emulating the new features, there may be spurious warnings
+ ** that some attributes are misplaced or ignored. This obviously
+ ** means that they are not completely taken into account and that the
+ ** analysis they are expected to provide is not yet fully implemented
+ ** by your compiler. If you are flooded by these, you might switch
+ ** some of the diagnostics off by defining the macro
+ ** `C23_FALLBACK_SILENT` for example by providing the command line
+ ** argument `-DC23_FALLBACK_SILENT`.
+ **
+ ** But note also, that some errors that are found are actually real
+ ** errors. These are meant as bad code examples and also as tests if
+ ** compilers are able to detect these kind of things. If you stumble
+ ** into these, there should be a code comment close by that explains
+ ** the particular example. Compilers vary widely in what they are
+ ** able to detect, so here the more you see, the better.
+ **
+ ** And then, ..., there are the bugs. Currently, the code triggers
+ ** one particular bug of gcc-13 in `endianness.c`.
+ **
+ ** As of March 2024, gcc-14 and clang-18 work with most of the new
+ ** C23 features. Current restrictions are
+ **
+ ** - clang-18: `constexpr` is not yet implemented
+ ** - both: `#embed` is not yet implemented
+ **
+ ** As indicated above, some short comings of your C library
+ ** implementation can be worked around, but unfortunately not all. As
+ ** of this writing
+ **
+ ** - glibc: `printf` and `scanf` support only includes the new %b
+ **   specifier for binary representation, but not the %w length
+ **   modifiers.
+ **
+ ** - musl: in the current distribution there is no support for C23
+ **   features, so in particular `printf` etc will not work with the
+ **   new formats, yet.
+ **
+ ** We are currently working to have patches included to musl whence
+ ** the new edition of Modern C and the new standard appear. In the
+ ** mean time I will try to post a patch set and build recipe such
+ ** that you may easily build such modified version of musl with
+ ** complete C23 support on your own. Stay tuned.
+ **/
+
+#include <limits.h>
+
+/* Needed for musl */
+/* #ifdef __has_include */
+/* # if __has_include(<stdc-predef.h>) */
+/* #  include <stdc-predef.h> */
+/* # endif */
+/* #endif */
+
+
+#if (__STDC_UTF_16__ != 1) || (__STDC_UTF_32__ != 1)
+# ifndef C23_FALLBACK_SILENT
+#  warning "C23 imposes that char16_t and char32_t use UTF-16 and UTF-32 encodings"
+# endif
+#endif
+
+/**
+ ** @brief A preprocessor test for the `__VA_OPT__` feature.
+ **
+ ** Compilers before C23 might not implement `__VA_OPT__`.
+ ** @return This macro should always evaluate to `0` or `1`.
+ **/
+#define __has_va_opt C23_HAS_VA_OPT_I(C23)
+#define C23_HAS_VA_OPT_I(...)                   \
+  C23_HAS_VA_OPT_IIplus(__VA_OPT__(,) 1, 0,)
+#define C23_HAS_VA_OPT_IIplus(_0, _1, ...) _1
+
+#if !__has_va_opt
+# ifndef C23_FALLBACK_SILENT
+#  warning "no support of C23 __VA_OPT__ found"
+# endif
+#endif
+
+#ifndef BITINT_MAXWIDTH
+# ifdef __BITINT_MAXWIDTH__
+#  define BITINT_MAXWIDTH __BITINT_MAXWIDTH__
+# else
+#  ifndef C23_FALLBACK_SILENT
+#   warning "no support for _BitInt types found"
+#  endif
+# endif
+#endif
+
+/* A simple type-generic conditional. */
+#define GENERIC_IF(COND, A, B)                  \
+  _Generic((char(*)[1+!!(COND)])0,              \
+           char(*)[2]: (A),                     \
+           default: (B))
+
+/* clang has a set of feature tests that are quite comfortable,
+
+   __has_feature, to test if a specific feature is implemented
+
+   __has_extension, to test if a specific feature is implemented
+
+   __is_identifier, to test if a word is an identifier or a keyword.
+
+   In the following we construct similar tests for gcc such that we
+   may use these features independently from the C standard version
+   that is supported. */
+# define __tester2(_0, _1, ...) _1
+# define __tester1(...) __tester2(__VA_ARGS__)
+#ifndef __has_feature
+# define __has_feature(X) __tester1(__has_feature_ ## X 1, 0, )
+#endif
+#ifndef __has_extension
+# define __has_extension(X) __tester1(__has_extension_ ## X 1, 0, )
+#endif
+
+#ifndef __is_identifier
+# define __is_identifier(X) __tester1(__is_special_ ## X 0, 1, )
+# define __is_special_auto ,
+# define __is_special_break ,
+# define __is_special_case ,
+# define __is_special_char ,
+# define __is_special_const ,
+# define __is_special_continue ,
+# define __is_special_default ,
+# define __is_special_do ,
+# define __is_special_double ,
+# define __is_special_else ,
+# define __is_special_enum ,
+# define __is_special_extern ,
+# define __is_special_float ,
+# define __is_special_for ,
+# define __is_special_goto ,
+# define __is_special_if ,
+# define __is_special_inline ,
+# define __is_special_int ,
+# define __is_special_long ,
+# define __is_special_register ,
+# define __is_special_restrict ,
+# define __is_special_return ,
+# define __is_special_short ,
+# define __is_special_signed ,
+# define __is_special_sizeof ,
+# define __is_special_static ,
+# define __is_special_struct ,
+# define __is_special_switch ,
+# define __is_special_typedef ,
+# define __is_special_union ,
+# define __is_special_unsigned ,
+# define __is_special_void ,
+# define __is_special_volatile ,
+# define __is_special_while ,
+# define __is_special__Atomic ,
+# define __is_special__Complex ,
+# define __is_special__Decimal128 ,
+# define __is_special__Decimal32 ,
+# define __is_special__Decimal64 ,
+# define __is_special__Generic ,
+# define __is_special__Imaginary ,
+# define __is_special__Noreturn ,
+# if __GNUC__ > 12 || __STDC_VERSION__ >= 202311L
+#  define __is_special_nullptr ,
+#  define __is_special_static_assert ,
+#  define __is_special_thread_local ,
+#  define __is_special_constexpr ,
+#  define __is_special_typeof ,
+#  define __is_special_typeof_unqual ,
+# endif
+# if __GNUC__ > 13 || __STDC_VERSION__ >= 202311L
+#  define __is_special__BitInt ,
+#  define __is_special_alignas ,
+#  define __is_special_alignof ,
+#  define __is_special_bool ,
+#  define __is_special_false ,
+#  define __is_special_true ,
+# endif
+#endif
+#if __GNUC__ > 12 || __STDC_VERSION__ >= 202311L
+# define __has_feature_c_fixed_enum ,
+#endif
+
+// The feature for fixed underlying types for enums has been so long
+// in clang, that they don't even seem to have a feature test for it.
+#if !__has_feature(c_fixed_enum) && defined(__clang_major__) && (__clang_major__ < 8)
+# ifndef C23_FALLBACK_SILENT
+#  warning "syntax for fixed underlying integer type of enumerations is not supported"
+# endif
+#endif
+
+#if __is_identifier(constexpr)
+# ifndef C23_FALLBACK_SILENT
+#  warning "constexpr keyword is not supported, emulating as static const"
+# endif
+# define constexpr static const
+#endif
+
+#if __is_identifier(bool)
+# ifndef C23_FALLBACK_SILENT
+#  warning "bool keyword is not supported, emulating as macro"
+# endif
+# define bool _Bool
+#endif
+#if __is_identifier(false)
+# ifndef C23_FALLBACK_SILENT
+#  warning "false keyword is not supported, emulating as macro"
+# endif
+# undef false
+# define false ((bool)+0U)
+#endif
+#if __is_identifier(true)
+# ifndef C23_FALLBACK_SILENT
+#  warning "true keyword is not supported, emulating as macro"
+# endif
+# undef true
+# define true ((bool)+1U)
+#endif
+
+#if __is_identifier(thread_local)
+// Maybe this is also provided by the C library implementation, but a
+// redefinition makes no harm.
+#define thread_local _Thread_local
+#endif
+
+#if __is_identifier(alignof)
+#undef alignof
+#define alignof _Alignof
+#endif
+
+#if __is_identifier(alignas)
+#undef alignas
+#define alignas _Alignas
+#endif
+
+#if __is_identifier(static_assert)
+#undef static_assert
+#define static_assert(...) __static_assert(__VA_ARGS__,)
+#define __static_assert(E, ...) _Static_assert(E)
+#endif
+
+#if __is_identifier(typeof)
+# if __GNUC__
+#  undef typeof
+#  define typeof __typeof__
+# else
+#  warning "typeof operator only comes with C23"
+# endif
+#endif
+
+#if __STDC_VERSION__ < 202311L
+# if __GNUC__
+#  if __GNUC__ < 13
+#   define auto __auto_type
+#  endif
+# else
+#  warning "auto type inference only comes with C23"
+# endif
+#endif
+
+#ifndef __has_c_attribute
+# define __has_c_attribute(X) 0
+#endif
+
+// C23 has nullptr, use a fallback if that is not available. Here we
+// use an enumeration type and constant to do that. The idea is that
+// such an enumeration may then be used in _Generic as long the cases
+// otherwise only have pointer types. The first choice is to use a
+// _BitInt type for that, if that is already available, in an effort
+// to not clash with standard integer types. If that is not found, we
+// use a standard integer type that has the right width.
+//
+// If possible, we also use an attribute that forces warnings if any
+// other value than a null or 0 is assigned to a variable of type
+// nullptr_t.
+#if !__is_identifier(nullptr)
+// Maybe this is also provided by the C library implementation, but a
+// redefinition makes no harm.
+typedef typeof(nullptr) nullptr_t;
+#elif (__STC_VERSION__ < 202311L)
+# ifdef BITINT_MAXWIDTH
+
+#  ifndef C23_FALLBACK_SILENT
+#   warning "using fallback for nullptr to enumeration constant based on _BitInt type"
+#  else
+#   pragma GCC diagnostic ignored "-Wnon-literal-null-conversion"
+#  endif
+
+enum
+#  if __has_c_attribute(clang::enum_extensibility)
+[[__clang__::__enum_extensibility__(closed)]]
+#  endif
+nullptr_t :
+__typeof__((unsigned _BitInt(sizeof(void*)*CHAR_BIT))0)
+{
+  nullptr,
+};
+
+# else
+
+#  ifndef C23_FALLBACK_SILENT
+#   warning "using fallback for nullptr to enumeration constant based on standard integer type"
+#  endif
+
+enum
+#  if __has_c_attribute(clang::enum_extensibility)
+[[__clang__::__enum_extensibility__(closed)]]
+#  endif
+nullptr_t {
+  nullptr,
+  __nullptr_max =
+  GENERIC_IF((sizeof(void*)==sizeof(int)),
+             -1U,
+             GENERIC_IF((sizeof(void*)==sizeof(long)),
+                        -1UL,
+                        -1ULL)),
+};
+
+// Unfortunately such an enumeration type is not yet good enough for
+// all compilers. In particular some gcc version has nullptr and
+// __nullptr_max as different types. Force an expression that is an
+// ICE of value 0 and of the enumeration type.
+#  define nullptr (1 ? nullptr : __nullptr_max)
+# endif
+#endif
+typedef typeof(nullptr) nullptr_t;
+
+static_assert(_Generic(nullptr, nullptr_t: true));
+static_assert(sizeof(void*)==sizeof(nullptr));
+static_assert(sizeof(void*)==sizeof(nullptr_t));
+
+/**********************************************************************************************/
+
+#include <inttypes.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdalign.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <wchar.h>
+
+/**********************************************************************************************/
+
+// for call_once
+#ifndef ONCE_FLAG_INIT
+# ifdef __has_include
+#  if __has_include(<threads.h>)
+#   ifndef C23_FALLBACK_SILENT
+#    warning "including call_once function from <threads.h> instead of <stdlib.h>"
+#   endif
+#   include <threads.h>
+#  endif
+# endif
+#endif
+
+// If call_once has not been found we construct a function that is
+// based on atomics.
+#ifndef ONCE_FLAG_INIT
+# ifdef __has_include
+#  if __has_include(<stdatomic.h>)
+#   include <stdatomic.h>
+#   ifndef C23_FALLBACK_SILENT
+#    warning "emulating call_once function by using atomics"
+#   endif
+enum { once_initial, once_inter, once_final, };
+#   define ONCE_FLAG_INIT once_initial
+
+typedef _Atomic(unsigned) once_flag;
+
+# if __has_c_attribute(__gnu__::__noinline__)
+[[__gnu__::__noinline__]]
+# endif
+static inline
+void call_once(once_flag* flag, void callback(void)) {
+  if (*flag != once_final) {
+    unsigned expected = once_initial;
+    if (atomic_compare_exchange_strong(flag, &expected, once_inter)) {
+      callback();
+      *flag = once_final;
+    } else {
+      while (*flag != once_final) {
+        //
+      }
+    }
+  } else {
+    // We know already that the implementation does not support threads,
+    // so the only available fence is this:
+    atomic_signal_fence(memory_order_seq_cst);
+  }
+}
+#  endif
+# endif
+#endif
+
+/**********************************************************************************************/
+
+// We assume that the compiler is already able to handle the new
+// attribute syntax such as [[deprecated]]. Nevertheless, maybe
+// certain attributes themselves might not yet be implemented. We
+// provide fallback macros to corresponding gnu attributes. Here we
+// use the "safe" names for these features with double underscores, so
+// they don't interfere with application names.
+
+#if !__has_c_attribute(__unsequenced__)
+# ifndef C23_FALLBACK_SILENT
+#  warning "unsequenced attribute not yet implemented"
+# endif
+# define __unsequenced__
+# if __has_c_attribute(__gnu__::__const__)
+#  ifndef C23_FALLBACK_SILENT
+#   warning "unsequenced attribute could be emulated via gnu attribute by using c23_unsequenced"
+#  endif
+#  define c23_unsequenced __attribute__((__const__))
+# endif
+#endif
+
+#if !__has_c_attribute(__reproducible__)
+# ifndef C23_FALLBACK_SILENT
+#  warning "reproducible attribute not yet implemented"
+# endif
+# define __reproducible__
+# if __has_c_attribute(__gnu__::__pure__)
+#  ifndef C23_FALLBACK_SILENT
+#   warning "reproducible attribute could be emulated via gnu attribute by using c23_reproducible"
+#  endif
+#  define c23_reproducible __attribute__((__pure__))
+# endif
+#endif
+
+#if !__has_c_attribute(__deprecated__) && __has_c_attribute(__gnu__::__deprecated__)
+# ifndef C23_FALLBACK_SILENT
+#  warning "emulating deprecated attribute via gnu attribute"
+# endif
+# define __deprecated__ __gnu__::__deprecated__
+#endif
+
+#if !__has_c_attribute(__nodiscard__) && __has_c_attribute(__gnu__::__warn_unused_result__)
+# ifndef C23_FALLBACK_SILENT
+#  warning "emulating nodiscard attribute via gnu attribute"
+# endif
+# define __nodiscard__ __gnu__::__warn_unused_result__
+#endif
+
+#if !__has_c_attribute(__maybe_unused__) && __has_c_attribute(__gnu__::__unused__)
+# ifndef C23_FALLBACK_SILENT
+#  warning "emulating maybe_unused attribute via gnu attribute"
+# endif
+# define __maybe_unused__ __gnu__::__unused__
+#endif
+
+#if !__has_c_attribute(noreturn) && __has_c_attribute(__gnu__::__noreturn__)
+# ifndef C23_FALLBACK_SILENT
+#  warning "emulating noreturn attribute via gnu attribute"
+# endif
+# define noreturn __gnu__::__noreturn__
+#endif
+
+#if !__has_c_attribute(__fallthrough__) && __has_c_attribute(__gnu__::__fallthrough__)
+# warning "emulating fallthrough attribute via gnu attribute"
+# define __fallthrough__ __gnu__::__fallthrough__
+#endif
+
+#if __has_c_attribute(__deprecated__) || defined(__deprecated__)
+// Deprecate two interfaces in <time.h>
+[[__deprecated__]] char *asctime(const struct tm*);
+[[__deprecated__]] char *ctime(const time_t*);
+#endif
+
+// Gnu compilers have a malloc attribute that comes in two different
+// forms. Without argument it just certifies that a function returns a
+// pointer value that has not been seen before, and thus the pointer
+// target will not alias with anything known. The second form receives
+// one or two arguments and specifies a function that should be used
+// analogous to free. Unfortunately, clang didn't follow that second
+// development, yet. But we suppose that there will be at least a
+// partial solution in clang-18 final.
+#if __has_c_attribute(__gnu__::__malloc__) && !(defined(__clang_major__) && __clang_major__ <= 19)
+# define __gnu_free__(...) __gnu__::__malloc__(__VA_ARGS__)
+#else
+# define __gnu_free__(...)
+#endif
+
+/**********************************************************************************************/
+
+/* C23 allows to omit the second argument of va_start */
+#if __STDC_VERSION_STDARG_H__ < 202311L
+#undef va_start
+#define va_start(...) __va_start1(__VA_ARGS__ , 0, )
+#define __va_start1(...) __va_start2(__VA_ARGS__)
+#define __va_start2(v, l, ...) __builtin_va_start(v, l)
+#endif
+
+/**********************************************************************************************/
+
+/* C23 has three new tg interfaces in the new <stdkdint.h> header.
+They are modeled after similar gcc features. They are meant to do
+arithmetic with overflow check by using everything the compiler can
+get from instruction flags that already exist on most CPU.
+*/
+
+#ifdef __has_include
+# if __has_include(<stdckdint.h>)
+#  include <stdckdint.h>
+# endif
+#endif
+
+/* If we don't have the header, yet, we may easily emulate it if we
+are on a compiler claiming compatibility with gcc. */
+#ifndef ckd_add
+# ifdef __GNUC__
+#  ifndef C23_FALLBACK_SILENT
+#   warning "emulating stdckdint.h interfaces via gnu builtins"
+#  endif
+#  define ckd_add(R, A, B) __builtin_add_overflow ((A), (B), (R))
+#  define ckd_sub(R, A, B) __builtin_sub_overflow ((A), (B), (R))
+#  define ckd_mul(R, A, B) __builtin_mul_overflow ((A), (B), (R))
+# else
+#  warning "checked integer arithmetic as of C23 is not yet implemented"
+# endif
+#endif
+
+/**********************************************************************************************/
+
+// C23 has the unreachable macro in <stdlib.h>, use a fallback if that
+// is not available
+#ifndef unreachable
+# ifndef C23_FALLBACK_SILENT
+#  warning "using fallback for unreachable macro"
+# endif
+# define unreachable() __builtin_unreachable()
+#endif
+
+/**********************************************************************************************/
+
+// C23 provides macros for the width of integer types. Provide a
+// fallback if they are not available
+
+#ifndef BOOL_WIDTH
+# define BOOL_WIDTH 1
+#endif
+
+#ifndef CHAR_WIDTH
+# define CHAR_WIDTH CHAR_BIT
+#endif
+
+#ifndef UCHAR_WIDTH
+# define UCHAR_WIDTH CHAR_BIT
+#endif
+
+#ifndef SCHAR_WIDTH
+# define SCHAR_WIDTH CHAR_BIT
+#endif
+
+#ifndef USHRT_WIDTH
+# if USHRT_MAX <= 0xFFFFU
+#  define USHRT_WIDTH 16
+#  define SHRT_WIDTH 16
+# else
+#  if USHRT_MAX <= 0xFFFFFFFFU
+#   define USHRT_WIDTH 32
+#   define SHRT_WIDTH 32
+#  else
+#   if USHRT_MAX <= 0xFFFFFFFFFFFFFFFFU
+#    define USHRT_WIDTH 64
+#    define SHRT_WIDTH 64
+#   else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#    if USHRT_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFU
+#     define USHRT_WIDTH 96
+#     define SHRT_WIDTH 96
+#    else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#     if USHRT_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFU
+#      define USHRT_WIDTH 128
+#      define SHRT_WIDTH 128
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+// unsigned int has a width of at least 16.
+#ifndef UINT_WIDTH
+# if UINT_MAX <= 0xFFFFU
+#  define UINT_WIDTH 16
+#  define INT_WIDTH 16
+# else
+#  if UINT_MAX <= 0xFFFFFFFFU
+#   define UINT_WIDTH 32
+#   define INT_WIDTH 32
+#  else
+#   if UINT_MAX <= 0xFFFFFFFFFFFFFFFFU
+#    define UINT_WIDTH 64
+#    define INT_WIDTH 64
+#   else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#    if UINT_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFU
+#     define UINT_WIDTH 96
+#     define INT_WIDTH 96
+#    else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#     if UINT_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFU
+#      define UINT_WIDTH 128
+#      define INT_WIDTH 128
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+// size_t has a width of at least 16.
+#ifndef SIZE_WIDTH
+# if SIZE_MAX <= 0xFFFFU
+#  define SIZE_WIDTH 16
+# else
+#  if SIZE_MAX <= 0xFFFFFFFFU
+#   define SIZE_WIDTH 32
+#  else
+#   if SIZE_MAX <= 0xFFFFFFFFFFFFFFFFU
+#    define SIZE_WIDTH 64
+#   else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#    if SIZE_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFU
+#     define SIZE_WIDTH 96
+#    else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#     if SIZE_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFU
+#      define SIZE_WIDTH 128
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+// unsigned long has a width of at least 32
+#ifndef ULONG_WIDTH
+# if ULONG_MAX <= 0xFFFFFFFFUL
+#  define ULONG_WIDTH 32
+#  define LONG_WIDTH 32
+# else
+#  if ULONG_MAX <= 0xFFFFFFFFFFFFFFFFUL
+#   define ULONG_WIDTH 64
+#   define LONG_WIDTH 64
+#  else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#   if ULONG_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFUL
+#    define ULONG_WIDTH 96
+#    define LONG_WIDTH 96
+#   else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#    if ULONG_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFUL
+#     define ULONG_WIDTH 128
+#     define LONG_WIDTH 128
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+// unsigned long long has a width of at least 64.
+#ifndef ULLONG_WIDTH
+# if ULLONG_MAX <= 0xFFFFFFFFFFFFFFFFULL
+#  define ULLONG_WIDTH 64
+#  define LLONG_WIDTH 64
+# else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#  if ULLONG_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFULL
+#   define ULLONG_WIDTH 96
+#   define LLONG_WIDTH 96
+#  else
+// This doesn't use #elif but nested #if/#else because the value might
+// be too large for the preprocessor
+#   if ULLONG_MAX <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFULL
+#    define ULLONG_WIDTH 128
+#    define LLONG_WIDTH 128
+#   endif
+#  endif
+# endif
+#endif
+
+// In most cases the [u]intmax_t types will just be the long long
+// types.
+#ifndef UINTMAX_WIDTH
+# if UINTMAX_MAX == ULLONG_MAX
+#  define UINTMAX_WIDTH ULLONG_WIDTH
+#  define INTMAX_WIDTH  LLONG_WIDTH
+# endif
+#endif
+
+#ifndef UINT128_MAX
+# ifdef __SIZEOF_INT128__
+#  if defined(__clang_major__) && (__clang_major__ < 18)
+#   ifndef C23_FALLBACK_SILENT
+#    warning "not using compiler intrinsic for int128_t, please upgrade to clang version ≥ 18"
+#   endif
+#  else
+#   define __has_int128
+#  endif
+# endif
+#endif
+
+#ifndef UINT256_MAX
+# ifdef __SIZEOF_INT256__
+#  if defined(__clang_major__) && (__clang_major__ < 18)
+#   ifndef C23_FALLBACK_SILENT
+#    warning "not using compiler intrinsic for int256_t, please upgrade to clang version ≥ 18"
+#   endif
+#  else
+#   define __has_int256
+#  endif
+# endif
+#endif
+
+// In C23 uint128_t may exist, even if it is wider than
+// uintmax_t. Provide it if the compiler supports it.
+#ifndef UINT128_MAX
+# ifdef __has_int128
+typedef signed __int128 int128_t;
+typedef unsigned __int128 uint128_t;
+#  define UINT128_WIDTH 128
+#  define INT128_WIDTH  128
+#  define UINT128_MAX   ((uint128_t)-1)
+#  define INT128_MAX    ((int128_t)(((uint128_t)-1)>>1))
+#  define INT128_MIN    (-INT128_MAX-1)
+#  if BITINT_MAXWIDTH >= 128
+#   define UINT128_C(X) ((uint128_t)+(X ## wbu))
+#   define INT128_C(X)  ((int128_t)+(X ## wb))
+#  endif
+# endif
+#endif
+
+// In C23 uint256_t may exist, even if it is wider than
+// uintmax_t. Provide it if the compiler supports it.
+#ifndef UINT256_MAX
+# ifdef __has_int256
+typedef signed __int256 int256_t;
+typedef unsigned __int256 uint256_t;
+#  define UINT256_WIDTH 256
+#  define INT256_WIDTH  256
+#  define UINT256_MAX   ((uint256_t)-1)
+#  define INT256_MAX    ((int256_t)(((uint256_t)-1)>>1))
+#  define INT256_MIN    (-INT256_MAX-1)
+#  if BITINT_MAXWIDTH >= 256
+#   define UINT256_C(X) ((uint256_t)+(X ## wbu))
+#   define INT256_C(X)  ((int256_t)+(X ## wb))
+#  endif
+# endif
+#endif
+
+/**********************************************************************************************/
+
+#if __STDC_VERSION_INTTYPES_H__ < 202311L
+# ifndef C23_FALLBACK_SILENT
+#  warning "native C23 library support for %b printf or scanf formats may be missing"
+# endif
+# ifndef PRIb32
+#  if __GLIBC__ > 1 && defined(__PRI64_PREFIX)
+#   ifndef C23_FALLBACK_SILENT
+#    warning "no C23 support for %b printf formats found, emulating with glibc features"
+#   endif
+#   define PRIB16      "B"
+#   define PRIB32      "B"
+#   define PRIB64      __PRI64_PREFIX "B"
+#   define PRIB8       "B"
+#   define PRIBFAST16  __PRIPTR_PREFIX "B"
+#   define PRIBFAST32  __PRIPTR_PREFIX "B"
+#   define PRIBFAST64  __PRI64_PREFIX "B"
+#   define PRIBFAST8   "B"
+#   define PRIBLEAST16 "B"
+#   define PRIBLEAST32 "B"
+#   define PRIBLEAST64 __PRI64_PREFIX "B"
+#   define PRIBLEAST8  "B"
+#   define PRIBMAX     __PRI64_PREFIX "B"
+#   define PRIBPTR     __PRIPTR_PREFIX "B"
+#   define PRIb16      "b"
+#   define PRIb32      "b"
+#   define PRIb64      __PRI64_PREFIX "b"
+#   define PRIb8       "b"
+#   define PRIbFAST16  __PRIPTR_PREFIX "b"
+#   define PRIbFAST32  __PRIPTR_PREFIX "b"
+#   define PRIbFAST64  __PRI64_PREFIX "b"
+#   define PRIbFAST8   "b"
+#   define PRIbLEAST16 "b"
+#   define PRIbLEAST32 "b"
+#   define PRIbLEAST64 __PRI64_PREFIX "b"
+#   define PRIbLEAST8  "b"
+#   define PRIbMAX     __PRI64_PREFIX "b"
+#   define PRIbPTR     __PRIPTR_PREFIX "b"
+#   define SCNb16      "hb"
+#   define SCNb32      "b"
+#   define SCNb64      __PRI64_PREFIX "b"
+#   define SCNb8       "hhb"
+#   define SCNbFAST16  __PRIPTR_PREFIX "b"
+#   define SCNbFAST32  __PRIPTR_PREFIX "b"
+#   define SCNbFAST64  __PRI64_PREFIX "b"
+#   define SCNbFAST8   "hhb"
+#   define SCNbLEAST16 "hb"
+#   define SCNbLEAST32 "b"
+#   define SCNbLEAST64 __PRI64_PREFIX "b"
+#   define SCNbLEAST8  "hhb"
+#   define SCNbMAX     __PRI64_PREFIX "b"
+#   define SCNbPTR     __PRIPTR_PREFIX "b"
+#  else
+#   ifndef C23_FALLBACK_SILENT
+#    warning "no C23 support for %b printf formats found"
+#   endif
+#  endif
+# endif
+#endif
+
+/**********************************************************************************************/
+
+// Complex arithmetic without <complex.h> header
+#ifndef __STDC_NO_COMPLEX__
+
+// gcc and related compilers implement an "I" or "i" suffix for
+// floating point constants since ages.
+# ifdef __GNUC__
+#  define I (__extension__ 1.0IF)
+#  define _COMPLEX_I (0.0F + I)
+
+// Otherwise use the new constexpr construct to produce a named
+// constant of complex type.
+# else
+typedef union _C23_complex _C23_complex;
+union _C23_complex {
+  // These two are guaranteed to have the same representation.
+  float _C23_v[2];
+  _Complex float _C23_c;
+};
+// Use static const. Best would be to have constexpr, but using a
+// different member than was initialized is not defined for them,
+// unfortunately.
+static _C23_complex const _C23_I = { { 0.0F, 1.0F, }, };
+#  define _COMPLEX_I (_C23_I._C23_c)
+# endif
+
+#define iscomplex(X) (sizeof(1.0F*(X)) == sizeof(1.0F*(X)+_COMPLEX_I))
+#define isimaginary(X) (sizeof(1.0F*(X)+0.0F) == 2*sizeof(1.0F*(X)))
+
+# define _C23_float_Complex_CASE float _Complex: true,
+# define _C23_double_Complex_CASE double _Complex: true,
+# define _C23_long_double_Complex_CASE long double _Complex: true,
+#else
+# define _C23_float_Complex_CASE
+# define _C23_double_Complex_CASE
+# define _C23_long_double_Complex_CASE
+#endif
+
+/**********************************************************************************************/
+
+// Testing for presence of decimal floating types
+
+#if defined(__DEC32_MAX__)
+# define _C23_Decimal32_CASE _Decimal32: true,
+#else
+# define _C23_Decimal32_CASE
+#endif
+
+#if defined(__DEC64_MAX__)
+# define _C23_Decimal64_CASE _Decimal64: true,
+#else
+# define _C23_Decimal64_CASE
+#endif
+
+#if defined(__DEC128_MAX__)
+# define _C23_Decimal128_CASE _Decimal128: true,
+#else
+# define _C23_Decimal128_CASE
+#endif
+
+#define isdecimalfloating(...) (_Generic((__VA_ARGS__)+0, _C23_Decimal32_CASE _C23_Decimal64_CASE _C23_Decimal128_CASE default: false))
+#ifndef iscomplex
+# define iscomplex(...) (_Generic((__VA_ARGS__)+0, _C23_float_Complex_CASE _C23_double_Complex_CASE _C23_long_double_Complex_CASE default: false))
+#endif
+#define isstandardrealfloating(...) (_Generic((__VA_ARGS__)+0, float: true, double: true, long double: true, default: false))
+#define isstandardfloating(...) ((bool)(isstandardrealfloating(__VA_ARGS__)||iscomplex(__VA_ARGS__)))
+#ifndef isfloating
+# define isfloating(...) ((bool)(isstandardfloating(__VA_ARGS__)||isdecimalfloating(__VA_ARGS__)))
+#endif
+
+/**********************************************************************************************/
+
+// various tg-conversions and type traits
+
+#ifndef totype
+# define totype(Y, ...) ((typeof(__VA_ARGS__))Y)
+#endif
+#ifndef tominusone
+# define tominusone(...) totype(-1, __VA_ARGS__)
+#endif
+#ifndef tozero
+# define tozero(...) totype(0, __VA_ARGS__)
+#endif
+#ifndef toone
+# define toone(...) totype(1, __VA_ARGS__)
+#endif
+#ifndef iscompatible
+# define iscompatible(X, Y) (_Generic((X), typeof(Y): true, default: false))
+#endif
+#ifndef is_potentially_negative
+# define is_potentially_negative(...) (tominusone(__VA_ARGS__) < 0)
+#endif
+#ifndef is_const_target
+# define is_const_target(...) (_Generic((1 ? (__VA_ARGS__) : (void*)1), void const*: true, void const volatile*: true, default: false))
+#endif
+#ifndef is_volatile_target
+# define is_volatile_target(...) (_Generic((1 ? (__VA_ARGS__) : (void*)1), void volatile*: true, void const volatile*: true, default: false))
+#endif
+#ifndef is_const
+# define is_const(...) is_const_target(&(typeof(__VA_ARGS__)){ 0 })
+#endif
+#ifndef is_volatile
+# define is_volatile(...) is_volatile_target(&(typeof(__VA_ARGS__)){ 0 })
+#endif
+#ifndef is_null_pointer_constant
+struct do_not_use_this_otherwise;
+# define is_null_pointer_constant(...)                                    \
+  (_Generic((1 ? (struct do_not_use_this_otherwise*)nullptr : (__VA_ARGS__)),     \
+            struct do_not_use_this_otherwise*: true,                    \
+            default: false))
+#endif
+#ifndef is_zero_ice
+# define is_zero_ice(...) is_null_pointer_constant((void*)(uintptr_t)(!!(__VA_ARGS__)))
+#endif
+#ifndef isinteger
+# define isinteger(...) is_zero_ice(tozero(__VA_ARGS__))
+#endif
+#ifndef issigned
+# define issigned(...) ((bool)(is_potentially_negative(__VA_ARGS__) && isinteger(__VA_ARGS__) && !iscompatible(__VA_ARGS__, char)))
+#endif
+#ifndef isunsigned
+# define isunsigned(...) ((bool)(!is_potentially_negative(__VA_ARGS__) && isinteger(__VA_ARGS__) && !iscompatible(__VA_ARGS__, char)))
+#endif
+#ifndef isice
+# define isice(...) is_zero_ice(!((__VA_ARGS__) || 1))
+#endif
+#ifndef isvla
+# define isvla(...) ((bool)!isice(sizeof(__VA_ARGS__)))
+#endif
+#ifndef isxwide
+# define isxwide(...)                           \
+  ((bool)(                                      \
+          isinteger(__VA_ARGS__)                \
+          &&_Generic((__VA_ARGS__)+0ULL,        \
+                     unsigned long long: false, \
+                     default: true)))
+#endif
+
+#ifndef is_pointer
+struct do_not_use_this_otherwise { char c; };
+# define get_fla(...)                                                   \
+  GENERIC_IF(isvla(__VA_ARGS__),                                        \
+             (struct do_not_use_this_otherwise[1]){ 0 },                \
+             (__VA_ARGS__))
+# define is_pointer_nvla(...)                           \
+  (_Generic((typeof(__VA_ARGS__)*)0,                    \
+            typeof(get_fla(*(__VA_ARGS__)))**: true,    \
+            default: false))
+# define is_pointer_vla(...)                                        \
+  (_Generic((typeof(get_fla(*(__VA_ARGS__)))*)0,                    \
+            typeof(struct do_not_use_this_otherwise[1])*: true,     \
+            default: false))
+# define is_pointer(...) ((bool)(is_pointer_nvla(__VA_ARGS__)||is_pointer_vla(__VA_ARGS__)))
+#endif
+#ifndef is_array
+# define is_array(...) ((bool)!is_pointer(__VA_ARGS__))
+#endif
+#ifndef is_fla
+# define is_fla(...) ((bool)(is_array(__VA_ARGS__)&&!isvla(__VA_ARGS__)))
+#endif
+
+#ifndef is_void_pointer
+# define is_void_pointer(...)                                   \
+  _Generic((typeof(*(__VA_ARGS__))const volatile*)nullptr,      \
+           void const volatile*: true,                          \
+           default: false)
+#endif
+
+/**********************************************************************************************/
+
+/* Const preserving functions as of C23. */
+
+/* These are not exactly according to the book, because the return
+   type of the string functions could sometimes be a pointer to a void
+   type and not a character type.*/
+
+#if __STDC_VERSION_STRING_H__ < 202311L
+
+//QVoid *memchr(QVoid *s, int c, size_t n);
+# ifndef memchr
+#  define memchr(S, C, N) ((typeof(1 ? S : (void*)1))memchr((S), (C), (N)))
+# endif
+
+// QChar *strchr(QChar *s, int c);
+# ifndef strchr
+#  define strchr(S, C) ((typeof(S))strchr((S), (C)))
+# endif
+
+// QChar *strpbrk(QChar *s1, const char *s2);
+# ifndef strpbrk
+#  define strpbrk(S1, S2) ((typeof(S1))strpbrk((S1), (S2)))
+# endif
+
+// QChar *strrchr(QChar *s, int c);
+# ifndef strrchr
+#  define strrchr(S, C) ((typeof(S))strrchr((S), (C)))
+# endif
+
+// QChar *strstr(QChar *s1, const char *s2);
+# ifndef strstr
+#  define strstr(S1, S2) ((typeof(S1))strstr((S1), (S2)))
+# endif
+
+#endif
+
+#if __STDC_VERSION_WCHAR_H__ < 202311L
+
+//QWchar *wmemchr(QWchar *s, int c, size_t n);
+# ifndef wmemchr
+#  define wmemchr(S, C, N) ((typeof(S))wmemchr((S), (C), (N)))
+# endif
+
+// QWchar *wcschr(QWchar *s, wchar_t c);
+# ifndef wcschr
+#  define wcschr(S, C) ((typeof(S))wcschr((S), (C)))
+# endif
+
+// QWchar *wcspbrk(QWchar *s1, const wchar_t *s2);
+# ifndef wcspbrk
+#  define wcspbrk(S1, S2) ((typeof(S1))wcspbrk((S1), (S2)))
+# endif
+
+// QWchar *wcsrchr(QWchar *s, wchar_t c);
+# ifndef wcsrchr
+#  define wcsrchr(S, C) ((typeof(S))wcsrchr((S), (C)))
+# endif
+
+// QWchar *wcswcs(QWchar *s1, const wchar_t *s2);
+# ifndef wcsstr
+#  define wcsstr(S1, S2) ((typeof(S1))wcsstr((S1), (S2)))
+# endif
+
+#endif
+
+#if __STDC_VERSION_STDLIB_H__ < 202311L
+
+// QVoid *bsearch(const void *key, QVoid *base, size_t nmemb, size_t size,
+//               int (*compar)(const void *, const void *));
+# ifndef bsearch
+#  define bsearch(KEY, BASE, NMEMB, SIZE, COMPAR) ((typeof(1 ? (BASE) : (void*)1))bsearch((KEY), (BASE), (NMEMB), (SIZE), (COMPAR)))
+# endif
+
+#endif
+
+#endif
+
+/**********************************************************************************************/
+
+#ifdef __has_include
+# if __has_include(<stdbit.h>)
+#  include <stdbit.h>
+#  define __has_feature_c_stdbit_h ,
+# endif
+#endif
+
+#ifndef __STDC_ENDIAN_LITTLE__
+# ifdef __GNUC__
+#  define __STDC_ENDIAN_LITTLE__ __ORDER_LITTLE_ENDIAN__
+# endif
+#endif
+
+#ifndef __STDC_ENDIAN_BIG__
+# ifdef __GNUC__
+#  define __STDC_ENDIAN_BIG__ __ORDER_BIG_ENDIAN__
+# endif
+#endif
+
+#ifndef __STDC_ENDIAN_NATIVE__
+# ifdef __GNUC__
+#  define __STDC_ENDIAN_NATIVE__ __BYTE_ORDER__
+# else
+#  ifndef C23_FALLBACK_SILENT
+#   warning "native endian could not be determined"
+#  endif
+# endif
+#endif
+
+/**********************************************************************************************/
+
+/* This adds the 14 type-generic bit interfaces that are added by
+   C23. The use of the other type-specific interfaces is of less
+   interest.
+
+generic_return_type stdc_leading_zeros(generic_value_type value);
+generic_return_type stdc_leading_ones(generic_value_type value);
+generic_return_type stdc_trailing_zeros(generic_value_type value);
+generic_return_type stdc_trailing_ones(generic_value_type value);
+generic_return_type stdc_first_leading_zero(generic_value_type value);
+generic_return_type stdc_first_leading_one(generic_value_type value);
+generic_return_type stdc_first_trailing_zero(generic_value_type value);
+generic_return_type stdc_count_zeros(generic_value_type value);
+generic_return_type stdc_count_ones(generic_value_type value);
+bool stdc_has_single_bit(generic_value_type value);
+generic_return_type stdc_bit_width(generic_value_type value);
+generic_value_type stdc_bit_floor(generic_value_type value);
+generic_value_type stdc_bit_ceil(generic_value_type value);
+
+*/
+
+/*
+  An auxiliary macro that shifts right by ULLONG_WIDTH, regardless
+  whether the type has a width smaller than that. For most types this
+  will just be a zero of the same type.
+ */
+
+#define shift_xright(...)                                       \
+  GENERIC_IF(isxwide(__VA_ARGS__),                              \
+             (__VA_ARGS__)>>GENERIC_IF(isxwide(__VA_ARGS__),    \
+                                       ULLONG_WIDTH,            \
+                                       0),                      \
+             tozero(__VA_ARGS__))
+
+#ifndef stdc_count_ones
+# ifdef __GNUC__
+
+#  define stdc_trailing_zeros(...)                                      \
+  ({                                                                    \
+    auto s_t_z_x = (__VA_ARGS__);                                       \
+    static_assert(isunsigned(s_t_z_x), "bit operation needs unsigned type"); \
+    (s_t_z_x)                                                           \
+      ? _Generic((s_t_z_x),                                             \
+                 bool:               __builtin_ctz((unsigned)s_t_z_x),  \
+                 unsigned char:      __builtin_ctz((unsigned)s_t_z_x),  \
+                 unsigned short:     __builtin_ctz((unsigned)s_t_z_x),  \
+                 unsigned:           __builtin_ctz(s_t_z_x),            \
+                 unsigned long:      __builtin_ctzl(s_t_z_x),           \
+                 unsigned long long: __builtin_ctzll(s_t_z_x),          \
+                 default: ({                                            \
+                     size_t s_t_z_ret = 0;                              \
+                     while (s_t_z_x) {                                  \
+                       unsigned long long s_t_z_z = s_t_z_x;            \
+                       if (s_t_z_z) {                                   \
+                         s_t_z_ret += __builtin_ctzll(s_t_z_z);         \
+                         s_t_z_x = 0;                                   \
+                       } else {                                         \
+                         s_t_z_ret += ULLONG_WIDTH;                     \
+                         s_t_z_x = shift_xright(s_t_z_x);               \
+                       }                                                \
+                     }                                                  \
+                     s_t_z_ret;                                         \
+                   }))                                                  \
+      : stdc_count_ones(tominusone(s_t_z_x));                           \
+  })
+
+/* This counts the least significant 1-bits of the specific type of the
+   argument. Therefor we complement all bits. To take narrow types
+   into account, that result has to be cast back to the original
+   type. */
+#  define stdc_trailing_ones(...) stdc_trailing_zeros((typeof(__VA_ARGS__))~(__VA_ARGS__))
+
+#  define stdc_leading_zeros(...)                                       \
+  ({                                                                    \
+    auto s_l_o_x = (__VA_ARGS__);                                       \
+    static_assert(isunsigned(s_l_o_x), "bit operation needs unsigned type"); \
+    (s_l_o_x)                                                           \
+      ? _Generic((s_l_o_x),                                             \
+                 unsigned char:      __builtin_clz((unsigned)s_l_o_x) - __builtin_clz((unsigned)tominusone(s_l_o_x)), \
+                 unsigned short:     __builtin_clz((unsigned)s_l_o_x) - __builtin_clz((unsigned)tominusone(s_l_o_x)), \
+                 unsigned:           __builtin_clz(s_l_o_x),            \
+                 unsigned long:      __builtin_clzl(s_l_o_x),           \
+                 unsigned long long: __builtin_clzll(s_l_o_x),          \
+                 default:                                               \
+                 ((!isxwide(s_l_o_x))                                   \
+                  /* Should only trigger for _BitInt types. */          \
+                  ? (__builtin_clzll(s_l_o_x) - __builtin_clzll(tominusone(s_l_o_x))) \
+                  /* determine the long long word with highest 1-bit . */ \
+                  : ({                                                  \
+                      size_t s_l_o_w = stdc_count_ones(tominusone(s_l_o_x)) - ULLONG_WIDTH; \
+                      while ((s_l_o_x+0UL) > ULLONG_MAX) {              \
+                        s_l_o_x = shift_xright(s_l_o_x);                \
+                        s_l_o_w -= ULLONG_WIDTH;                        \
+                      }                                                 \
+                      __builtin_clzll(s_l_o_x) + s_l_o_w;               \
+                    })))                                                \
+      /* This should resolve to a compile time constant. */             \
+      : stdc_count_ones(tominusone(s_l_o_x));                           \
+  })
+
+
+/* This counts the most significant 1-bits of the specific type of the
+   argument. Therefor we complement all bits. To take narrow types
+   into account, that result has to be cast back to the original
+   type. */
+#  define stdc_leading_ones(...) stdc_leading_zeros((typeof(__VA_ARGS__))~(__VA_ARGS__))
+
+
+#  define stdc_count_ones(...)                                          \
+  _Generic((__VA_ARGS__),                                               \
+           bool:               __builtin_popcount((unsigned)(__VA_ARGS__)), \
+           unsigned char:      __builtin_popcount((unsigned)(__VA_ARGS__)), \
+           unsigned short:     __builtin_popcount((unsigned)(__VA_ARGS__)), \
+           unsigned:           __builtin_popcount((unsigned)(__VA_ARGS__)), \
+           unsigned long:      __builtin_popcountl((unsigned long)(__VA_ARGS__)), \
+           unsigned long long: __builtin_popcountll((unsigned long long)(__VA_ARGS__)), \
+           default: ({                                                  \
+               auto s_c_o_x = (__VA_ARGS__);                            \
+               static_assert(isunsigned(s_c_o_x), "bit operation needs unsigned type"); \
+               size_t s_c_o_ret = 0;                                    \
+               while (s_c_o_x) {                                        \
+                 s_c_o_ret += __builtin_popcountll((unsigned long long)s_c_o_x); \
+                 s_c_o_x = shift_xright(s_c_o_x);                       \
+               }                                                        \
+               s_c_o_ret;                                               \
+             }))
+
+
+/* This counts the 0-bits of the specific type of the
+   argument. Therefor we complement all bits. To take narrow types
+   into account, that result has to be cast back to the original
+   type. */
+#  define stdc_count_zeros(...) stdc_count_ones((typeof(__VA_ARGS__))~(__VA_ARGS__))
+
+#  define stdc_has_single_bit(...)                                      \
+  ({                                                                    \
+    auto s_h_s_b_x = (__VA_ARGS__);                                     \
+    static_assert(isunsigned(s_h_s_b_x), "bit operation needs unsigned type"); \
+    (bool)(s_h_s_b_x && !((s_h_s_b_x != 1) && (s_h_s_b_x & (s_h_s_b_x - 1)))); \
+  })
+
+#  define stdc_bit_width(...)                                           \
+  ({                                                                    \
+  auto s_b_w_x = (__VA_ARGS__);                                         \
+  static_assert(isunsigned(s_b_w_x), "bit operation needs unsigned type"); \
+  stdc_count_ones(tominusone(s_b_w_x))-stdc_leading_zeros(s_b_w_x);     \
+  })
+
+#  define stdc_bit_floor(...)                                           \
+  ({                                                                    \
+  auto s_b_f_x = (__VA_ARGS__);                                         \
+  static_assert(isunsigned(s_b_f_x), "bit operation needs unsigned type"); \
+  (!s_b_f_x)                                                            \
+    ? 0                                                                 \
+    : (toone(s_b_f_x)<<(stdc_bit_width(s_b_f_x)-1));                    \
+  })
+
+#  define stdc_bit_ceil(...)                            \
+  (toone(__VA_ARGS__)<<stdc_bit_width(__VA_ARGS__))
+
+# endif
+#endif