From 97f21e24dcc7a021f64d88d494b70ea3cb4396d3 Mon Sep 17 00:00:00 2001 From: zeichensystem <83899451+zeichensystem@users.noreply.github.com> Date: Tue, 23 Dec 2025 21:13:41 +0100 Subject: [PATCH] Update libguf --- libguf/{src => }/guf_alloc.h | 0 libguf/{src => }/guf_alloc_libc.h | 3 +- libguf/{src => }/guf_alloc_tracker.h | 0 libguf/{src => }/guf_assert.h | 0 libguf/{src => }/guf_common.h | 0 libguf/{src => }/guf_cstr.h | 13 +- libguf/{src => }/guf_dbuf.h | 0 libguf/{src => }/guf_dict.h | 4 +- libguf/{src => }/guf_hash.h | 0 libguf/{src => }/guf_id_pool.h | 0 libguf/{src => }/guf_init.h | 0 libguf/{src => }/guf_linalg.h | 0 libguf/{src => }/guf_math.h | 8 +- libguf/{src => }/guf_math_ckdint.h | 947 ++++++------ libguf/{src => }/guf_rand.h | 14 +- libguf/{src => }/guf_sort.h | 0 libguf/{src => }/guf_str.h | 4 +- libguf/{src => }/guf_str_view_type.h | 0 libguf/{src => }/guf_utf8.h | 10 +- libguf/{src => }/guf_utils.h | 0 libguf/src/.DS_Store | Bin 6148 -> 0 bytes libguf/test/data/bartleby.txt | 1941 ++++++++++++++++++++++++ libguf/test/data/utf8-test.txt | 67 + libguf/test/example.c | 320 ++++ libguf/test/impls/alloc_libc_impl.c | 2 + libguf/test/impls/alloc_tracker_impl.c | 2 + libguf/test/impls/ckdint_impl.c | 2 + libguf/test/impls/dbuf_impl.c | 55 + libguf/test/impls/dbuf_impl.h | 53 + libguf/test/impls/dict_impl.c | 47 + libguf/test/impls/dict_impl.h | 61 + libguf/test/impls/init_impl.c | 1 + libguf/test/impls/linalg_impl.c | 2 + libguf/test/impls/rand_impl.c | 2 + libguf/test/impls/sort_impl.c | 17 + libguf/test/impls/sort_impl.h | 18 + libguf/test/impls/str_impl.c | 2 + libguf/test/test.cpp | 64 + libguf/test/test.hpp | 108 ++ libguf/test/test_ckdint.cpp | 361 +++++ libguf/test/test_ckdint.hpp | 12 + libguf/test/test_dbuf.cpp | 685 +++++++++ libguf/test/test_dbuf.hpp | 69 + libguf/test/test_dict.cpp | 431 ++++++ libguf/test/test_dict.hpp | 35 + libguf/test/test_str.cpp | 379 +++++ libguf/test/test_str.hpp | 33 + libguf/test/test_utf8.cpp | 387 +++++ libguf/test/test_utf8.hpp | 36 + 49 files changed, 5698 insertions(+), 497 deletions(-) rename libguf/{src => }/guf_alloc.h (100%) rename libguf/{src => }/guf_alloc_libc.h (95%) rename libguf/{src => }/guf_alloc_tracker.h (100%) rename libguf/{src => }/guf_assert.h (100%) rename libguf/{src => }/guf_common.h (100%) rename libguf/{src => }/guf_cstr.h (88%) rename libguf/{src => }/guf_dbuf.h (100%) rename libguf/{src => }/guf_dict.h (97%) rename libguf/{src => }/guf_hash.h (100%) rename libguf/{src => }/guf_id_pool.h (100%) rename libguf/{src => }/guf_init.h (100%) rename libguf/{src => }/guf_linalg.h (100%) rename libguf/{src => }/guf_math.h (99%) rename libguf/{src => }/guf_math_ckdint.h (86%) rename libguf/{src => }/guf_rand.h (98%) rename libguf/{src => }/guf_sort.h (100%) rename libguf/{src => }/guf_str.h (99%) rename libguf/{src => }/guf_str_view_type.h (100%) rename libguf/{src => }/guf_utf8.h (98%) rename libguf/{src => }/guf_utils.h (100%) delete mode 100755 libguf/src/.DS_Store create mode 100755 libguf/test/data/bartleby.txt create mode 100755 libguf/test/data/utf8-test.txt create mode 100755 libguf/test/example.c create mode 100755 libguf/test/impls/alloc_libc_impl.c create mode 100755 libguf/test/impls/alloc_tracker_impl.c create mode 100755 libguf/test/impls/ckdint_impl.c create mode 100755 libguf/test/impls/dbuf_impl.c create mode 100755 libguf/test/impls/dbuf_impl.h create mode 100755 libguf/test/impls/dict_impl.c create mode 100755 libguf/test/impls/dict_impl.h create mode 100755 libguf/test/impls/init_impl.c create mode 100755 libguf/test/impls/linalg_impl.c create mode 100755 libguf/test/impls/rand_impl.c create mode 100755 libguf/test/impls/sort_impl.c create mode 100755 libguf/test/impls/sort_impl.h create mode 100755 libguf/test/impls/str_impl.c create mode 100755 libguf/test/test.cpp create mode 100755 libguf/test/test.hpp create mode 100755 libguf/test/test_ckdint.cpp create mode 100755 libguf/test/test_ckdint.hpp create mode 100755 libguf/test/test_dbuf.cpp create mode 100755 libguf/test/test_dbuf.hpp create mode 100755 libguf/test/test_dict.cpp create mode 100755 libguf/test/test_dict.hpp create mode 100755 libguf/test/test_str.cpp create mode 100755 libguf/test/test_str.hpp create mode 100755 libguf/test/test_utf8.cpp create mode 100755 libguf/test/test_utf8.hpp diff --git a/libguf/src/guf_alloc.h b/libguf/guf_alloc.h similarity index 100% rename from libguf/src/guf_alloc.h rename to libguf/guf_alloc.h diff --git a/libguf/src/guf_alloc_libc.h b/libguf/guf_alloc_libc.h similarity index 95% rename from libguf/src/guf_alloc_libc.h rename to libguf/guf_alloc_libc.h index 2adb63c..b8a5f7c 100755 --- a/libguf/src/guf_alloc_libc.h +++ b/libguf/guf_alloc_libc.h @@ -23,7 +23,6 @@ typedef struct guf_libc_alloc_ctx { #if !defined(GUF_ALLOC_LIBC_IMPL_STATIC) && !defined(GUF_ALLOC_LIBC_IMPL) GUF_ALLOC_LIBC_KWRDS void *guf_libc_alloc(ptrdiff_t size, void *ctx); GUF_ALLOC_LIBC_KWRDS void *guf_libc_realloc(void *ptr, ptrdiff_t old_size, ptrdiff_t new_size, void *ctx); - GUF_ALLOC_LIBC_KWRDS void *guf_libc_realloc(void *ptr, ptrdiff_t old_size, ptrdiff_t new_size, void *ctx); GUF_ALLOC_LIBC_KWRDS void guf_libc_free(void *ptr, ptrdiff_t size, void *ctx); GUF_ALLOC_LIBC_KWRDS guf_allocator *guf_libc_allocator_init(guf_allocator *a, guf_libc_alloc_ctx *ctx); @@ -71,7 +70,7 @@ GUF_ALLOC_LIBC_KWRDS void *guf_libc_realloc(void *ptr, ptrdiff_t old_size, ptrdi const ptrdiff_t len = new_size - old_size; GUF_ASSERT(len > 0); GUF_ASSERT(old_size + len == new_size); - memset((char*)ptr + old_size, 0, len); // TODO: sketchy + memset((char*)new_ptr + old_size, 0, len); // TODO: sketchy } if (alloc_ctx && alloc_ctx->tracker.enabled) { diff --git a/libguf/src/guf_alloc_tracker.h b/libguf/guf_alloc_tracker.h similarity index 100% rename from libguf/src/guf_alloc_tracker.h rename to libguf/guf_alloc_tracker.h diff --git a/libguf/src/guf_assert.h b/libguf/guf_assert.h similarity index 100% rename from libguf/src/guf_assert.h rename to libguf/guf_assert.h diff --git a/libguf/src/guf_common.h b/libguf/guf_common.h similarity index 100% rename from libguf/src/guf_common.h rename to libguf/guf_common.h diff --git a/libguf/src/guf_cstr.h b/libguf/guf_cstr.h similarity index 88% rename from libguf/src/guf_cstr.h rename to libguf/guf_cstr.h index db30b62..c49a935 100755 --- a/libguf/src/guf_cstr.h +++ b/libguf/guf_cstr.h @@ -9,6 +9,15 @@ #include "guf_assert.h" #include "guf_hash.h" +static inline char *guf_cstr_dup(const char *cstr) +{ + char *cpy = (char*)calloc(strlen(cstr) + 1, 1); // Explicit conversion for cpp... + if (cpy) { + strcpy(cpy, cstr); + } + return cpy; +} + typedef const char* guf_cstr_const; static inline int guf_cstr_const_cmp(const guf_cstr_const *a, const guf_cstr_const *b) @@ -42,11 +51,11 @@ static inline guf_cstr_heap *guf_cstr_heap_copy(guf_cstr_heap *dst, const guf_cs *dst = NULL; return dst; } - *dst = strdup(*src); + *dst = guf_cstr_dup(*src); GUF_ASSERT_RELEASE(*dst); return dst; } - +// static inline guf_cstr_heap *guf_cstr_heap_move(guf_cstr_heap *dst, guf_cstr_heap *src, void *ctx) { (void)ctx; diff --git a/libguf/src/guf_dbuf.h b/libguf/guf_dbuf.h similarity index 100% rename from libguf/src/guf_dbuf.h rename to libguf/guf_dbuf.h diff --git a/libguf/src/guf_dict.h b/libguf/guf_dict.h similarity index 97% rename from libguf/src/guf_dict.h rename to libguf/guf_dict.h index 37308fe..7e27dd5 100755 --- a/libguf/src/guf_dict.h +++ b/libguf/guf_dict.h @@ -275,7 +275,7 @@ GUF_DICT_KWRDS GUF_DICT_NAME *GUF_CAT(GUF_DICT_NAME, _try_init_with_capacity)(GU if (kv_elem_capacity > 0) { const size_t MAX_IDX_CAP = GUF_ALLOC_MAX_CAPACITY(GUF_DICT_KV_META_T); - const size_t desired_idx_cap = (size_t)guf_min_f64(kv_elem_capacity * 1.0 / GUF_DICT_MAX_LOAD_FACTOR, MAX_IDX_CAP); + const size_t desired_idx_cap = (size_t)guf_min_f64((double)kv_elem_capacity * 1.0 / GUF_DICT_MAX_LOAD_FACTOR, (double)MAX_IDX_CAP); // Capacities must be powers of two. size_t kv_idx_cap = 1; while ((kv_idx_cap <= MAX_IDX_CAP / 2) && (kv_idx_cap <= desired_idx_cap)) { @@ -598,7 +598,7 @@ static void GUF_CAT(GUF_DICT_NAME, _try_grow_if_necessary_)(GUF_DICT_NAME *ht, b ht->kv_indices = new_kv_indices; ht->kv_indices_cap = ht->kv_indices_cap * KV_META_GROWTH_FAC;; GUF_ASSERT(guf_is_pow2_size_t(ht->kv_indices_cap)); - GUF_ASSERT(new_size_bytes / sizeof(GUF_DICT_KV_META_T) == ht->kv_indices_cap); + GUF_ASSERT((ptrdiff_t)(new_size_bytes / sizeof(GUF_DICT_KV_META_T)) == ht->kv_indices_cap); // ht->max_probelen = 0; GUF_CAT(GUF_DICT_NAME, _reinsert_elems_)(ht); GUF_ASSERT(ht->num_tombstones == 0); diff --git a/libguf/src/guf_hash.h b/libguf/guf_hash.h similarity index 100% rename from libguf/src/guf_hash.h rename to libguf/guf_hash.h diff --git a/libguf/src/guf_id_pool.h b/libguf/guf_id_pool.h similarity index 100% rename from libguf/src/guf_id_pool.h rename to libguf/guf_id_pool.h diff --git a/libguf/src/guf_init.h b/libguf/guf_init.h similarity index 100% rename from libguf/src/guf_init.h rename to libguf/guf_init.h diff --git a/libguf/src/guf_linalg.h b/libguf/guf_linalg.h similarity index 100% rename from libguf/src/guf_linalg.h rename to libguf/guf_linalg.h diff --git a/libguf/src/guf_math.h b/libguf/guf_math.h similarity index 99% rename from libguf/src/guf_math.h rename to libguf/guf_math.h index 44f3896..4863bca 100755 --- a/libguf/src/guf_math.h +++ b/libguf/guf_math.h @@ -215,16 +215,16 @@ static inline unsigned long long guf_uabs_long_long(long long x) {if (x >= 0 static inline size_t guf_uabs_ptrdiff_t(ptrdiff_t x) {if (x >= 0) {return x;} else if (x == PTRDIFF_MIN && -PTRDIFF_MAX != PTRDIFF_MIN) {return (size_t)PTRDIFF_MAX + 1u;} else {return -x;}} #if defined(UINT8_MAX) && defined(INT8_MAX) - static inline uint8_t guf_uabs_i8(int8_t x) {if (x >= 0) {return x;} else if (x == INT8_MIN) {return (uint8_t)INT8_MAX + 1u;} else {return -x;}} + static inline uint8_t guf_uabs_i8(int8_t x) {if (x >= 0) {return x;} else if (x == INT8_MIN) {return (uint8_t)INT8_MAX + (uint8_t)1u;} else {return (uint8_t)-x;}} #endif #if defined(UINT16_MAX) && defined(INT16_MAX) - static inline uint16_t guf_uabs_i16(int16_t x) {if (x >= 0) {return x;} else if (x == INT16_MIN) {return (uint16_t)INT16_MAX + 1u;} else {return -x;}} + static inline uint16_t guf_uabs_i16(int16_t x) {if (x >= 0) {return x;} else if (x == INT16_MIN) {return (uint16_t)INT16_MAX + (uint16_t)1u;} else {return (uint16_t)-x;}} #endif #if defined(UINT32_MAX) && defined(INT32_MAX) - static inline uint32_t guf_uabs_i32(int32_t x) {if (x >= 0) {return x;} else if (x == INT32_MIN) {return (uint32_t)INT32_MAX + 1u;} else {return -x;}} + static inline uint32_t guf_uabs_i32(int32_t x) {if (x >= 0) {return x;} else if (x == INT32_MIN) {return (uint32_t)INT32_MAX + (uint32_t)1u;} else {return (uint32_t)-x;}} #endif #if defined(UINT64_MAX) && defined(INT64_MAX) - static inline uint64_t guf_uabs_i64(int64_t x) {if (x >= 0) {return x;} else if (x == INT64_MIN) {return (uint64_t)INT64_MAX + 1u;} else {return -x;}} + static inline uint64_t guf_uabs_i64(int64_t x) {if (x >= 0) {return x;} else if (x == INT64_MIN) {return (uint64_t)INT64_MAX + (uint64_t)1u;} else {return (uint64_t)-x;}} #endif // absdiff functions with unsigned result (cannot fail) diff --git a/libguf/src/guf_math_ckdint.h b/libguf/guf_math_ckdint.h similarity index 86% rename from libguf/src/guf_math_ckdint.h rename to libguf/guf_math_ckdint.h index d5aa5e9..61db381 100755 --- a/libguf/src/guf_math_ckdint.h +++ b/libguf/guf_math_ckdint.h @@ -70,9 +70,9 @@ #if defined(GUF_MATH_CKDINT_IMPL_STATIC) - #define GUF_MATH_CKDINT_KWRDS static inline +#define GUF_MATH_CKDINT_KWRDS static inline #else - #define GUF_MATH_CKDINT_KWRDS +#define GUF_MATH_CKDINT_KWRDS #endif #ifndef GUF_MATH_CKDINT_H @@ -81,125 +81,125 @@ typedef enum guf_math_ckd_result {GUF_MATH_CKD_SUCCESS = 0, GUF_MATH_CKD_OVERFLOW_POS, GUF_MATH_CKD_OVERFLOW_NEG} guf_math_ckd_result; -#if !defined(GUF_MATH_CKDINT_IMPL_STATIC) && !defined(GUF_MATH_CKDINT_IMPL) +#if !defined(GUF_MATH_CKDINT_IMPL_STATIC) && !defined(GUF_MATH_CKDINT_IMPL) // Signed integer arithmetic checks (generated with libguf/tools/ckdint-gen.py) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_int(int a, int b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_int(int a, int b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_int(int a, int b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_int(int a, int b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_long(long a, long b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_long(long a, long b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_long(long a, long b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_long(long a, long b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_long_long(long long a, long long b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_long_long(long long a, long long b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_long_long(long long a, long long b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_long_long(long long a, long long b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_ptrdiff_t(ptrdiff_t a, ptrdiff_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_ptrdiff_t(ptrdiff_t a, ptrdiff_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ptrdiff_t(ptrdiff_t a, ptrdiff_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ptrdiff_t(ptrdiff_t a, ptrdiff_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_i8(int_least8_t a, int_least8_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i8(int_least8_t a, int_least8_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i8(int_least8_t a, int_least8_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i8(int_least8_t a, int_least8_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_i16(int_least16_t a, int_least16_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i16(int_least16_t a, int_least16_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i16(int_least16_t a, int_least16_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i16(int_least16_t a, int_least16_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_i32(int_least32_t a, int_least32_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i32(int_least32_t a, int_least32_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i32(int_least32_t a, int_least32_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i32(int_least32_t a, int_least32_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_i64(int_least64_t a, int_least64_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i64(int_least64_t a, int_least64_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i64(int_least64_t a, int_least64_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i64(int_least64_t a, int_least64_t b); #ifdef INT8_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_i8(int8_t a, int8_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i8(int8_t a, int8_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i8(int8_t a, int8_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i8(int8_t a, int8_t b); #endif #ifdef INT16_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_i16(int16_t a, int16_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i16(int16_t a, int16_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i16(int16_t a, int16_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i16(int16_t a, int16_t b); #endif #ifdef INT32_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_i32(int32_t a, int32_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i32(int32_t a, int32_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i32(int32_t a, int32_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i32(int32_t a, int32_t b); #endif #ifdef INT64_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_i64(int64_t a, int64_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i64(int64_t a, int64_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i64(int64_t a, int64_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i64(int64_t a, int64_t b); #endif -// Unsigned integer arithmetic checks (generated with libguf/tools/ckdint-gen.py) +// Unsigned integer arithmetic checks (generated with libguf/tools/ckdint-gen.py) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_uchar(unsigned char a, unsigned char b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_uchar(unsigned char a, unsigned char b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_uchar(unsigned char a, unsigned char b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_uchar(unsigned char a, unsigned char b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_unsigned(unsigned a, unsigned b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_unsigned(unsigned a, unsigned b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_unsigned(unsigned a, unsigned b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_unsigned(unsigned a, unsigned b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_ulong(unsigned long a, unsigned long b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_ulong(unsigned long a, unsigned long b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ulong(unsigned long a, unsigned long b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ulong(unsigned long a, unsigned long b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_ulong_long(unsigned long long a, unsigned long long b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_ulong_long(unsigned long long a, unsigned long long b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ulong_long(unsigned long long a, unsigned long long b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ulong_long(unsigned long long a, unsigned long long b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_size_t(size_t a, size_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_size_t(size_t a, size_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_size_t(size_t a, size_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_size_t(size_t a, size_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u8(uint_least8_t a, uint_least8_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u8(uint_least8_t a, uint_least8_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u8(uint_least8_t a, uint_least8_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u8(uint_least8_t a, uint_least8_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u16(uint_least16_t a, uint_least16_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u16(uint_least16_t a, uint_least16_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u16(uint_least16_t a, uint_least16_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u16(uint_least16_t a, uint_least16_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u32(uint_least32_t a, uint_least32_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u32(uint_least32_t a, uint_least32_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u32(uint_least32_t a, uint_least32_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u32(uint_least32_t a, uint_least32_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u64(uint_least64_t a, uint_least64_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u64(uint_least64_t a, uint_least64_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u64(uint_least64_t a, uint_least64_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u64(uint_least64_t a, uint_least64_t b); #ifdef UINT8_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_u8(uint8_t a, uint8_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_u8(uint8_t a, uint8_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u8(uint8_t a, uint8_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u8(uint8_t a, uint8_t b); #endif #ifdef UINT16_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_u16(uint16_t a, uint16_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_u16(uint16_t a, uint16_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u16(uint16_t a, uint16_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u16(uint16_t a, uint16_t b); #endif #ifdef UINT32_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_u32(uint32_t a, uint32_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_u32(uint32_t a, uint32_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u32(uint32_t a, uint32_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u32(uint32_t a, uint32_t b); #endif #ifdef UINT64_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_u64(uint64_t a, uint64_t b); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_u64(uint64_t a, uint64_t b); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u64(uint64_t a, uint64_t b); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u64(uint64_t a, uint64_t b); #endif @@ -211,7 +211,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_int(int a, int b, i GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_int(int a, int b, int *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_int(int a, int b, int *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_int(int a, int b, int *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_int(int a, int b, int *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_long(long a, long b, long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_long(long a, long b, long *result); @@ -219,7 +219,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_long(long a, long b GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_long(long a, long b, long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_long(long a, long b, long *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long(long a, long b, long *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long(long a, long b, long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_long_long(long long a, long long b, long long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_long_long(long long a, long long b, long long *result); @@ -227,7 +227,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_long_long(long long GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_long_long(long long a, long long b, long long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_long_long(long long a, long long b, long long *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long_long(long long a, long long b, long long *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long_long(long long a, long long b, long long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result); @@ -235,7 +235,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ptrdiff_t(ptrdiff_t GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result); @@ -243,7 +243,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i8(int_least8 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result); @@ -251,7 +251,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i16(int_least GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result); @@ -259,7 +259,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i32(int_least GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result); @@ -267,7 +267,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i64(int_least GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result); #ifdef INT8_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i8(int8_t a, int8_t b, int8_t *result); @@ -276,7 +276,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i8(int8_t a, int8_t GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i8(int8_t a, int8_t b, int8_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i8(int8_t a, int8_t b, int8_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i8(int8_t a, int8_t b, int8_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i8(int8_t a, int8_t b, int8_t *result); #endif #ifdef INT16_MAX @@ -286,7 +286,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i16(int16_t a, int1 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i16(int16_t a, int16_t b, int16_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i16(int16_t a, int16_t b, int16_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i16(int16_t a, int16_t b, int16_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i16(int16_t a, int16_t b, int16_t *result); #endif #ifdef INT32_MAX @@ -296,7 +296,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i32(int32_t a, int3 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i32(int32_t a, int32_t b, int32_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i32(int32_t a, int32_t b, int32_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i32(int32_t a, int32_t b, int32_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i32(int32_t a, int32_t b, int32_t *result); #endif #ifdef INT64_MAX @@ -306,7 +306,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i64(int64_t a, int6 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i64(int64_t a, int64_t b, int64_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i64(int64_t a, int64_t b, int64_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i64(int64_t a, int64_t b, int64_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i64(int64_t a, int64_t b, int64_t *result); #endif @@ -317,7 +317,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_uchar(unsigned char GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_uchar(unsigned char a, unsigned char b, unsigned char *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_uchar(unsigned char a, unsigned char b, unsigned char *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_uchar(unsigned char a, unsigned char b, unsigned char *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_uchar(unsigned char a, unsigned char b, unsigned char *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_unsigned(unsigned a, unsigned b, unsigned *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_unsigned(unsigned a, unsigned b, unsigned *result); @@ -325,7 +325,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_unsigned(unsigned a GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_unsigned(unsigned a, unsigned b, unsigned *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_unsigned(unsigned a, unsigned b, unsigned *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_unsigned(unsigned a, unsigned b, unsigned *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_unsigned(unsigned a, unsigned b, unsigned *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ulong(unsigned long a, unsigned long b, unsigned long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ulong(unsigned long a, unsigned long b, unsigned long *result); @@ -333,7 +333,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ulong(unsigned long GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_ulong(unsigned long a, unsigned long b, unsigned long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_ulong(unsigned long a, unsigned long b, unsigned long *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ulong(unsigned long a, unsigned long b, unsigned long *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ulong(unsigned long a, unsigned long b, unsigned long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result); @@ -341,7 +341,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ulong_long(unsigned GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_size_t(size_t a, size_t b, size_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_size_t(size_t a, size_t b, size_t *result); @@ -349,7 +349,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_size_t(size_t a, si GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_size_t(size_t a, size_t b, size_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_size_t(size_t a, size_t b, size_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_size_t(size_t a, size_t b, size_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_size_t(size_t a, size_t b, size_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result); @@ -357,7 +357,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_u8(uint_least GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result); @@ -365,7 +365,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_u16(uint_leas GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result); @@ -373,7 +373,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_u32(uint_leas GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result); @@ -381,7 +381,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_u64(uint_leas GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result); #ifdef UINT8_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u8(uint8_t a, uint8_t b, uint8_t *result); @@ -390,7 +390,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u8(uint8_t a, uint8 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_u8(uint8_t a, uint8_t b, uint8_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_u8(uint8_t a, uint8_t b, uint8_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u8(uint8_t a, uint8_t b, uint8_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u8(uint8_t a, uint8_t b, uint8_t *result); #endif #ifdef UINT16_MAX @@ -400,7 +400,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u16(uint16_t a, uin GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_u16(uint16_t a, uint16_t b, uint16_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_u16(uint16_t a, uint16_t b, uint16_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u16(uint16_t a, uint16_t b, uint16_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u16(uint16_t a, uint16_t b, uint16_t *result); #endif #ifdef UINT32_MAX @@ -410,7 +410,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u32(uint32_t a, uin GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_u32(uint32_t a, uint32_t b, uint32_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_u32(uint32_t a, uint32_t b, uint32_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u32(uint32_t a, uint32_t b, uint32_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u32(uint32_t a, uint32_t b, uint32_t *result); #endif #ifdef UINT64_MAX @@ -420,7 +420,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u64(uint64_t a, uin GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_u64(uint64_t a, uint64_t b, uint64_t *result); GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_u64(uint64_t a, uint64_t b, uint64_t *result); -GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u64(uint64_t a, uint64_t b, uint64_t *result); +GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u64(uint64_t a, uint64_t b, uint64_t *result); #endif @@ -440,9 +440,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_int(int a, int b) } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_int(int a, int b) { - if (b < 0 && a > INT_MAX + b) { + if (b < 0 && a > INT_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < INT_MIN + b) { + } else if (b > 0 && a < INT_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -451,23 +451,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_int(int a, int b) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_int(int a, int b) { if (b > 0) { - if (a > INT_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > INT_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (INT_MIN != -INT_MAX && b == -1) { // Prevent potential (INT_MIN / b) overflow for b == -1 - return a == INT_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (INT_MIN != -INT_MAX && b == -1) { // Prevent potential (INT_MIN / b) overflow for b == -1 + return a == INT_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -485,9 +485,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_long(long a, long b) } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_long(long a, long b) { - if (b < 0 && a > LONG_MAX + b) { + if (b < 0 && a > LONG_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < LONG_MIN + b) { + } else if (b > 0 && a < LONG_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -496,23 +496,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_long(long a, long b) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_long(long a, long b) { if (b > 0) { - if (a > LONG_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > LONG_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < LONG_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (LONG_MIN != -LONG_MAX && b == -1) { // Prevent potential (LONG_MIN / b) overflow for b == -1 - return a == LONG_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (LONG_MIN != -LONG_MAX && b == -1) { // Prevent potential (LONG_MIN / b) overflow for b == -1 + return a == LONG_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < LONG_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > LONG_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -530,9 +530,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_long_long(long long a, lon } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_long_long(long long a, long long b) { - if (b < 0 && a > LLONG_MAX + b) { + if (b < 0 && a > LLONG_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < LLONG_MIN + b) { + } else if (b > 0 && a < LLONG_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -541,23 +541,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_long_long(long long a, lon GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_long_long(long long a, long long b) { if (b > 0) { - if (a > LLONG_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > LLONG_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < LLONG_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (LLONG_MIN != -LLONG_MAX && b == -1) { // Prevent potential (LLONG_MIN / b) overflow for b == -1 - return a == LLONG_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (LLONG_MIN != -LLONG_MAX && b == -1) { // Prevent potential (LLONG_MIN / b) overflow for b == -1 + return a == LLONG_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < LLONG_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > LLONG_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -575,9 +575,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_ptrdiff_t(ptrdiff_t a, ptr } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_ptrdiff_t(ptrdiff_t a, ptrdiff_t b) { - if (b < 0 && a > PTRDIFF_MAX + b) { + if (b < 0 && a > PTRDIFF_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < PTRDIFF_MIN + b) { + } else if (b > 0 && a < PTRDIFF_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -586,23 +586,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_ptrdiff_t(ptrdiff_t a, ptr GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ptrdiff_t(ptrdiff_t a, ptrdiff_t b) { if (b > 0) { - if (a > PTRDIFF_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > PTRDIFF_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < PTRDIFF_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (PTRDIFF_MIN != -PTRDIFF_MAX && b == -1) { // Prevent potential (PTRDIFF_MIN / b) overflow for b == -1 - return a == PTRDIFF_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (PTRDIFF_MIN != -PTRDIFF_MAX && b == -1) { // Prevent potential (PTRDIFF_MIN / b) overflow for b == -1 + return a == PTRDIFF_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < PTRDIFF_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > PTRDIFF_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -620,9 +620,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_i8(int_least8_t a, i } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i8(int_least8_t a, int_least8_t b) { - if (b < 0 && a > GUF_INT8_MAX + b) { + if (b < 0 && a > GUF_INT8_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < GUF_INT8_MIN + b) { + } else if (b > 0 && a < GUF_INT8_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -631,23 +631,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i8(int_least8_t a, i GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i8(int_least8_t a, int_least8_t b) { if (b > 0) { - if (a > GUF_INT8_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > GUF_INT8_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < GUF_INT8_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (GUF_INT8_MIN != -GUF_INT8_MAX && b == -1) { // Prevent potential (GUF_INT8_MIN / b) overflow for b == -1 - return a == GUF_INT8_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (GUF_INT8_MIN != -GUF_INT8_MAX && b == -1) { // Prevent potential (GUF_INT8_MIN / b) overflow for b == -1 + return a == GUF_INT8_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < GUF_INT8_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > GUF_INT8_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -665,9 +665,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_i16(int_least16_t a, } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i16(int_least16_t a, int_least16_t b) { - if (b < 0 && a > GUF_INT16_MAX + b) { + if (b < 0 && a > GUF_INT16_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < GUF_INT16_MIN + b) { + } else if (b > 0 && a < GUF_INT16_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -676,23 +676,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i16(int_least16_t a, GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i16(int_least16_t a, int_least16_t b) { if (b > 0) { - if (a > GUF_INT16_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > GUF_INT16_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < GUF_INT16_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (GUF_INT16_MIN != -GUF_INT16_MAX && b == -1) { // Prevent potential (GUF_INT16_MIN / b) overflow for b == -1 - return a == GUF_INT16_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (GUF_INT16_MIN != -GUF_INT16_MAX && b == -1) { // Prevent potential (GUF_INT16_MIN / b) overflow for b == -1 + return a == GUF_INT16_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < GUF_INT16_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > GUF_INT16_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -710,9 +710,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_i32(int_least32_t a, } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i32(int_least32_t a, int_least32_t b) { - if (b < 0 && a > GUF_INT32_MAX + b) { + if (b < 0 && a > GUF_INT32_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < GUF_INT32_MIN + b) { + } else if (b > 0 && a < GUF_INT32_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -721,23 +721,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i32(int_least32_t a, GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i32(int_least32_t a, int_least32_t b) { if (b > 0) { - if (a > GUF_INT32_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > GUF_INT32_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < GUF_INT32_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (GUF_INT32_MIN != -GUF_INT32_MAX && b == -1) { // Prevent potential (GUF_INT32_MIN / b) overflow for b == -1 - return a == GUF_INT32_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (GUF_INT32_MIN != -GUF_INT32_MAX && b == -1) { // Prevent potential (GUF_INT32_MIN / b) overflow for b == -1 + return a == GUF_INT32_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < GUF_INT32_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > GUF_INT32_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -755,9 +755,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_i64(int_least64_t a, } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i64(int_least64_t a, int_least64_t b) { - if (b < 0 && a > GUF_INT64_MAX + b) { + if (b < 0 && a > GUF_INT64_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < GUF_INT64_MIN + b) { + } else if (b > 0 && a < GUF_INT64_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -766,23 +766,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_i64(int_least64_t a, GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_i64(int_least64_t a, int_least64_t b) { if (b > 0) { - if (a > GUF_INT64_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > GUF_INT64_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < GUF_INT64_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (GUF_INT64_MIN != -GUF_INT64_MAX && b == -1) { // Prevent potential (GUF_INT64_MIN / b) overflow for b == -1 - return a == GUF_INT64_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (GUF_INT64_MIN != -GUF_INT64_MAX && b == -1) { // Prevent potential (GUF_INT64_MIN / b) overflow for b == -1 + return a == GUF_INT64_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < GUF_INT64_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > GUF_INT64_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -801,9 +801,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_i8(int8_t a, int8_t b) } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i8(int8_t a, int8_t b) { - if (b < 0 && a > INT8_MAX + b) { + if (b < 0 && a > INT8_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < INT8_MIN + b) { + } else if (b > 0 && a < INT8_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -812,23 +812,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i8(int8_t a, int8_t b) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i8(int8_t a, int8_t b) { if (b > 0) { - if (a > INT8_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > INT8_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT8_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (INT8_MIN != -INT8_MAX && b == -1) { // Prevent potential (INT8_MIN / b) overflow for b == -1 - return a == INT8_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (INT8_MIN != -INT8_MAX && b == -1) { // Prevent potential (INT8_MIN / b) overflow for b == -1 + return a == INT8_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT8_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT8_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -848,9 +848,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_i16(int16_t a, int16_t b) } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i16(int16_t a, int16_t b) { - if (b < 0 && a > INT16_MAX + b) { + if (b < 0 && a > INT16_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < INT16_MIN + b) { + } else if (b > 0 && a < INT16_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -859,23 +859,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i16(int16_t a, int16_t b) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i16(int16_t a, int16_t b) { if (b > 0) { - if (a > INT16_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > INT16_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT16_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (INT16_MIN != -INT16_MAX && b == -1) { // Prevent potential (INT16_MIN / b) overflow for b == -1 - return a == INT16_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (INT16_MIN != -INT16_MAX && b == -1) { // Prevent potential (INT16_MIN / b) overflow for b == -1 + return a == INT16_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT16_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT16_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -895,9 +895,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_i32(int32_t a, int32_t b) } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i32(int32_t a, int32_t b) { - if (b < 0 && a > INT32_MAX + b) { + if (b < 0 && a > INT32_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < INT32_MIN + b) { + } else if (b > 0 && a < INT32_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -906,23 +906,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i32(int32_t a, int32_t b) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i32(int32_t a, int32_t b) { if (b > 0) { - if (a > INT32_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > INT32_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT32_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (INT32_MIN != -INT32_MAX && b == -1) { // Prevent potential (INT32_MIN / b) overflow for b == -1 - return a == INT32_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (INT32_MIN != -INT32_MAX && b == -1) { // Prevent potential (INT32_MIN / b) overflow for b == -1 + return a == INT32_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT32_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT32_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -942,9 +942,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_i64(int64_t a, int64_t b) } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i64(int64_t a, int64_t b) { - if (b < 0 && a > INT64_MAX + b) { + if (b < 0 && a > INT64_MAX + b) { return GUF_MATH_CKD_OVERFLOW_POS; - } else if (b > 0 && a < INT64_MIN + b) { + } else if (b > 0 && a < INT64_MIN + b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; @@ -953,23 +953,23 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_i64(int64_t a, int64_t b) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i64(int64_t a, int64_t b) { if (b > 0) { - if (a > INT64_MAX / b) { - return GUF_MATH_CKD_OVERFLOW_POS; + if (a > INT64_MAX / b) { + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT64_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { - return GUF_MATH_CKD_SUCCESS; + return GUF_MATH_CKD_SUCCESS; } } else if (b < 0) { - if (INT64_MIN != -INT64_MAX && b == -1) { // Prevent potential (INT64_MIN / b) overflow for b == -1 - return a == INT64_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; + if (INT64_MIN != -INT64_MAX && b == -1) { // Prevent potential (INT64_MIN / b) overflow for b == -1 + return a == INT64_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT64_MAX / b) { return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT64_MIN / b) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; - } + } } else { return GUF_MATH_CKD_SUCCESS; } @@ -977,10 +977,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_i64(int64_t a, int64_t b) #endif -// Unsigned integer arithmetic checks (generated with libguf/tools/ckdint-gen.py) +// Unsigned integer arithmetic checks (generated with libguf/tools/ckdint-gen.py) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_uchar(unsigned char a, unsigned char b) { - if (b > 0 && a > UCHAR_MAX - b) { + if (b > 0 && a > UCHAR_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1002,7 +1002,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_uchar(unsigned char a, uns GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_unsigned(unsigned a, unsigned b) { - if (b > 0 && a > UINT_MAX - b) { + if (b > 0 && a > UINT_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1024,7 +1024,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_unsigned(unsigned a, unsig GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_ulong(unsigned long a, unsigned long b) { - if (b > 0 && a > ULONG_MAX - b) { + if (b > 0 && a > ULONG_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1046,7 +1046,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ulong(unsigned long a, uns GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_ulong_long(unsigned long long a, unsigned long long b) { - if (b > 0 && a > ULLONG_MAX - b) { + if (b > 0 && a > ULLONG_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1068,7 +1068,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ulong_long(unsigned long l GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_size_t(size_t a, size_t b) { - if (b > 0 && a > SIZE_MAX - b) { + if (b > 0 && a > SIZE_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1091,8 +1091,8 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_size_t(size_t a, size_t b) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u8(uint_least8_t a, uint_least8_t b) { a = GUF_UWRAP_8(a); - b = GUF_UWRAP_8(b); - if (b > 0 && a > GUF_UINT8_MAX - b) { + b = GUF_UWRAP_8(b); + if (b > 0 && a > GUF_UINT8_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1101,7 +1101,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u8(uint_least8_t a, GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u8(uint_least8_t a, uint_least8_t b) { a = GUF_UWRAP_8(a); - b = GUF_UWRAP_8(b); + b = GUF_UWRAP_8(b); if (b > a) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { @@ -1111,15 +1111,15 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u8(uint_least8_t a, GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u8(uint_least8_t a, uint_least8_t b) { a = GUF_UWRAP_8(a); - b = GUF_UWRAP_8(b); + b = GUF_UWRAP_8(b); const uint_least8_t c = GUF_UWRAP_8( 1u * a * b ); return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u16(uint_least16_t a, uint_least16_t b) { a = GUF_UWRAP_16(a); - b = GUF_UWRAP_16(b); - if (b > 0 && a > GUF_UINT16_MAX - b) { + b = GUF_UWRAP_16(b); + if (b > 0 && a > GUF_UINT16_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1128,7 +1128,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u16(uint_least16_t a GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u16(uint_least16_t a, uint_least16_t b) { a = GUF_UWRAP_16(a); - b = GUF_UWRAP_16(b); + b = GUF_UWRAP_16(b); if (b > a) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { @@ -1138,15 +1138,15 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u16(uint_least16_t a GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u16(uint_least16_t a, uint_least16_t b) { a = GUF_UWRAP_16(a); - b = GUF_UWRAP_16(b); + b = GUF_UWRAP_16(b); const uint_least16_t c = GUF_UWRAP_16( 1u * a * b ); return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u32(uint_least32_t a, uint_least32_t b) { a = GUF_UWRAP_32(a); - b = GUF_UWRAP_32(b); - if (b > 0 && a > GUF_UINT32_MAX - b) { + b = GUF_UWRAP_32(b); + if (b > 0 && a > GUF_UINT32_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1155,7 +1155,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u32(uint_least32_t a GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u32(uint_least32_t a, uint_least32_t b) { a = GUF_UWRAP_32(a); - b = GUF_UWRAP_32(b); + b = GUF_UWRAP_32(b); if (b > a) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { @@ -1165,15 +1165,15 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u32(uint_least32_t a GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u32(uint_least32_t a, uint_least32_t b) { a = GUF_UWRAP_32(a); - b = GUF_UWRAP_32(b); + b = GUF_UWRAP_32(b); const uint_least32_t c = GUF_UWRAP_32( 1u * a * b ); return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u64(uint_least64_t a, uint_least64_t b) { a = GUF_UWRAP_64(a); - b = GUF_UWRAP_64(b); - if (b > 0 && a > GUF_UINT64_MAX - b) { + b = GUF_UWRAP_64(b); + if (b > 0 && a > GUF_UINT64_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1182,7 +1182,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_least_u64(uint_least64_t a GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u64(uint_least64_t a, uint_least64_t b) { a = GUF_UWRAP_64(a); - b = GUF_UWRAP_64(b); + b = GUF_UWRAP_64(b); if (b > a) { return GUF_MATH_CKD_OVERFLOW_NEG; } else { @@ -1192,14 +1192,14 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_least_u64(uint_least64_t a GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_least_u64(uint_least64_t a, uint_least64_t b) { a = GUF_UWRAP_64(a); - b = GUF_UWRAP_64(b); + b = GUF_UWRAP_64(b); const uint_least64_t c = GUF_UWRAP_64( 1u * a * b ); return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } #ifdef UINT8_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_u8(uint8_t a, uint8_t b) { - if (b > 0 && a > UINT8_MAX - b) { + if (b > 0 && a > UINT8_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1223,7 +1223,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u8(uint8_t a, uint8_t b) #ifdef UINT16_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_u16(uint16_t a, uint16_t b) { - if (b > 0 && a > UINT16_MAX - b) { + if (b > 0 && a > UINT16_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1247,7 +1247,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u16(uint16_t a, uint16_t b #ifdef UINT32_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_u32(uint32_t a, uint32_t b) { - if (b > 0 && a > UINT32_MAX - b) { + if (b > 0 && a > UINT32_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1271,7 +1271,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u32(uint32_t a, uint32_t b #ifdef UINT64_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_u64(uint64_t a, uint64_t b) { - if (b > 0 && a > UINT64_MAX - b) { + if (b > 0 && a > UINT64_MAX - b) { return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; @@ -1297,7 +1297,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_u64(uint64_t a, uint64_t b // Signed saturating/wrapping arithmetic (generated with libguf/tools/ckdint-gen.py) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_int(int a, int b, int *result) { - const guf_math_ckd_result check = guf_ckd_add_int(a, b); + const guf_math_ckd_result check = guf_ckd_add_int(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1317,7 +1317,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_int(int a, int b, i } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_int(int a, int b, int *result) { - const guf_math_ckd_result check = guf_ckd_sub_int(a, b); + const guf_math_ckd_result check = guf_ckd_sub_int(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1337,7 +1337,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_int(int a, int b, i } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_int(int a, int b, int *result) { - const guf_math_ckd_result check = guf_ckd_mul_int(a, b); + const guf_math_ckd_result check = guf_ckd_mul_int(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1358,27 +1358,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_int(int a, int b, i GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_int(int a, int b, int *result) { - const guf_math_ckd_result check = guf_ckd_add_int(a, b); + const guf_math_ckd_result check = guf_ckd_add_int(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + INT_MIN) + (b + INT_MIN); + *result = (int)( (a + (int)INT_MIN) + (b + (int)INT_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - INT_MIN) + (b - INT_MIN); + *result = (int)( (a - (int)INT_MIN) + (b - (int)INT_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_int(int a, int b, int *result) { - const guf_math_ckd_result check = guf_ckd_sub_int(a, b); + const guf_math_ckd_result check = guf_ckd_sub_int(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1386,26 +1386,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_int(int a, int b, int break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + INT_MIN) - (b - INT_MIN); // TODO: not sure + *result = (int)( (a + (int)INT_MIN) - (b - (int)INT_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - INT_MIN) - (b + INT_MIN); // TODO: not sure + *result = (int)( (a - (int)INT_MIN) - (b + (int)INT_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_int(int a, int b, int *result) { - const guf_math_ckd_result check = guf_ckd_mul_int(a, b); + const guf_math_ckd_result check = guf_ckd_mul_int(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { unsigned res = 1u * (unsigned)a * (unsigned)b; @@ -1413,7 +1413,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_int(int a, int b, int const unsigned mod = (unsigned)INT_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = INT_MIN + (int)res; + *result = (int)INT_MIN + (int)res; } else { *result = (int)res; } @@ -1423,12 +1423,12 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_int(int a, int b, int GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_long(long a, long b, long *result) { - const guf_math_ckd_result check = guf_ckd_add_long(a, b); + const guf_math_ckd_result check = guf_ckd_add_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1448,7 +1448,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_long(long a, long b } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_long(long a, long b, long *result) { - const guf_math_ckd_result check = guf_ckd_sub_long(a, b); + const guf_math_ckd_result check = guf_ckd_sub_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1468,7 +1468,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_long(long a, long b } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_long(long a, long b, long *result) { - const guf_math_ckd_result check = guf_ckd_mul_long(a, b); + const guf_math_ckd_result check = guf_ckd_mul_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1489,27 +1489,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_long(long a, long b GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_long(long a, long b, long *result) { - const guf_math_ckd_result check = guf_ckd_add_long(a, b); + const guf_math_ckd_result check = guf_ckd_add_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + LONG_MIN) + (b + LONG_MIN); + *result = (long)( (a + (long)LONG_MIN) + (b + (long)LONG_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - LONG_MIN) + (b - LONG_MIN); + *result = (long)( (a - (long)LONG_MIN) + (b - (long)LONG_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_long(long a, long b, long *result) { - const guf_math_ckd_result check = guf_ckd_sub_long(a, b); + const guf_math_ckd_result check = guf_ckd_sub_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1517,26 +1517,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_long(long a, long b, break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + LONG_MIN) - (b - LONG_MIN); // TODO: not sure + *result = (long)( (a + (long)LONG_MIN) - (b - (long)LONG_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - LONG_MIN) - (b + LONG_MIN); // TODO: not sure + *result = (long)( (a - (long)LONG_MIN) - (b + (long)LONG_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long(long a, long b, long *result) { - const guf_math_ckd_result check = guf_ckd_mul_long(a, b); + const guf_math_ckd_result check = guf_ckd_mul_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { unsigned long res = 1u * (unsigned long)a * (unsigned long)b; @@ -1544,7 +1544,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long(long a, long b, const unsigned long mod = (unsigned long)LONG_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = LONG_MIN + (long)res; + *result = (long)LONG_MIN + (long)res; } else { *result = (long)res; } @@ -1554,12 +1554,12 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long(long a, long b, GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_long_long(long long a, long long b, long long *result) { - const guf_math_ckd_result check = guf_ckd_add_long_long(a, b); + const guf_math_ckd_result check = guf_ckd_add_long_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1579,7 +1579,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_long_long(long long } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_long_long(long long a, long long b, long long *result) { - const guf_math_ckd_result check = guf_ckd_sub_long_long(a, b); + const guf_math_ckd_result check = guf_ckd_sub_long_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1599,7 +1599,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_long_long(long long } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_long_long(long long a, long long b, long long *result) { - const guf_math_ckd_result check = guf_ckd_mul_long_long(a, b); + const guf_math_ckd_result check = guf_ckd_mul_long_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1620,27 +1620,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_long_long(long long GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_long_long(long long a, long long b, long long *result) { - const guf_math_ckd_result check = guf_ckd_add_long_long(a, b); + const guf_math_ckd_result check = guf_ckd_add_long_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + LLONG_MIN) + (b + LLONG_MIN); + *result = (long long)( (a + (long long)LLONG_MIN) + (b + (long long)LLONG_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - LLONG_MIN) + (b - LLONG_MIN); + *result = (long long)( (a - (long long)LLONG_MIN) + (b - (long long)LLONG_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_long_long(long long a, long long b, long long *result) { - const guf_math_ckd_result check = guf_ckd_sub_long_long(a, b); + const guf_math_ckd_result check = guf_ckd_sub_long_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1648,26 +1648,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_long_long(long long a break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + LLONG_MIN) - (b - LLONG_MIN); // TODO: not sure + *result = (long long)( (a + (long long)LLONG_MIN) - (b - (long long)LLONG_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - LLONG_MIN) - (b + LLONG_MIN); // TODO: not sure + *result = (long long)( (a - (long long)LLONG_MIN) - (b + (long long)LLONG_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long_long(long long a, long long b, long long *result) { - const guf_math_ckd_result check = guf_ckd_mul_long_long(a, b); + const guf_math_ckd_result check = guf_ckd_mul_long_long(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { unsigned long long res = 1u * (unsigned long long)a * (unsigned long long)b; @@ -1675,7 +1675,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long_long(long long a const unsigned long long mod = (unsigned long long)LLONG_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = LLONG_MIN + (long long)res; + *result = (long long)LLONG_MIN + (long long)res; } else { *result = (long long)res; } @@ -1685,12 +1685,12 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_long_long(long long a GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result) { - const guf_math_ckd_result check = guf_ckd_add_ptrdiff_t(a, b); + const guf_math_ckd_result check = guf_ckd_add_ptrdiff_t(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1710,7 +1710,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ptrdiff_t(ptrdiff_t } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_ptrdiff_t(a, b); + const guf_math_ckd_result check = guf_ckd_sub_ptrdiff_t(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1730,7 +1730,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ptrdiff_t(ptrdiff_t } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_ptrdiff_t(a, b); + const guf_math_ckd_result check = guf_ckd_mul_ptrdiff_t(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1751,27 +1751,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ptrdiff_t(ptrdiff_t GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result) { - const guf_math_ckd_result check = guf_ckd_add_ptrdiff_t(a, b); + const guf_math_ckd_result check = guf_ckd_add_ptrdiff_t(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + PTRDIFF_MIN) + (b + PTRDIFF_MIN); + *result = (ptrdiff_t)( (a + (ptrdiff_t)PTRDIFF_MIN) + (b + (ptrdiff_t)PTRDIFF_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - PTRDIFF_MIN) + (b - PTRDIFF_MIN); + *result = (ptrdiff_t)( (a - (ptrdiff_t)PTRDIFF_MIN) + (b - (ptrdiff_t)PTRDIFF_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_ptrdiff_t(a, b); + const guf_math_ckd_result check = guf_ckd_sub_ptrdiff_t(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1779,26 +1779,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_ptrdiff_t(ptrdiff_t a break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + PTRDIFF_MIN) - (b - PTRDIFF_MIN); // TODO: not sure + *result = (ptrdiff_t)( (a + (ptrdiff_t)PTRDIFF_MIN) - (b - (ptrdiff_t)PTRDIFF_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - PTRDIFF_MIN) - (b + PTRDIFF_MIN); // TODO: not sure + *result = (ptrdiff_t)( (a - (ptrdiff_t)PTRDIFF_MIN) - (b + (ptrdiff_t)PTRDIFF_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ptrdiff_t(ptrdiff_t a, ptrdiff_t b, ptrdiff_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_ptrdiff_t(a, b); + const guf_math_ckd_result check = guf_ckd_mul_ptrdiff_t(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { size_t res = 1u * (size_t)a * (size_t)b; @@ -1806,7 +1806,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ptrdiff_t(ptrdiff_t a const size_t mod = (size_t)PTRDIFF_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = PTRDIFF_MIN + (ptrdiff_t)res; + *result = (ptrdiff_t)PTRDIFF_MIN + (ptrdiff_t)res; } else { *result = (ptrdiff_t)res; } @@ -1816,12 +1816,12 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ptrdiff_t(ptrdiff_t a GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_i8(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1841,7 +1841,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i8(int_least8 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_i8(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1861,7 +1861,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i8(int_least8 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_i8(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1882,27 +1882,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i8(int_least8 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_i8(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + GUF_INT8_MIN) + (b + GUF_INT8_MIN); + *result = (int_least8_t)( (a + (int_least8_t)GUF_INT8_MIN) + (b + (int_least8_t)GUF_INT8_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - GUF_INT8_MIN) + (b - GUF_INT8_MIN); + *result = (int_least8_t)( (a - (int_least8_t)GUF_INT8_MIN) + (b - (int_least8_t)GUF_INT8_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_i8(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1910,26 +1910,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i8(int_least8_t break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + GUF_INT8_MIN) - (b - GUF_INT8_MIN); // TODO: not sure + *result = (int_least8_t)( (a + (int_least8_t)GUF_INT8_MIN) - (b - (int_least8_t)GUF_INT8_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - GUF_INT8_MIN) - (b + GUF_INT8_MIN); // TODO: not sure + *result = (int_least8_t)( (a - (int_least8_t)GUF_INT8_MIN) - (b + (int_least8_t)GUF_INT8_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i8(int_least8_t a, int_least8_t b, int_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_i8(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { uint_least8_t res = 1u * (uint_least8_t)a * (uint_least8_t)b; @@ -1937,7 +1937,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i8(int_least8_t const uint_least8_t mod = (uint_least8_t)GUF_INT8_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = GUF_INT8_MIN + (int_least8_t)res; + *result = (int_least8_t)GUF_INT8_MIN + (int_least8_t)res; } else { *result = (int_least8_t)res; } @@ -1947,12 +1947,12 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i8(int_least8_t GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_i16(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1972,7 +1972,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i16(int_least } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_i16(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -1992,7 +1992,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i16(int_least } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_i16(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2013,27 +2013,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i16(int_least GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_i16(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + GUF_INT16_MIN) + (b + GUF_INT16_MIN); + *result = (int_least16_t)( (a + (int_least16_t)GUF_INT16_MIN) + (b + (int_least16_t)GUF_INT16_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - GUF_INT16_MIN) + (b - GUF_INT16_MIN); + *result = (int_least16_t)( (a - (int_least16_t)GUF_INT16_MIN) + (b - (int_least16_t)GUF_INT16_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_i16(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2041,26 +2041,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i16(int_least16 break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + GUF_INT16_MIN) - (b - GUF_INT16_MIN); // TODO: not sure + *result = (int_least16_t)( (a + (int_least16_t)GUF_INT16_MIN) - (b - (int_least16_t)GUF_INT16_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - GUF_INT16_MIN) - (b + GUF_INT16_MIN); // TODO: not sure + *result = (int_least16_t)( (a - (int_least16_t)GUF_INT16_MIN) - (b + (int_least16_t)GUF_INT16_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i16(int_least16_t a, int_least16_t b, int_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_i16(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { uint_least16_t res = 1u * (uint_least16_t)a * (uint_least16_t)b; @@ -2068,7 +2068,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i16(int_least16 const uint_least16_t mod = (uint_least16_t)GUF_INT16_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = GUF_INT16_MIN + (int_least16_t)res; + *result = (int_least16_t)GUF_INT16_MIN + (int_least16_t)res; } else { *result = (int_least16_t)res; } @@ -2078,12 +2078,12 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i16(int_least16 GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_i32(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2103,7 +2103,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i32(int_least } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_i32(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2123,7 +2123,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i32(int_least } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_i32(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2144,27 +2144,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i32(int_least GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_i32(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + GUF_INT32_MIN) + (b + GUF_INT32_MIN); + *result = (int_least32_t)( (a + (int_least32_t)GUF_INT32_MIN) + (b + (int_least32_t)GUF_INT32_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - GUF_INT32_MIN) + (b - GUF_INT32_MIN); + *result = (int_least32_t)( (a - (int_least32_t)GUF_INT32_MIN) + (b - (int_least32_t)GUF_INT32_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_i32(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2172,26 +2172,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i32(int_least32 break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + GUF_INT32_MIN) - (b - GUF_INT32_MIN); // TODO: not sure + *result = (int_least32_t)( (a + (int_least32_t)GUF_INT32_MIN) - (b - (int_least32_t)GUF_INT32_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - GUF_INT32_MIN) - (b + GUF_INT32_MIN); // TODO: not sure + *result = (int_least32_t)( (a - (int_least32_t)GUF_INT32_MIN) - (b + (int_least32_t)GUF_INT32_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i32(int_least32_t a, int_least32_t b, int_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_i32(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { uint_least32_t res = 1u * (uint_least32_t)a * (uint_least32_t)b; @@ -2199,7 +2199,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i32(int_least32 const uint_least32_t mod = (uint_least32_t)GUF_INT32_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = GUF_INT32_MIN + (int_least32_t)res; + *result = (int_least32_t)GUF_INT32_MIN + (int_least32_t)res; } else { *result = (int_least32_t)res; } @@ -2209,12 +2209,12 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i32(int_least32 GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_i64(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2234,7 +2234,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_i64(int_least } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_i64(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2254,7 +2254,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_i64(int_least } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_i64(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2275,27 +2275,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_i64(int_least GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_i64(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + GUF_INT64_MIN) + (b + GUF_INT64_MIN); + *result = (int_least64_t)( (a + (int_least64_t)GUF_INT64_MIN) + (b + (int_least64_t)GUF_INT64_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - GUF_INT64_MIN) + (b - GUF_INT64_MIN); + *result = (int_least64_t)( (a - (int_least64_t)GUF_INT64_MIN) + (b - (int_least64_t)GUF_INT64_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_i64(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2303,26 +2303,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_i64(int_least64 break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + GUF_INT64_MIN) - (b - GUF_INT64_MIN); // TODO: not sure + *result = (int_least64_t)( (a + (int_least64_t)GUF_INT64_MIN) - (b - (int_least64_t)GUF_INT64_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - GUF_INT64_MIN) - (b + GUF_INT64_MIN); // TODO: not sure + *result = (int_least64_t)( (a - (int_least64_t)GUF_INT64_MIN) - (b + (int_least64_t)GUF_INT64_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i64(int_least64_t a, int_least64_t b, int_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_i64(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { uint_least64_t res = 1u * (uint_least64_t)a * (uint_least64_t)b; @@ -2330,7 +2330,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i64(int_least64 const uint_least64_t mod = (uint_least64_t)GUF_INT64_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = GUF_INT64_MIN + (int_least64_t)res; + *result = (int_least64_t)GUF_INT64_MIN + (int_least64_t)res; } else { *result = (int_least64_t)res; } @@ -2340,13 +2340,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_i64(int_least64 GUF_ASSERT(false); } } - return check; + return check; } #ifdef INT8_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i8(int8_t a, int8_t b, int8_t *result) { - const guf_math_ckd_result check = guf_ckd_add_i8(a, b); + const guf_math_ckd_result check = guf_ckd_add_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2366,7 +2366,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i8(int8_t a, int8_t } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i8(int8_t a, int8_t b, int8_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_i8(a, b); + const guf_math_ckd_result check = guf_ckd_sub_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2386,7 +2386,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i8(int8_t a, int8_t } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i8(int8_t a, int8_t b, int8_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_i8(a, b); + const guf_math_ckd_result check = guf_ckd_mul_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2407,27 +2407,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i8(int8_t a, int8_t GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i8(int8_t a, int8_t b, int8_t *result) { - const guf_math_ckd_result check = guf_ckd_add_i8(a, b); + const guf_math_ckd_result check = guf_ckd_add_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + INT8_MIN) + (b + INT8_MIN); + *result = (int8_t)( (a + (int8_t)INT8_MIN) + (b + (int8_t)INT8_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - INT8_MIN) + (b - INT8_MIN); + *result = (int8_t)( (a - (int8_t)INT8_MIN) + (b - (int8_t)INT8_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i8(int8_t a, int8_t b, int8_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_i8(a, b); + const guf_math_ckd_result check = guf_ckd_sub_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2435,26 +2435,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i8(int8_t a, int8_t b break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + INT8_MIN) - (b - INT8_MIN); // TODO: not sure + *result = (int8_t)( (a + (int8_t)INT8_MIN) - (b - (int8_t)INT8_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - INT8_MIN) - (b + INT8_MIN); // TODO: not sure + *result = (int8_t)( (a - (int8_t)INT8_MIN) - (b + (int8_t)INT8_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i8(int8_t a, int8_t b, int8_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_i8(a, b); + const guf_math_ckd_result check = guf_ckd_mul_i8(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { uint8_t res = 1u * (uint8_t)a * (uint8_t)b; @@ -2462,7 +2462,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i8(int8_t a, int8_t b const uint8_t mod = (uint8_t)INT8_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = INT8_MIN + (int8_t)res; + *result = (int8_t)INT8_MIN + (int8_t)res; } else { *result = (int8_t)res; } @@ -2472,14 +2472,14 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i8(int8_t a, int8_t b GUF_ASSERT(false); } } - return check; + return check; } #endif #ifdef INT16_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i16(int16_t a, int16_t b, int16_t *result) { - const guf_math_ckd_result check = guf_ckd_add_i16(a, b); + const guf_math_ckd_result check = guf_ckd_add_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2499,7 +2499,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i16(int16_t a, int1 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i16(int16_t a, int16_t b, int16_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_i16(a, b); + const guf_math_ckd_result check = guf_ckd_sub_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2519,7 +2519,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i16(int16_t a, int1 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i16(int16_t a, int16_t b, int16_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_i16(a, b); + const guf_math_ckd_result check = guf_ckd_mul_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2540,27 +2540,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i16(int16_t a, int1 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i16(int16_t a, int16_t b, int16_t *result) { - const guf_math_ckd_result check = guf_ckd_add_i16(a, b); + const guf_math_ckd_result check = guf_ckd_add_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + INT16_MIN) + (b + INT16_MIN); + *result = (int16_t)( (a + (int16_t)INT16_MIN) + (b + (int16_t)INT16_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - INT16_MIN) + (b - INT16_MIN); + *result = (int16_t)( (a - (int16_t)INT16_MIN) + (b - (int16_t)INT16_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i16(int16_t a, int16_t b, int16_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_i16(a, b); + const guf_math_ckd_result check = guf_ckd_sub_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2568,26 +2568,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i16(int16_t a, int16_ break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + INT16_MIN) - (b - INT16_MIN); // TODO: not sure + *result = (int16_t)( (a + (int16_t)INT16_MIN) - (b - (int16_t)INT16_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - INT16_MIN) - (b + INT16_MIN); // TODO: not sure + *result = (int16_t)( (a - (int16_t)INT16_MIN) - (b + (int16_t)INT16_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i16(int16_t a, int16_t b, int16_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_i16(a, b); + const guf_math_ckd_result check = guf_ckd_mul_i16(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { uint16_t res = 1u * (uint16_t)a * (uint16_t)b; @@ -2595,7 +2595,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i16(int16_t a, int16_ const uint16_t mod = (uint16_t)INT16_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = INT16_MIN + (int16_t)res; + *result = (int16_t)INT16_MIN + (int16_t)res; } else { *result = (int16_t)res; } @@ -2605,14 +2605,14 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i16(int16_t a, int16_ GUF_ASSERT(false); } } - return check; + return check; } #endif #ifdef INT32_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i32(int32_t a, int32_t b, int32_t *result) { - const guf_math_ckd_result check = guf_ckd_add_i32(a, b); + const guf_math_ckd_result check = guf_ckd_add_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2632,7 +2632,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i32(int32_t a, int3 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i32(int32_t a, int32_t b, int32_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_i32(a, b); + const guf_math_ckd_result check = guf_ckd_sub_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2652,7 +2652,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i32(int32_t a, int3 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i32(int32_t a, int32_t b, int32_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_i32(a, b); + const guf_math_ckd_result check = guf_ckd_mul_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2673,27 +2673,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i32(int32_t a, int3 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i32(int32_t a, int32_t b, int32_t *result) { - const guf_math_ckd_result check = guf_ckd_add_i32(a, b); + const guf_math_ckd_result check = guf_ckd_add_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + INT32_MIN) + (b + INT32_MIN); + *result = (int32_t)( (a + (int32_t)INT32_MIN) + (b + (int32_t)INT32_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - INT32_MIN) + (b - INT32_MIN); + *result = (int32_t)( (a - (int32_t)INT32_MIN) + (b - (int32_t)INT32_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i32(int32_t a, int32_t b, int32_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_i32(a, b); + const guf_math_ckd_result check = guf_ckd_sub_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2701,26 +2701,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i32(int32_t a, int32_ break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + INT32_MIN) - (b - INT32_MIN); // TODO: not sure + *result = (int32_t)( (a + (int32_t)INT32_MIN) - (b - (int32_t)INT32_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - INT32_MIN) - (b + INT32_MIN); // TODO: not sure + *result = (int32_t)( (a - (int32_t)INT32_MIN) - (b + (int32_t)INT32_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i32(int32_t a, int32_t b, int32_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_i32(a, b); + const guf_math_ckd_result check = guf_ckd_mul_i32(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { uint32_t res = 1u * (uint32_t)a * (uint32_t)b; @@ -2728,7 +2728,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i32(int32_t a, int32_ const uint32_t mod = (uint32_t)INT32_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = INT32_MIN + (int32_t)res; + *result = (int32_t)INT32_MIN + (int32_t)res; } else { *result = (int32_t)res; } @@ -2738,14 +2738,14 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i32(int32_t a, int32_ GUF_ASSERT(false); } } - return check; + return check; } #endif #ifdef INT64_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i64(int64_t a, int64_t b, int64_t *result) { - const guf_math_ckd_result check = guf_ckd_add_i64(a, b); + const guf_math_ckd_result check = guf_ckd_add_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2765,7 +2765,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i64(int64_t a, int6 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i64(int64_t a, int64_t b, int64_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_i64(a, b); + const guf_math_ckd_result check = guf_ckd_sub_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2785,7 +2785,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i64(int64_t a, int6 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i64(int64_t a, int64_t b, int64_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_i64(a, b); + const guf_math_ckd_result check = guf_ckd_mul_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2806,27 +2806,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i64(int64_t a, int6 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i64(int64_t a, int64_t b, int64_t *result) { - const guf_math_ckd_result check = guf_ckd_add_i64(a, b); + const guf_math_ckd_result check = guf_ckd_add_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + INT64_MIN) + (b + INT64_MIN); + *result = (int64_t)( (a + (int64_t)INT64_MIN) + (b + (int64_t)INT64_MIN) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - INT64_MIN) + (b - INT64_MIN); + *result = (int64_t)( (a - (int64_t)INT64_MIN) + (b - (int64_t)INT64_MIN) ); break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i64(int64_t a, int64_t b, int64_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_i64(a, b); + const guf_math_ckd_result check = guf_ckd_sub_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: @@ -2834,26 +2834,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i64(int64_t a, int64_ break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + INT64_MIN) - (b - INT64_MIN); // TODO: not sure + *result = (int64_t)( (a + (int64_t)INT64_MIN) - (b - (int64_t)INT64_MIN) ); // TODO: not sure break; case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); - *result = (a - INT64_MIN) - (b + INT64_MIN); // TODO: not sure + *result = (int64_t)( (a - (int64_t)INT64_MIN) - (b + (int64_t)INT64_MIN) ); // TODO: not sure break; default: GUF_ASSERT(false); } } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i64(int64_t a, int64_t b, int64_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_i64(a, b); + const guf_math_ckd_result check = guf_ckd_mul_i64(a, b); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; - break; + break; case GUF_MATH_CKD_OVERFLOW_POS: case GUF_MATH_CKD_OVERFLOW_NEG: { uint64_t res = 1u * (uint64_t)a * (uint64_t)b; @@ -2861,7 +2861,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i64(int64_t a, int64_ const uint64_t mod = (uint64_t)INT64_MAX + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = INT64_MIN + (int64_t)res; + *result = (int64_t)INT64_MIN + (int64_t)res; } else { *result = (int64_t)res; } @@ -2871,7 +2871,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i64(int64_t a, int64_ GUF_ASSERT(false); } } - return check; + return check; } #endif @@ -2879,7 +2879,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i64(int64_t a, int64_ // Unsigned saturating/wrapping arithmetic (generated with libguf/tools/ckdint-gen.py) GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_uchar(unsigned char a, unsigned char b, unsigned char *result) { - const guf_math_ckd_result check = guf_ckd_add_uchar(a, b); + const guf_math_ckd_result check = guf_ckd_add_uchar(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -2897,7 +2897,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_uchar(unsigned char } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_uchar(unsigned char a, unsigned char b, unsigned char *result) { - const guf_math_ckd_result check = guf_ckd_sub_uchar(a, b); + const guf_math_ckd_result check = guf_ckd_sub_uchar(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -2915,7 +2915,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_uchar(unsigned char } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_uchar(unsigned char a, unsigned char b, unsigned char *result) { - const guf_math_ckd_result check = guf_ckd_mul_uchar(a, b); + const guf_math_ckd_result check = guf_ckd_mul_uchar(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -2934,32 +2934,32 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_uchar(unsigned char GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_uchar(unsigned char a, unsigned char b, unsigned char *result) { - const guf_math_ckd_result check = guf_ckd_add_uchar(a, b); + const guf_math_ckd_result check = guf_ckd_add_uchar(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_uchar(unsigned char a, unsigned char b, unsigned char *result) { - const guf_math_ckd_result check = guf_ckd_sub_uchar(a, b); + const guf_math_ckd_result check = guf_ckd_sub_uchar(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_uchar(unsigned char a, unsigned char b, unsigned char *result) { - const guf_math_ckd_result check = guf_ckd_mul_uchar(a, b); + const guf_math_ckd_result check = guf_ckd_mul_uchar(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_unsigned(unsigned a, unsigned b, unsigned *result) { - const guf_math_ckd_result check = guf_ckd_add_unsigned(a, b); + const guf_math_ckd_result check = guf_ckd_add_unsigned(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -2977,7 +2977,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_unsigned(unsigned a } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_unsigned(unsigned a, unsigned b, unsigned *result) { - const guf_math_ckd_result check = guf_ckd_sub_unsigned(a, b); + const guf_math_ckd_result check = guf_ckd_sub_unsigned(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -2995,7 +2995,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_unsigned(unsigned a } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_unsigned(unsigned a, unsigned b, unsigned *result) { - const guf_math_ckd_result check = guf_ckd_mul_unsigned(a, b); + const guf_math_ckd_result check = guf_ckd_mul_unsigned(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3014,32 +3014,32 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_unsigned(unsigned a GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_unsigned(unsigned a, unsigned b, unsigned *result) { - const guf_math_ckd_result check = guf_ckd_add_unsigned(a, b); + const guf_math_ckd_result check = guf_ckd_add_unsigned(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_unsigned(unsigned a, unsigned b, unsigned *result) { - const guf_math_ckd_result check = guf_ckd_sub_unsigned(a, b); + const guf_math_ckd_result check = guf_ckd_sub_unsigned(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_unsigned(unsigned a, unsigned b, unsigned *result) { - const guf_math_ckd_result check = guf_ckd_mul_unsigned(a, b); + const guf_math_ckd_result check = guf_ckd_mul_unsigned(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ulong(unsigned long a, unsigned long b, unsigned long *result) { - const guf_math_ckd_result check = guf_ckd_add_ulong(a, b); + const guf_math_ckd_result check = guf_ckd_add_ulong(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3057,7 +3057,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ulong(unsigned long } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ulong(unsigned long a, unsigned long b, unsigned long *result) { - const guf_math_ckd_result check = guf_ckd_sub_ulong(a, b); + const guf_math_ckd_result check = guf_ckd_sub_ulong(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3075,7 +3075,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ulong(unsigned long } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ulong(unsigned long a, unsigned long b, unsigned long *result) { - const guf_math_ckd_result check = guf_ckd_mul_ulong(a, b); + const guf_math_ckd_result check = guf_ckd_mul_ulong(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3094,32 +3094,32 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ulong(unsigned long GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_ulong(unsigned long a, unsigned long b, unsigned long *result) { - const guf_math_ckd_result check = guf_ckd_add_ulong(a, b); + const guf_math_ckd_result check = guf_ckd_add_ulong(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_ulong(unsigned long a, unsigned long b, unsigned long *result) { - const guf_math_ckd_result check = guf_ckd_sub_ulong(a, b); + const guf_math_ckd_result check = guf_ckd_sub_ulong(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ulong(unsigned long a, unsigned long b, unsigned long *result) { - const guf_math_ckd_result check = guf_ckd_mul_ulong(a, b); + const guf_math_ckd_result check = guf_ckd_mul_ulong(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result) { - const guf_math_ckd_result check = guf_ckd_add_ulong_long(a, b); + const guf_math_ckd_result check = guf_ckd_add_ulong_long(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3137,7 +3137,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ulong_long(unsigned } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result) { - const guf_math_ckd_result check = guf_ckd_sub_ulong_long(a, b); + const guf_math_ckd_result check = guf_ckd_sub_ulong_long(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3155,7 +3155,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ulong_long(unsigned } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result) { - const guf_math_ckd_result check = guf_ckd_mul_ulong_long(a, b); + const guf_math_ckd_result check = guf_ckd_mul_ulong_long(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3174,32 +3174,32 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ulong_long(unsigned GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result) { - const guf_math_ckd_result check = guf_ckd_add_ulong_long(a, b); + const guf_math_ckd_result check = guf_ckd_add_ulong_long(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result) { - const guf_math_ckd_result check = guf_ckd_sub_ulong_long(a, b); + const guf_math_ckd_result check = guf_ckd_sub_ulong_long(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ulong_long(unsigned long long a, unsigned long long b, unsigned long long *result) { - const guf_math_ckd_result check = guf_ckd_mul_ulong_long(a, b); + const guf_math_ckd_result check = guf_ckd_mul_ulong_long(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_size_t(size_t a, size_t b, size_t *result) { - const guf_math_ckd_result check = guf_ckd_add_size_t(a, b); + const guf_math_ckd_result check = guf_ckd_add_size_t(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3217,7 +3217,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_size_t(size_t a, si } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_size_t(size_t a, size_t b, size_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_size_t(a, b); + const guf_math_ckd_result check = guf_ckd_sub_size_t(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3235,7 +3235,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_size_t(size_t a, si } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_size_t(size_t a, size_t b, size_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_size_t(a, b); + const guf_math_ckd_result check = guf_ckd_mul_size_t(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3254,32 +3254,32 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_size_t(size_t a, si GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_size_t(size_t a, size_t b, size_t *result) { - const guf_math_ckd_result check = guf_ckd_add_size_t(a, b); + const guf_math_ckd_result check = guf_ckd_add_size_t(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_size_t(size_t a, size_t b, size_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_size_t(a, b); + const guf_math_ckd_result check = guf_ckd_sub_size_t(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_size_t(size_t a, size_t b, size_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_size_t(a, b); + const guf_math_ckd_result check = guf_ckd_mul_size_t(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_u8(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_u8(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3297,7 +3297,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u8(uint_least } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_u8(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_u8(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3315,7 +3315,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u8(uint_least } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_u8(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_u8(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3336,9 +3336,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_u8(uint_least8_ { a = GUF_UWRAP_8(a); b = GUF_UWRAP_8(b); - const guf_math_ckd_result check = guf_ckd_add_least_u8(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_u8(a, b); if (result) { - *result = GUF_UWRAP_8( 1u * a + b ); + *result = GUF_UWRAP_8( 1u * a + b ); } return check; } @@ -3346,26 +3346,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_u8(uint_least8_ { a = GUF_UWRAP_8(a); b = GUF_UWRAP_8(b); - const guf_math_ckd_result check = guf_ckd_sub_least_u8(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_u8(a, b); if (result) { *result = GUF_UWRAP_8( 1u * a - b ); } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u8(uint_least8_t a, uint_least8_t b, uint_least8_t *result) { a = GUF_UWRAP_8(a); b = GUF_UWRAP_8(b); - const guf_math_ckd_result check = guf_ckd_mul_least_u8(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_u8(a, b); if (result) { *result = GUF_UWRAP_8( 1u * a * b ); } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_u16(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_u16(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3383,7 +3383,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u16(uint_leas } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_u16(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_u16(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3401,7 +3401,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u16(uint_leas } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_u16(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_u16(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3422,9 +3422,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_u16(uint_least1 { a = GUF_UWRAP_16(a); b = GUF_UWRAP_16(b); - const guf_math_ckd_result check = guf_ckd_add_least_u16(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_u16(a, b); if (result) { - *result = GUF_UWRAP_16( 1u * a + b ); + *result = GUF_UWRAP_16( 1u * a + b ); } return check; } @@ -3432,26 +3432,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_u16(uint_least1 { a = GUF_UWRAP_16(a); b = GUF_UWRAP_16(b); - const guf_math_ckd_result check = guf_ckd_sub_least_u16(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_u16(a, b); if (result) { *result = GUF_UWRAP_16( 1u * a - b ); } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u16(uint_least16_t a, uint_least16_t b, uint_least16_t *result) { a = GUF_UWRAP_16(a); b = GUF_UWRAP_16(b); - const guf_math_ckd_result check = guf_ckd_mul_least_u16(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_u16(a, b); if (result) { *result = GUF_UWRAP_16( 1u * a * b ); } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_u32(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_u32(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3469,7 +3469,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u32(uint_leas } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_u32(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_u32(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3487,7 +3487,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u32(uint_leas } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_u32(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_u32(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3508,9 +3508,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_u32(uint_least3 { a = GUF_UWRAP_32(a); b = GUF_UWRAP_32(b); - const guf_math_ckd_result check = guf_ckd_add_least_u32(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_u32(a, b); if (result) { - *result = GUF_UWRAP_32( 1u * a + b ); + *result = GUF_UWRAP_32( 1u * a + b ); } return check; } @@ -3518,26 +3518,26 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_u32(uint_least3 { a = GUF_UWRAP_32(a); b = GUF_UWRAP_32(b); - const guf_math_ckd_result check = guf_ckd_sub_least_u32(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_u32(a, b); if (result) { *result = GUF_UWRAP_32( 1u * a - b ); } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u32(uint_least32_t a, uint_least32_t b, uint_least32_t *result) { a = GUF_UWRAP_32(a); b = GUF_UWRAP_32(b); - const guf_math_ckd_result check = guf_ckd_mul_least_u32(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_u32(a, b); if (result) { *result = GUF_UWRAP_32( 1u * a * b ); } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_add_least_u64(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_u64(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3555,7 +3555,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_least_u64(uint_leas } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_least_u64(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_u64(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3573,7 +3573,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_least_u64(uint_leas } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_least_u64(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_u64(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3594,9 +3594,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_least_u64(uint_least6 { a = GUF_UWRAP_64(a); b = GUF_UWRAP_64(b); - const guf_math_ckd_result check = guf_ckd_add_least_u64(a, b); + const guf_math_ckd_result check = guf_ckd_add_least_u64(a, b); if (result) { - *result = GUF_UWRAP_64( 1u * a + b ); + *result = GUF_UWRAP_64( 1u * a + b ); } return check; } @@ -3604,27 +3604,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_least_u64(uint_least6 { a = GUF_UWRAP_64(a); b = GUF_UWRAP_64(b); - const guf_math_ckd_result check = guf_ckd_sub_least_u64(a, b); + const guf_math_ckd_result check = guf_ckd_sub_least_u64(a, b); if (result) { *result = GUF_UWRAP_64( 1u * a - b ); } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_least_u64(uint_least64_t a, uint_least64_t b, uint_least64_t *result) { a = GUF_UWRAP_64(a); b = GUF_UWRAP_64(b); - const guf_math_ckd_result check = guf_ckd_mul_least_u64(a, b); + const guf_math_ckd_result check = guf_ckd_mul_least_u64(a, b); if (result) { *result = GUF_UWRAP_64( 1u * a * b ); } - return check; + return check; } #ifdef UINT8_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u8(uint8_t a, uint8_t b, uint8_t *result) { - const guf_math_ckd_result check = guf_ckd_add_u8(a, b); + const guf_math_ckd_result check = guf_ckd_add_u8(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3642,7 +3642,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u8(uint8_t a, uint8 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_u8(uint8_t a, uint8_t b, uint8_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_u8(a, b); + const guf_math_ckd_result check = guf_ckd_sub_u8(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3660,7 +3660,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_u8(uint8_t a, uint8 } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u8(uint8_t a, uint8_t b, uint8_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_u8(a, b); + const guf_math_ckd_result check = guf_ckd_mul_u8(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3679,34 +3679,34 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u8(uint8_t a, uint8 GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_u8(uint8_t a, uint8_t b, uint8_t *result) { - const guf_math_ckd_result check = guf_ckd_add_u8(a, b); + const guf_math_ckd_result check = guf_ckd_add_u8(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_u8(uint8_t a, uint8_t b, uint8_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_u8(a, b); + const guf_math_ckd_result check = guf_ckd_sub_u8(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u8(uint8_t a, uint8_t b, uint8_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_u8(a, b); + const guf_math_ckd_result check = guf_ckd_mul_u8(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } #endif #ifdef UINT16_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u16(uint16_t a, uint16_t b, uint16_t *result) { - const guf_math_ckd_result check = guf_ckd_add_u16(a, b); + const guf_math_ckd_result check = guf_ckd_add_u16(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3724,7 +3724,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u16(uint16_t a, uin } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_u16(uint16_t a, uint16_t b, uint16_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_u16(a, b); + const guf_math_ckd_result check = guf_ckd_sub_u16(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3742,7 +3742,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_u16(uint16_t a, uin } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u16(uint16_t a, uint16_t b, uint16_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_u16(a, b); + const guf_math_ckd_result check = guf_ckd_mul_u16(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3761,34 +3761,34 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u16(uint16_t a, uin GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_u16(uint16_t a, uint16_t b, uint16_t *result) { - const guf_math_ckd_result check = guf_ckd_add_u16(a, b); + const guf_math_ckd_result check = guf_ckd_add_u16(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_u16(uint16_t a, uint16_t b, uint16_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_u16(a, b); + const guf_math_ckd_result check = guf_ckd_sub_u16(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u16(uint16_t a, uint16_t b, uint16_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_u16(a, b); + const guf_math_ckd_result check = guf_ckd_mul_u16(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } #endif #ifdef UINT32_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u32(uint32_t a, uint32_t b, uint32_t *result) { - const guf_math_ckd_result check = guf_ckd_add_u32(a, b); + const guf_math_ckd_result check = guf_ckd_add_u32(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3806,7 +3806,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u32(uint32_t a, uin } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_u32(uint32_t a, uint32_t b, uint32_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_u32(a, b); + const guf_math_ckd_result check = guf_ckd_sub_u32(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3824,7 +3824,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_u32(uint32_t a, uin } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u32(uint32_t a, uint32_t b, uint32_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_u32(a, b); + const guf_math_ckd_result check = guf_ckd_mul_u32(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3843,34 +3843,34 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u32(uint32_t a, uin GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_u32(uint32_t a, uint32_t b, uint32_t *result) { - const guf_math_ckd_result check = guf_ckd_add_u32(a, b); + const guf_math_ckd_result check = guf_ckd_add_u32(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_u32(uint32_t a, uint32_t b, uint32_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_u32(a, b); + const guf_math_ckd_result check = guf_ckd_sub_u32(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u32(uint32_t a, uint32_t b, uint32_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_u32(a, b); + const guf_math_ckd_result check = guf_ckd_mul_u32(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } #endif #ifdef UINT64_MAX GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u64(uint64_t a, uint64_t b, uint64_t *result) { - const guf_math_ckd_result check = guf_ckd_add_u64(a, b); + const guf_math_ckd_result check = guf_ckd_add_u64(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3888,7 +3888,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_u64(uint64_t a, uin } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_u64(uint64_t a, uint64_t b, uint64_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_u64(a, b); + const guf_math_ckd_result check = guf_ckd_sub_u64(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { @@ -3906,7 +3906,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_u64(uint64_t a, uin } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u64(uint64_t a, uint64_t b, uint64_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_u64(a, b); + const guf_math_ckd_result check = guf_ckd_mul_u64(a, b); GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { @@ -3925,27 +3925,27 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_u64(uint64_t a, uin GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_u64(uint64_t a, uint64_t b, uint64_t *result) { - const guf_math_ckd_result check = guf_ckd_add_u64(a, b); + const guf_math_ckd_result check = guf_ckd_add_u64(a, b); if (result) { - *result = 1u * a + b; + *result = 1u * a + b; } return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_u64(uint64_t a, uint64_t b, uint64_t *result) { - const guf_math_ckd_result check = guf_ckd_sub_u64(a, b); + const guf_math_ckd_result check = guf_ckd_sub_u64(a, b); if (result) { *result = 1u * a - b; } - return check; + return check; } GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u64(uint64_t a, uint64_t b, uint64_t *result) { - const guf_math_ckd_result check = guf_ckd_mul_u64(a, b); + const guf_math_ckd_result check = guf_ckd_mul_u64(a, b); if (result) { *result = 1u * a * b; } - return check; + return check; } #endif @@ -3957,3 +3957,4 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u64(uint64_t a, uint6 #undef GUF_MATH_CKDINT_KWRDS #undef GUF_MATH_CKDINT_IMPL #undef GUF_MATH_CKDINT_IMPL_STATIC + diff --git a/libguf/src/guf_rand.h b/libguf/guf_rand.h similarity index 98% rename from libguf/src/guf_rand.h rename to libguf/guf_rand.h index 867a4a4..0d5d4b9 100755 --- a/libguf/src/guf_rand.h +++ b/libguf/guf_rand.h @@ -345,7 +345,7 @@ GUF_RAND_KWRDS uint_least64_t guf_rand32_u64(guf_rand32_state *state) GUF_ASSERT(state->s[0] || state->s[1] || state->s[2] || state->s[3]); const uint_least32_t lower_bits = guf_rand32_u32(state); const uint_least32_t upper_bits = guf_rand32_u32(state); - GUF_ASSERT( lower_bits <= GUF_UINT32_MAX && upper_bits <= GUF_UINT32_MAX ); + //GUF_ASSERT( lower_bits <= GUF_UINT32_MAX && upper_bits <= GUF_UINT32_MAX ); GUF_ASSERT( ( ((uint_least64_t)upper_bits << 32u) | (uint_least64_t)lower_bits ) <= GUF_UINT32_MAX); return ((uint_least64_t)upper_bits << 32u) | (uint_least64_t)lower_bits; // TODO: not sure if that's a good idea... @@ -443,31 +443,31 @@ GUF_RAND_KWRDS void guf_randstate_jump(guf_randstate *state) GUF_RAND_KWRDS double guf_rand64_f64(guf_rand64_state *state) { // cf. https://prng.di.unimi.it/ and https://dotat.at/@/2023-06-23-random-double.html (last-retrieved 2025-02-11) - return (guf_rand64_u64(state) >> 11u) * 0x1.0p-53; // 11 == 64 - 53 (double has a 53-bit mantissa/significand) + return (double)(guf_rand64_u64(state) >> 11u) * 0x1.0p-53; // 11 == 64 - 53 (double has a 53-bit mantissa/significand) } GUF_RAND_KWRDS double guf_rand32_f64(guf_rand32_state *state) { // cf. https://prng.di.unimi.it/ and https://dotat.at/@/2023-06-23-random-double.html (last-retrieved 2025-02-11) - return (guf_rand32_u64(state) >> 11u) * 0x1.0p-53; // 11 == 64 - 53 (double has a 53-bit mantissa/significand) + return (double)(guf_rand32_u64(state) >> 11u) * 0x1.0p-53; // 11 == 64 - 53 (double has a 53-bit mantissa/significand) } // Generate double in the unit interval [0, 1) GUF_RAND_KWRDS double guf_rand_f64(guf_randstate *state) { // cf. https://prng.di.unimi.it/ and https://dotat.at/@/2023-06-23-random-double.html (last-retrieved 2025-02-11) - return (guf_rand_u64(state) >> 11u) * 0x1.0p-53; // 11 == 64 - 53 (double has a 53-bit mantissa/significand) + return (double)(guf_rand_u64(state) >> 11u) * 0x1.0p-53; // 11 == 64 - 53 (double has a 53-bit mantissa/significand) } GUF_RAND_KWRDS float guf_rand64_f32(guf_rand64_state *state) { - return (guf_rand64_u64(state) >> 40u) * 0x1.0p-24f; // 40 == 64 - 24; (float has a 24-bit mantissa/significand) + return (float)(guf_rand64_u64(state) >> 40u) * 0x1.0p-24f; // 40 == 64 - 24; (float has a 24-bit mantissa/significand) } GUF_RAND_KWRDS float guf_rand32_f32(guf_rand32_state *state) { - return (guf_rand32_u32(state) >> 8u) * 0x1.0p-24f; // 8 == 32 - 24; (float has a 24-bit mantissa/significand) + return (float)(guf_rand32_u32(state) >> 8u) * 0x1.0p-24f; // 8 == 32 - 24; (float has a 24-bit mantissa/significand) } // Generate float in the unit interval [0, 1) @@ -684,7 +684,7 @@ GUF_RAND_KWRDS int_least32_t guf_rand32_range_i32(guf_rand32_state *state, int_l const int_least32_t rnd = min + (int_least32_t)step; GUF_ASSERT(rnd >= min && rnd <= max); - GUF_ASSERT(rnd <= GUF_INT32_MAX && rnd >= GUF_INT32_MIN); + //GUF_ASSERT(rnd <= GUF_INT32_MAX && rnd >= GUF_INT32_MIN); return rnd; } diff --git a/libguf/src/guf_sort.h b/libguf/guf_sort.h similarity index 100% rename from libguf/src/guf_sort.h rename to libguf/guf_sort.h diff --git a/libguf/src/guf_str.h b/libguf/guf_str.h similarity index 99% rename from libguf/src/guf_str.h rename to libguf/guf_str.h index 7de9ee0..84ff870 100755 --- a/libguf/src/guf_str.h +++ b/libguf/guf_str.h @@ -77,7 +77,7 @@ typedef struct guf_str_tok_state { #define GUF_CSTR_TO_VIEW_CPP(CSTR) guf_str_view {.str = (CSTR), .len = (ptrdiff_t)strlen(CSTR)} #define GUF_CSTR_LIT_TO_VIEW_CPP(CSTR) guf_str_view {.str = (CSTR), .len = (ptrdiff_t)sizeof(CSTR) - 1} - #define GUF_STR_UNINITIALISED_CPP guf_str{.allocator = NULL, .data.lng.size = 0, .data.lng.capacity = 0, .data.lng.c_str = NULL} + #define GUF_STR_UNINITIALISED_CPP guf_str{{0, 0, NULL}, 0} #endif // 1.) guf_str_view: @@ -1200,7 +1200,7 @@ GUF_STR_KWRDS guf_str *guf_str_append_u64(guf_str *str, uint_least64_t n) { int num_digits = 0; do { GUF_ASSERT(start_idx > 0); - char c = (n % 10) + '0'; + char c = (char)( (n % 10) + '0' ); buf[--start_idx] = c; ++num_digits; } while ((n = n / 10)); diff --git a/libguf/src/guf_str_view_type.h b/libguf/guf_str_view_type.h similarity index 100% rename from libguf/src/guf_str_view_type.h rename to libguf/guf_str_view_type.h diff --git a/libguf/src/guf_utf8.h b/libguf/guf_utf8.h similarity index 98% rename from libguf/src/guf_utf8.h rename to libguf/guf_utf8.h index eb6253b..22f969f 100755 --- a/libguf/src/guf_utf8.h +++ b/libguf/guf_utf8.h @@ -113,15 +113,15 @@ GUF_UTF8_KWRDS bool guf_utf8_encode(guf_utf8_char *result, uint_least32_t cp) first_byte_bits = 7; } else if (cp >= 0x80 && cp <= 0x7FF) { // binary: 110x.xxxx 10xx.xxxx num_bytes = 2; - result->bytes[0] = 0xC0; + result->bytes[0] = (char)0xC0; first_byte_bits = 5; } else if (cp >= 0x800 && cp <= 0xFFFF) { // binary: 1110.xxxx 10xx.xxxx 10xx.xxxx num_bytes = 3; - result->bytes[0] = 0xE0; + result->bytes[0] = (char)0xE0; first_byte_bits = 4; } else if (cp >= 0x10000 && cp <= 0x10FFFF) { // binary: 1111.0xxx 10xx.xxxx 10xx.xxxx 10xx.xxxx num_bytes = 4; - result->bytes[0] = 0xF0; + result->bytes[0] = (char)0xF0; first_byte_bits = 3; } @@ -131,7 +131,7 @@ GUF_UTF8_KWRDS bool guf_utf8_encode(guf_utf8_char *result, uint_least32_t cp) } for (int i = 1; i < num_bytes; ++i) { - result->bytes[i] = 0x80; // binary: 10xx.xxxx + result->bytes[i] = (char)0x80; // binary: 10xx.xxxx } const int tail_byte_bits = 6; @@ -288,7 +288,7 @@ GUF_UTF8_KWRDS bool guf_utf8_char_is_valid(const guf_utf8_char *c) for (int i = 0; i < num_bytes; ++i) { // "The octet values C0, C1, F5 to FF never appear.", cf. https://www.rfc-editor.org/rfc/rfc3629#page-5 - if (bytes[i] == 0xC0 || bytes[i] == 0xC1 || (bytes[i] >= 0xF5 && bytes[i] <= 0xFF)) { + if (bytes[i] == 0xC0 || bytes[i] == 0xC1 || (bytes[i] >= 0xF5)) { return false; } } diff --git a/libguf/src/guf_utils.h b/libguf/guf_utils.h similarity index 100% rename from libguf/src/guf_utils.h rename to libguf/guf_utils.h diff --git a/libguf/src/.DS_Store b/libguf/src/.DS_Store deleted file mode 100755 index 1d9d7f59dccad874574de3a3ecfd4ff3fc9a95b8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHKyH3MU47J+~5iA{9knYBax^%u&;R`A;qf!Jzt5l*?9W%k&AL`1)hwvF3Kd2H# zT^YcZd{3_Jlbf6&j){n;uZuC!h=@wKAic}dH_40lY~Yas$a0V6(|Gn!uhzZF(*fZY zw4q0Op-qQBIBeUwRb5r{Wj#l%+}&NhU4DMtbn}a2{_E^|vOje5>*v<94fmjig#w{K zC=d#S0{>D0^lY*6+%VQqAQT7%jta>4A;AT+V`HeF4lFtX0OdDc4c9tL0FwlO*|9N1 z1ja@M8kK#-V51|Rye>O7hDImWlW`wEnSDZGJst6+<;2-A)=(f6=qfO@?MV9nE&Rm% z-zCK^6bJ?Wlmc8-vucW0^4{8eIq9_teh>dK)M_~vZN)%s#n?zIzG&4Yxkf%aHik+^ RT +#include +#include +#include + +#include "guf_init.h" /* Must be included once (or compiled in a separate .c file and linked) */ + +#define GUF_ALLOC_LIBC_IMPL_STATIC +#include "guf_alloc_libc.h" + +#include "guf_cstr.h" +#include "guf_linalg.h" +#include "guf_utils.h" + +#define GUF_T float +#define GUF_SORT_IMPL_STATIC +#include "guf_sort.h" + +#define GUF_T int +#define GUF_SORT_IMPL_STATIC +#include "guf_sort.h" + +#define GUF_DBUF_NAME dbuf_int +#define GUF_T int +#define GUF_T_IS_INTEGRAL_TYPE +#define GUF_DBUF_IMPL_STATIC +#include "guf_dbuf.h" + +#define GUF_DBUF_NAME dbuf_float +#define GUF_T float +#define GUF_T_IS_INTEGRAL_TYPE +#define GUF_DBUF_IMPL_STATIC +#include "guf_dbuf.h" + +#define GUF_T guf_cstr_heap +#define GUF_DBUF_NAME dbuf_heap_cstr +#define GUF_T_COPY guf_cstr_heap_copy +#define GUF_T_MOVE guf_cstr_heap_move +#define GUF_T_FREE guf_cstr_heap_free +#define GUF_T_EQ guf_cstr_heap_eq +#define GUF_DBUF_IMPL_STATIC +// #define GUF_CNT_WITH_ELEM_CTX +#include "guf_dbuf.h" + +#define GUF_T guf_cstr_const +#define GUF_DBUF_NAME dbuf_const_cstr +#define GUF_T_EQ guf_cstr_const_eq +#define GUF_DBUF_IMPL_STATIC +#include "guf_dbuf.h" + +#define GUF_RAND_IMPL_STATIC +// #define GUF_RAND_32_BIT +#include "guf_rand.h" + +#include "impls/dict_impl.h" + +int main(void) +{ + guf_allocator allocator; + guf_libc_alloc_ctx allocator_ctx; + guf_alloc_tracker_init(&allocator_ctx.tracker, 1, "example_allocator", NULL, NULL); + allocator_ctx.zero_init = false; + guf_libc_allocator_init(&allocator, &allocator_ctx); + + printf("libguf example: " GUF_PLATFORM_STRING "\n"); + guf_platform_assert_endianness(); + guf_platform_assert_native_word_bits(); + + guf_allocator zero_init_allocator; + guf_libc_alloc_ctx zero_init_allocator_ctx; + guf_alloc_tracker_init(&zero_init_allocator_ctx.tracker, 2, "example_zero_init_allocator", stdout, stderr); + zero_init_allocator_ctx.zero_init = true; + guf_libc_allocator_init(&zero_init_allocator, &zero_init_allocator_ctx); + + dict_cstr_int ht; + dict_cstr_int_init(&ht, &zero_init_allocator); + + dict_cstr_int_insert_val_arg(&ht, "Hello", 42, GUF_CPY_VALUE, GUF_CPY_VALUE); + dict_cstr_int_insert_val_arg(&ht, "World", 64, GUF_CPY_VALUE, GUF_CPY_VALUE); + + int kv_iter = 0; + GUF_CNT_FOREACH(&ht, dict_cstr_int, kv_it) { + printf("%d: %s -> %d\n", kv_iter++, kv_it.ptr->key, kv_it.ptr->val); + } + + guf_cstr_const key = "World"; + int *res = dict_cstr_int_at_val_arg(&ht, "World"); + if (res) { + printf("%s: %d\n", key, *res); + } else { + printf("key '%s' not found\n", key); + } + + GUF_ASSERT(dict_cstr_int_at_val_arg(&ht, "World")); + GUF_ASSERT(dict_cstr_int_at_val_arg(&ht, "Hello")); + GUF_ASSERT(dict_cstr_int_at_val_arg(&ht, "hello") == NULL); + GUF_ASSERT(dict_cstr_int_at_val_arg(&ht, "") == NULL); + + GUF_ASSERT(dict_cstr_int_contains_val_arg(&ht, "World")); + GUF_ASSERT(dict_cstr_int_contains_val_arg(&ht, "Hello")); + + const int ht_needle_val = 64; + const dict_cstr_int_iter ht_it = dict_cstr_int_find_val(&ht, dict_cstr_int_begin(&ht), dict_cstr_int_end(&ht), &ht_needle_val); + + if (!dict_cstr_int_iter_is_end(&ht, ht_it)) { + printf("found value %d (key %s)\n", ht_needle_val, ht_it.ptr->key); + } + + dict_cstr_int_free(&ht, NULL); + + + GUF_CNT_LIFETIME_BLOCK(dbuf_float, floats, { + floats = dbuf_float_new(&allocator); + + for (int i = 0; i <= 16; ++i) { + dbuf_float_push_val(&floats, i % 2 ? (float)i * -2.f : (float)i * 2.f); + } + + // float *tmp = test_allocator.alloc(floats.size * sizeof(float), &test_allocator_ctx); + // float *res = float_arr_merge_sort(floats.data, tmp, floats.size, GUF_SORT_ASCENDING, NULL); + // test_allocator.free(tmp, floats.size * sizeof(float), &test_allocator_ctx); + // GUF_ASSERT_RELEASE(res == floats.data); + + float_arr_qsort(floats.data, floats.size, GUF_SORT_ASCENDING, NULL); + GUF_ASSERT_RELEASE(float_arr_is_sorted(floats.data, floats.size, GUF_SORT_ASCENDING, NULL)); + + GUF_CNT_FOREACH(&floats, dbuf_float, it) { + printf("float: %f\n", (double)*it.ptr); + } + }) + + dbuf_heap_cstr strings = dbuf_heap_cstr_new(&allocator); + dbuf_heap_cstr_push_val_cpy(&strings, "Foo 1"); + dbuf_heap_cstr_push_val_cpy(&strings, "Bar 2"); + char *move_me = guf_cstr_dup("Baz 3"); + dbuf_heap_cstr_push(&strings, &move_me, GUF_CPY_MOVE); + GUF_ASSERT_RELEASE(move_me == NULL); + + dbuf_heap_cstr_push_val_cpy(&strings, "Boz 4"); + + char *findme = "Baz 3"; + dbuf_heap_cstr_iter beg = dbuf_heap_cstr_begin(&strings); + dbuf_heap_cstr_iter end = dbuf_heap_cstr_end(&strings); + dbuf_heap_cstr_iter fnd_it = dbuf_heap_cstr_find(&strings, beg, end, &findme); + if (!dbuf_heap_cstr_iter_is_end(&strings, fnd_it)) { + printf("%s found in range [%td, %td) at idx %td\n", findme, dbuf_heap_cstr_iter_to_idx(&strings, beg), dbuf_heap_cstr_iter_to_idx(&strings, end), dbuf_heap_cstr_iter_to_idx(&strings, fnd_it)); + } else { + printf("%s not found in range [%td, %td) at idx %td\n", findme, dbuf_heap_cstr_iter_to_idx(&strings, beg), dbuf_heap_cstr_iter_to_idx(&strings, end), dbuf_heap_cstr_iter_to_idx(&strings, fnd_it)); + } + + if (dbuf_heap_cstr_contains_val(&strings, "Baz 3")) { + printf("contains\n"); + } else { + printf("does not contain\n"); + } + + GUF_CNT_FOREACH(&strings, dbuf_heap_cstr, it) { + printf("%s\n", *it.ptr); + } + dbuf_heap_cstr_free(&strings, NULL); + + dbuf_const_cstr const_strings = dbuf_const_cstr_new(&allocator); + dbuf_const_cstr_push_val(&const_strings, "Const 1"); + dbuf_const_cstr_push_val(&const_strings, "Const 2"); + const char *foo = "Const 3"; + dbuf_const_cstr_push(&const_strings, &foo, GUF_CPY_VALUE); + + dbuf_const_cstr_iter found_it = dbuf_const_cstr_find(&const_strings, dbuf_const_cstr_begin(&const_strings), dbuf_const_cstr_end(&const_strings), &foo); + if (found_it.ptr != dbuf_const_cstr_end(&const_strings).ptr) { + *found_it.ptr = "Found!"; + } + + GUF_CNT_FOREACH(&const_strings, dbuf_const_cstr, it) { + printf("%s\n", *it.ptr); + } + dbuf_const_cstr_free(&const_strings, NULL); + + dbuf_int integers = dbuf_int_new(&allocator); + dbuf_int_push_val(&integers, 420); + dbuf_int_push_val(&integers, 520); + dbuf_int_push_val(&integers, 620); + dbuf_int_push_val(&integers, 720); + dbuf_int_push_val(&integers, 820); + + guf_err err; + dbuf_int_try_at(&integers, 16, &err); + if (err) { + printf("%s %s\n", guf_err_to_str(err), GUF_ERR_MSG_EMPTY()); + } + + int i = 0; + GUF_DBUF_FOREACH(integers, int, elem) { + printf("elem %d: %d\n", i, *elem); + ++i; + } + + GUF_CNT_FOREACH(&integers, dbuf_int, it) { + printf("it-elem: %d", *it.ptr); + if (dbuf_int_iter_next(&integers, it, 1).ptr != dbuf_int_end(&integers).ptr) { + printf(", it-next: %d", *dbuf_int_iter_next(&integers, it, 1).ptr); + } + if (dbuf_int_iter_next(&integers, it, -1).ptr != dbuf_int_end(&integers).ptr) { + printf(", it-prev: %d", *dbuf_int_iter_next(&integers, it, -1).ptr); + } + printf("\n"); + } + + for (dbuf_int_iter it = dbuf_int_begin(&integers); it.ptr != dbuf_int_end(&integers).ptr; it = dbuf_int_iter_next(&integers, it, 2)) { + printf("every other: %d\n", *it.ptr); + } + + for (dbuf_int_iter it = dbuf_int_rbegin(&integers); it.ptr != dbuf_int_rend(&integers).ptr; it = dbuf_int_iter_next(&integers, it, 1)) { + printf("reverse: %d\n", *it.ptr); + } + + for (dbuf_int_iter it = dbuf_int_rbegin(&integers); it.ptr != dbuf_int_rend(&integers).ptr; it = dbuf_int_iter_next(&integers, it, 2)) { + printf("every other reverse: %d (idx %td)\n", *it.ptr, dbuf_int_iter_to_idx(&integers, it)); + } + + dbuf_int_free(&integers, NULL); + printf("\n"); + guf_randstate rng; + guf_randstate_init(&rng, (guf_rand_seed_t)time(NULL)); + int heads = 0, tails = 0; + int throws = 10; + for (i = 0; i < throws; ++i) { + bool is_head = guf_rand_flip(&rng); + if (is_head) { + puts("head"); + ++heads; + } else { + puts("tail"); + ++tails; + } + } + printf("n: %d\nheads: %d\ntails: %d\n", throws, heads, tails); + + int result[256]; + memset(result, 0, sizeof result); + for (int n = 0; n < 32000; ++n) { + float r = roundf(guf_rand_normal_sample_one_f32(&rng, 100, 15)); + r = guf_clamp_f32(r, 0, 255); + result[(int)r] += 1; + } + for (size_t n = 60; n <= 140; ++n) { + printf("%zu:\t", n); + for (int j = 0; j < result[n] / 8; ++j) { + putc('#', stdout); + } + puts(""); + } + + + for (float angle = 0; angle <= 8.f * GUF_PI_F32; angle += 0.001f) { + guf_quaternion rotq = guf_quaternion_from_axis_angle(angle, guf_vec3_normalised((guf_vec3){-2324234.3f, 1.4f, -1.3f})); + guf_mat4x4 rotmat, rotmat_inv; + guf_mat4x4_init_from_quaternion(&rotmat, rotq); + GUF_ASSERT_RELEASE(guf_mat4x4_inverted(&rotmat, &rotmat_inv)) + + guf_mat4x4_set_trans(&rotmat, (guf_vec3){42.1234f, -512.2f, 3.1415926f}); + GUF_ASSERT_RELEASE(guf_mat4x4_inverted(&rotmat, &rotmat_inv)); + + GUF_ASSERT_RELEASE(guf_mat4x4_inverted(&rotmat_inv, &rotmat)); + GUF_ASSERT_RELEASE(guf_mat4x4_inverted(&rotmat, &rotmat_inv)); + } + + guf_quaternion q = guf_quaternion_from_axis_angle(GUF_PI_F32 / 8.f, guf_vec3_normalised((guf_vec3){0.3f, 10.2f, -25.f})); + + guf_mat4x4 mat; + guf_mat4x4_init_from_quaternion(&mat, q); + guf_mat4x4_set_trans(&mat, (guf_vec3){42.1234f, -512.2f, 3.1415926f}); + + mat.data[2][0] *= 100000.4f; + + const guf_mat4x4 mat_cpy = mat; + + printf("Matrix:\n"); + guf_mat4x4_print_with_precision(&mat, stdout, 8); + + guf_mat4x4 mat_inv; + bool invertible = guf_mat4x4_inverted(&mat, &mat_inv); + if (!invertible) { + printf("Not invertible\n"); + } else { + printf("Inverse:\n"); + guf_mat4x4_print_with_precision(&mat_inv, stdout, 8); + GUF_ASSERT_RELEASE(guf_mat4x4_inverted(&mat_inv, &mat)); + GUF_ASSERT_RELEASE(guf_mat4x4_nearly_equal(&mat, &mat_cpy, 1e-4f, 1e-5f)); + } + + mat = (guf_mat4x4) {.data = { + {1, 1.3f, 1, 1}, + {2, 2.6f, 2, 2}, + {0, 0, 2, 4}, + {0, 0, 0, 1} + }}; + printf("Matrix 2:\n"); + guf_mat4x4_print_with_precision(&mat, stdout, 8); + invertible = guf_mat4x4_inverted(&mat, &mat_inv); + if (!invertible) { + printf("Not invertible\n"); + } else { + printf("Inverse:\n"); + guf_mat4x4_print_with_precision(&mat_inv, stdout, 8); + } + + bool leak = false; + if (guf_alloc_tracker_found_leak(&allocator_ctx.tracker)) { + printf("Found memory leak:\n"); + guf_alloc_tracker_print(&allocator_ctx.tracker, stderr); + leak = true; + } + if (guf_alloc_tracker_found_leak(&zero_init_allocator_ctx.tracker)) { + printf("Found memory leak:\n"); + guf_alloc_tracker_print(&zero_init_allocator_ctx.tracker, stderr); + leak = true; + } + + return leak ? EXIT_FAILURE: EXIT_SUCCESS; +} diff --git a/libguf/test/impls/alloc_libc_impl.c b/libguf/test/impls/alloc_libc_impl.c new file mode 100755 index 0000000..813fd0e --- /dev/null +++ b/libguf/test/impls/alloc_libc_impl.c @@ -0,0 +1,2 @@ +#define GUF_ALLOC_LIBC_IMPL +#include "guf_alloc_libc.h" diff --git a/libguf/test/impls/alloc_tracker_impl.c b/libguf/test/impls/alloc_tracker_impl.c new file mode 100755 index 0000000..5f41f5a --- /dev/null +++ b/libguf/test/impls/alloc_tracker_impl.c @@ -0,0 +1,2 @@ +#define GUF_ALLOC_TRACKER_IMPL +#include "guf_alloc_tracker.h" diff --git a/libguf/test/impls/ckdint_impl.c b/libguf/test/impls/ckdint_impl.c new file mode 100755 index 0000000..856029d --- /dev/null +++ b/libguf/test/impls/ckdint_impl.c @@ -0,0 +1,2 @@ +#define GUF_MATH_CKDINT_IMPL +#include "guf_math_ckdint.h" diff --git a/libguf/test/impls/dbuf_impl.c b/libguf/test/impls/dbuf_impl.c new file mode 100755 index 0000000..c0cf1b8 --- /dev/null +++ b/libguf/test/impls/dbuf_impl.c @@ -0,0 +1,55 @@ +#include "dbuf_impl.h" + +#define GUF_DBUF_NAME dbuf_int +#define GUF_T int +#define GUF_T_IS_INTEGRAL_TYPE +#define GUF_DBUF_IMPL +#include "guf_dbuf.h" + +#define GUF_DBUF_NAME dbuf_i32 +#define GUF_T int32_t +#define GUF_T_IS_INTEGRAL_TYPE +#define GUF_DBUF_IMPL +#include "guf_dbuf.h" + +#define GUF_DBUF_NAME dbuf_char +#define GUF_T char +#define GUF_T_IS_INTEGRAL_TYPE +#define GUF_DBUF_IMPL +#include "guf_dbuf.h" + +#define GUF_DBUF_NAME dbuf_float +#define GUF_T float +#define GUF_T_IS_INTEGRAL_TYPE +#define GUF_DBUF_IMPL +#include "guf_dbuf.h" + +#define GUF_T guf_cstr_heap +#define GUF_DBUF_NAME dbuf_heap_cstr +#define GUF_T_COPY guf_cstr_heap_copy +#define GUF_T_MOVE guf_cstr_heap_move +#define GUF_T_FREE guf_cstr_heap_free +#define GUF_T_EQ guf_cstr_heap_eq +#define GUF_DBUF_IMPL +#include "guf_dbuf.h" + +#define GUF_T guf_cstr_const +#define GUF_DBUF_NAME dbuf_const_cstr +#define GUF_T_EQ guf_cstr_const_eq +#define GUF_DBUF_IMPL +#include "guf_dbuf.h" + +#define GUF_T guf_str_view +#define GUF_DBUF_NAME dbuf_str_view +#define GUF_T_EQ guf_str_view_equal +#define GUF_DBUF_IMPL +#include "guf_dbuf.h" + +#define GUF_T guf_str +#define GUF_DBUF_NAME dbuf_str +#define GUF_T_COPY guf_str_copy +#define GUF_T_MOVE guf_str_move +#define GUF_T_FREE guf_str_free +#define GUF_T_EQ guf_str_equal +#define GUF_DBUF_IMPL +#include "guf_dbuf.h" diff --git a/libguf/test/impls/dbuf_impl.h b/libguf/test/impls/dbuf_impl.h new file mode 100755 index 0000000..5c6d04a --- /dev/null +++ b/libguf/test/impls/dbuf_impl.h @@ -0,0 +1,53 @@ +#ifndef GUF_DBUF_IMPL_H +#define GUF_DBUF_IMPL_H + +#include "guf_cstr.h" +#include "guf_str.h" + +#define GUF_DBUF_NAME dbuf_int +#define GUF_T int +#define GUF_T_IS_INTEGRAL_TYPE +#include "guf_dbuf.h" + +#define GUF_DBUF_NAME dbuf_i32 +#define GUF_T int32_t +#define GUF_T_IS_INTEGRAL_TYPE +#include "guf_dbuf.h" + +#define GUF_DBUF_NAME dbuf_char +#define GUF_T char +#define GUF_T_IS_INTEGRAL_TYPE +#include "guf_dbuf.h" + +#define GUF_DBUF_NAME dbuf_float +#define GUF_T float +#define GUF_T_IS_INTEGRAL_TYPE +#include "guf_dbuf.h" + +#define GUF_T guf_cstr_heap +#define GUF_DBUF_NAME dbuf_heap_cstr +#define GUF_T_COPY guf_cstr_heap_copy +#define GUF_T_MOVE guf_cstr_heap_move +#define GUF_T_FREE guf_cstr_heap_free +#define GUF_T_EQ guf_cstr_heap_eq +#include "guf_dbuf.h" + +#define GUF_T guf_cstr_const +#define GUF_DBUF_NAME dbuf_const_cstr +#define GUF_T_EQ guf_cstr_const_eq +#include "guf_dbuf.h" + +#define GUF_T guf_str_view +#define GUF_DBUF_NAME dbuf_str_view +#define GUF_T_EQ guf_str_view_equal +#include "guf_dbuf.h" + +#define GUF_T guf_str +#define GUF_DBUF_NAME dbuf_str +#define GUF_T_COPY guf_str_copy +#define GUF_T_MOVE guf_str_move +#define GUF_T_FREE guf_str_free +#define GUF_T_EQ guf_str_equal +#include "guf_dbuf.h" + +#endif diff --git a/libguf/test/impls/dict_impl.c b/libguf/test/impls/dict_impl.c new file mode 100755 index 0000000..3e773df --- /dev/null +++ b/libguf/test/impls/dict_impl.c @@ -0,0 +1,47 @@ +#include "dict_impl.h" + +#define GUF_DICT_KEY_T guf_cstr_const +#define GUF_DICT_KEY_T_EQ guf_cstr_const_eq +#define GUF_DICT_KEY_HASH guf_cstr_const_hash +#define GUF_DICT_VAL_T int +#define GUF_DICT_VAL_T_IS_INTEGRAL_TYPE +#define GUF_DICT_NAME dict_cstr_int +#define GUF_DICT_IMPL +#include "guf_dict.h" + +#define GUF_DICT_KEY_T guf_str_view +#define GUF_DICT_KEY_HASH guf_str_view_hash +#define GUF_DICT_KEY_T_EQ guf_str_view_equal +#define GUF_DICT_VAL_T int32_t +#define GUF_DICT_VAL_T_IS_INTEGRAL_TYPE +#define GUF_DICT_NAME dict_sv_i32 +#define GUF_DICT_IMPL +// #define GUF_DICT_64_BIT_IDX +// #define GUF_DICT_PROBE_LINEAR +// #define GUF_DICT_32_BIT_HASH +#include "guf_dict.h" + +#define GUF_DICT_KEY_T guf_str +#define GUF_DICT_KEY_HASH guf_str_hash +#define GUF_DICT_KEY_T_EQ guf_str_equal +#define GUF_DICT_KEY_T_CMP guf_str_cmp +#define GUF_DICT_KEY_T_COPY guf_str_copy +#define GUF_DICT_KEY_T_MOVE guf_str_move +#define GUF_DICT_KEY_T_FREE guf_str_free +#define GUF_DICT_VAL_T int32_t +#define GUF_DICT_VAL_T_IS_INTEGRAL_TYPE +#define GUF_DICT_NAME dict_str_i32 +#define GUF_DICT_IMPL +// #define GUF_DICT_64_BIT_IDX +// #define GUF_DICT_PROBE_LINEAR +// #define GUF_DICT_32_BIT_HASH +#include "guf_dict.h" + +#define GUF_DICT_KEY_T int32_t +#define GUF_DICT_KEY_HASH int32_hash +#define GUF_DICT_KEY_T_EQ int32_eq +#define GUF_DICT_VAL_T bool +#define GUF_DICT_VAL_T_IS_INTEGRAL_TYPE +#define GUF_DICT_NAME dict_i32_bool +#define GUF_DICT_IMPL +#include "guf_dict.h" diff --git a/libguf/test/impls/dict_impl.h b/libguf/test/impls/dict_impl.h new file mode 100755 index 0000000..ba4cbad --- /dev/null +++ b/libguf/test/impls/dict_impl.h @@ -0,0 +1,61 @@ +#ifndef GUF_DICT_IMPL_H +#define GUF_DICT_IMPL_H + +#include "guf_common.h" +#include "guf_cstr.h" +#include "guf_str.h" + +#include "guf_hash.h" + +#define GUF_DICT_KEY_T guf_cstr_const +#define GUF_DICT_KEY_HASH guf_cstr_const_hash +#define GUF_DICT_KEY_T_EQ guf_cstr_const_eq +#define GUF_DICT_VAL_T int +#define GUF_DICT_VAL_T_IS_INTEGRAL_TYPE +#define GUF_DICT_NAME dict_cstr_int +#include "guf_dict.h" + +#define GUF_DICT_KEY_T guf_str_view +#define GUF_DICT_KEY_HASH guf_str_view_hash +#define GUF_DICT_KEY_T_EQ guf_str_view_equal +#define GUF_DICT_VAL_T int32_t +#define GUF_DICT_VAL_T_IS_INTEGRAL_TYPE +#define GUF_DICT_NAME dict_sv_i32 +// #define GUF_DICT_64_BIT_IDX +// #define GUF_DICT_PROBE_LINEAR +// #define GUF_DICT_32_BIT_HASH +#include "guf_dict.h" + +#define GUF_DICT_KEY_T guf_str +#define GUF_DICT_KEY_HASH guf_str_hash +#define GUF_DICT_KEY_T_EQ guf_str_equal +#define GUF_DICT_KEY_T_CMP guf_str_cmp +#define GUF_DICT_KEY_T_COPY guf_str_copy +#define GUF_DICT_KEY_T_MOVE guf_str_move +#define GUF_DICT_KEY_T_FREE guf_str_free +#define GUF_DICT_VAL_T int32_t +#define GUF_DICT_VAL_T_IS_INTEGRAL_TYPE +#define GUF_DICT_NAME dict_str_i32 +// #define GUF_DICT_64_BIT_IDX +// #define GUF_DICT_PROBE_LINEAR +// #define GUF_DICT_32_BIT_HASH +#include "guf_dict.h" + +static inline guf_hash_size_t int32_hash(const int32_t *a) +{ + return guf_hash(a, sizeof(int32_t), GUF_HASH_INIT); // TODO: byte order... +} +static inline bool int32_eq(const int32_t *a, const int32_t *b) +{ + return *a == *b; +} + +#define GUF_DICT_KEY_T int32_t +#define GUF_DICT_KEY_HASH int32_hash +#define GUF_DICT_KEY_T_EQ int32_eq +#define GUF_DICT_VAL_T bool +#define GUF_DICT_VAL_T_IS_INTEGRAL_TYPE +#define GUF_DICT_NAME dict_i32_bool +#include "guf_dict.h" + +#endif diff --git a/libguf/test/impls/init_impl.c b/libguf/test/impls/init_impl.c new file mode 100755 index 0000000..7261d21 --- /dev/null +++ b/libguf/test/impls/init_impl.c @@ -0,0 +1 @@ +#include "guf_init.h" diff --git a/libguf/test/impls/linalg_impl.c b/libguf/test/impls/linalg_impl.c new file mode 100755 index 0000000..8debd22 --- /dev/null +++ b/libguf/test/impls/linalg_impl.c @@ -0,0 +1,2 @@ +#define GUF_LINALG_IMPL +#include "guf_linalg.h" diff --git a/libguf/test/impls/rand_impl.c b/libguf/test/impls/rand_impl.c new file mode 100755 index 0000000..5258f3d --- /dev/null +++ b/libguf/test/impls/rand_impl.c @@ -0,0 +1,2 @@ +#define GUF_RAND_IMPL +#include "guf_rand.h" diff --git a/libguf/test/impls/sort_impl.c b/libguf/test/impls/sort_impl.c new file mode 100755 index 0000000..778a00a --- /dev/null +++ b/libguf/test/impls/sort_impl.c @@ -0,0 +1,17 @@ +#include "sort_impl.h" + +#define GUF_T float +#define GUF_SORT_IMPL +#include "guf_sort.h" + +#define GUF_T int32_t +#define GUF_SORT_IMPL +#include "guf_sort.h" + +#define GUF_T int8_t +#define GUF_SORT_IMPL +#include "guf_sort.h" + +#define GUF_T guf_cstr_heap +#define GUF_SORT_IMPL +#include "guf_sort.h" diff --git a/libguf/test/impls/sort_impl.h b/libguf/test/impls/sort_impl.h new file mode 100755 index 0000000..6c4b7c9 --- /dev/null +++ b/libguf/test/impls/sort_impl.h @@ -0,0 +1,18 @@ +#ifndef GUF_SORT_IMPL_H +#define GUF_SORT_IMPL_H + +#include "guf_cstr.h" + +#define GUF_T float +#include "guf_sort.h" + +#define GUF_T int32_t +#include "guf_sort.h" + +#define GUF_T int8_t +#include "guf_sort.h" + +#define GUF_T guf_cstr_heap +#include "guf_sort.h" + +#endif diff --git a/libguf/test/impls/str_impl.c b/libguf/test/impls/str_impl.c new file mode 100755 index 0000000..8114902 --- /dev/null +++ b/libguf/test/impls/str_impl.c @@ -0,0 +1,2 @@ +#define GUF_STR_IMPL +#include "guf_str.h" diff --git a/libguf/test/test.cpp b/libguf/test/test.cpp new file mode 100755 index 0000000..415a8af --- /dev/null +++ b/libguf/test/test.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +#include + +#include "test_dbuf.hpp" +#include "test_dict.hpp" +#include "test_utf8.hpp" +#include "test_str.hpp" +#include "test_ckdint.hpp" + +extern "C" +{ + #include "guf_assert.h" + #include "guf_math.h" +} + +static std::vector> g_tests {}; + +static void init_tests() +{ + g_tests.push_back(std::make_unique("DbufIntTest")); + g_tests.push_back(std::make_unique("DbufCstringTest")); + g_tests.push_back(std::make_unique("DbufStrTest")); + + g_tests.push_back(std::make_unique("DictSvToIntTest")); + g_tests.push_back(std::make_unique("UTF8Test")); + g_tests.push_back(std::make_unique("StrTest")); + g_tests.push_back(std::make_unique("CkdIntTest")); +} + +int main() +{ + init_tests(); + + std::cout << "Running " << g_tests.size() << " tests...\n"; + + // std::cout << "max cap 1:" << dict_sv_i32_max_capacity() << "\n"; + // std::cout << "max cap 2:" << dict_cstr_int_max_capacity() << "\n"; + + size_t num_passed = 0; + for (auto &test : g_tests) { + Test *tst = test.get(); + GUF_ASSERT_RELEASE(tst); + tst->before_run(); + tst->run(); + tst->after_run(); + std::cout << "- " << *tst << "\n"; + if (tst->passed) { + ++num_passed; + } + } + + const bool passed_all = (num_passed == g_tests.size()); + GUF_ASSERT_RELEASE(num_passed <= g_tests.size()); + + if (passed_all) { + std::cout << "-> SUCCESS: Passed all (" << num_passed << "/" << g_tests.size() << ") tests.\n"; + } else { + std::cout << "-> FAILURE: Failed " << (g_tests.size() - num_passed) << "/" << g_tests.size() << " tests.\n"; + } + + return passed_all ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/libguf/test/test.hpp b/libguf/test/test.hpp new file mode 100755 index 0000000..58d65bf --- /dev/null +++ b/libguf/test/test.hpp @@ -0,0 +1,108 @@ +#ifndef GUF_TEST_HPP +#define GUF_TEST_HPP + +#include +#include +#include +#include +#include +#include +extern "C" { + #include "guf_common.h" + #include "guf_assert.h" +} + +#define TEST_CHECK(COND) (check((COND), GUF_STRINGIFY(COND), __LINE__, __FILE__)) + +struct Test +{ +private: + std::chrono::steady_clock::time_point time_start, time_end; + +protected: + std::stack check_name_stack; + std::string full_check_name = ""; + + void push_check_name(const std::string& check_name) + { + check_name_stack.push(check_name); + full_check_name = full_check_name + "::" + check_name; + } + + void pop_check_name() + { + const size_t sep_idx = full_check_name.rfind("::"); + GUF_ASSERT_RELEASE(sep_idx != std::string::npos); + full_check_name = full_check_name.substr(0, sep_idx); + check_name_stack.pop(); + } + + bool check(bool cond, std::string_view msg, size_t line, std::string_view fname) + { + if (!cond) { + std::cerr << name << full_check_name << ": "; + std::cerr << "FAILED CHECK (" << msg << ") on line " << line << " in file " << fname << "\n"; \ + ++num_failed_checks; + } else { + ++num_passed_checks; + } + return cond; + } + +public: + const std::string name {}; + std::chrono::duration runtime_ms {0}; + bool passed {false}, done {false}; + size_t num_failed_checks {0}, num_passed_checks {0}; + + Test(const std::string& nm) : name{nm} {} + virtual ~Test() = default; + + size_t total_checks() const + { + return num_passed_checks + num_failed_checks; + } + + virtual void run() = 0; + + void before_run() + { + time_start = std::chrono::steady_clock::now(); + } + + void after_run() + { + done = true; + passed = (num_failed_checks == 0); + + time_end = std::chrono::steady_clock::now(); + runtime_ms = std::chrono::duration_cast(time_end - time_start); + } + + friend std::ostream& operator<<(std::ostream &os, const Test& tst) + { + std::ios_base::fmtflags os_flags = os.flags(); + std::streamsize os_precision = os.precision(); + + os << tst.name << ": " << (tst.passed ? "PASS" : "FAIL"); + os << std::fixed << std::setprecision(2); + os << " (" << tst.num_passed_checks << "/" << tst.total_checks() << ") in " << tst.runtime_ms.count() << " ms"; + + os.precision(os_precision); + os.flags(os_flags); + return os; + } +}; + +template<> +struct std::hash> { + std::size_t operator()(const std::unique_ptr& test) const + { + if (test.get() == nullptr) { + return 0; + } + return std::hash()(test.get()->name); + } +}; + +#endif diff --git a/libguf/test/test_ckdint.cpp b/libguf/test/test_ckdint.cpp new file mode 100755 index 0000000..84b45b6 --- /dev/null +++ b/libguf/test/test_ckdint.cpp @@ -0,0 +1,361 @@ +#include "test_ckdint.hpp" + +extern "C" +{ + #include "guf_math_ckdint.h" +} + +/* + CkdIntTest: +*/ + +void CkdIntTest::run() +{ + push_check_name("test_ckd"); + test_ckd(); + pop_check_name(); + + push_check_name("test_ckd_uint"); + test_ckd_uint(); + pop_check_name(); +} + +void CkdIntTest::test_ckd() +{ + for (int32_t a = INT8_MIN; a <= INT8_MAX; ++a) { + for (int32_t b = INT8_MIN; b <= INT8_MAX; ++b) { + const int32_t add_res = a + b; + const guf_math_ckd_result ckd_add = guf_ckd_add_i8((int8_t)a, (int8_t)b); + TEST_CHECK(ckd_add == guf_ckd_add_i8((int8_t)b, (int8_t)a)); + TEST_CHECK(ckd_add == guf_ckd_add_least_i8((int_least8_t)a, (int_least8_t)b)); + if (add_res > INT8_MAX) { + TEST_CHECK(ckd_add == GUF_MATH_CKD_OVERFLOW_POS); + int8_t saturated, saturated2; + TEST_CHECK(guf_saturating_add_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(saturated == INT8_MAX); + TEST_CHECK(guf_saturating_add_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(saturated == saturated2); + + int8_t wrapped, wrapped2; + TEST_CHECK(guf_wrapping_add_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(static_cast(wrapped) == INT8_MIN + (add_res % (INT8_MAX + 1))); + TEST_CHECK(guf_wrapping_add_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(wrapped == wrapped2); + } + else if (add_res < INT8_MIN) { + TEST_CHECK(ckd_add == GUF_MATH_CKD_OVERFLOW_NEG); + int8_t saturated, saturated2; + TEST_CHECK(guf_saturating_add_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(saturated == INT8_MIN); + TEST_CHECK(guf_saturating_add_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(saturated == saturated2); + + int8_t wrapped, wrapped2; + TEST_CHECK(guf_wrapping_add_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(static_cast(wrapped) == INT8_MAX - (-add_res % (-INT8_MIN + 1))); + TEST_CHECK(guf_wrapping_add_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(wrapped == wrapped2); + } + else { + TEST_CHECK(ckd_add == GUF_MATH_CKD_SUCCESS); + int8_t saturated, saturated2; + TEST_CHECK(guf_saturating_add_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(saturated) == add_res); + TEST_CHECK(guf_saturating_add_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(saturated == saturated2); + + int8_t wrapped, wrapped2; + TEST_CHECK(guf_wrapping_add_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(wrapped) == add_res); + TEST_CHECK(guf_wrapping_add_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(wrapped == wrapped2); + } + + const int32_t sub_res = a - b; + const guf_math_ckd_result ckd_sub = guf_ckd_sub_i8((int8_t)a, (int8_t)b); + TEST_CHECK(ckd_sub == guf_ckd_sub_least_i8((int_least8_t)a, (int_least8_t)b)); + if (sub_res > INT8_MAX) { + TEST_CHECK(ckd_sub == GUF_MATH_CKD_OVERFLOW_POS); + int8_t saturated; + TEST_CHECK(guf_saturating_sub_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(saturated == INT8_MAX); + int8_t wrapped; + TEST_CHECK(guf_wrapping_sub_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(static_cast(wrapped) == INT8_MIN + (sub_res % (INT8_MAX + 1))); + } else if (sub_res < INT8_MIN) { + TEST_CHECK(ckd_sub == GUF_MATH_CKD_OVERFLOW_NEG); + int8_t saturated; + TEST_CHECK(guf_saturating_sub_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(saturated == INT8_MIN); + int8_t wrapped; + TEST_CHECK(guf_wrapping_sub_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(static_cast(wrapped) == INT8_MAX - (-sub_res % (-INT8_MIN + 1))); + } else { + TEST_CHECK(ckd_sub == GUF_MATH_CKD_SUCCESS); + int8_t saturated; + TEST_CHECK(guf_saturating_sub_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(saturated) == sub_res); + int8_t wrapped; + TEST_CHECK(guf_wrapping_sub_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(wrapped) == sub_res); + } + + const int32_t mul_res = a * b; + const guf_math_ckd_result ckd_mul = guf_ckd_mul_i8((int8_t)a, (int8_t)b); + TEST_CHECK(ckd_mul == guf_ckd_mul_least_i8((int_least8_t)a, (int_least8_t)b)); + TEST_CHECK(ckd_mul == guf_ckd_mul_i8((int8_t)b, (int8_t)a)); + if (mul_res > INT8_MAX) { + TEST_CHECK(ckd_mul == GUF_MATH_CKD_OVERFLOW_POS); + int8_t saturated, saturated2; + TEST_CHECK(guf_saturating_mul_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(saturated == INT8_MAX); + + TEST_CHECK(guf_saturating_mul_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(saturated == saturated2); + + int8_t wrapped, wrapped2; + TEST_CHECK(guf_wrapping_mul_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(guf_wrapping_mul_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(wrapped == wrapped2); + // TODO: check wrapped + } else if (mul_res < INT8_MIN) { + TEST_CHECK(ckd_mul == GUF_MATH_CKD_OVERFLOW_NEG); + int8_t saturated, saturated2; + TEST_CHECK(guf_saturating_mul_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(saturated == INT8_MIN); + + TEST_CHECK(guf_saturating_mul_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(saturated == saturated2); + + int8_t wrapped, wrapped2; + TEST_CHECK(guf_wrapping_mul_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(guf_wrapping_mul_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(wrapped == wrapped2); + // TODO: check wrapped + } else { + TEST_CHECK(ckd_mul == GUF_MATH_CKD_SUCCESS); + int8_t saturated, saturated2; + TEST_CHECK(guf_saturating_mul_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(saturated) == mul_res); + + TEST_CHECK(guf_saturating_mul_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(saturated == saturated2); + + int8_t wrapped, wrapped2; + TEST_CHECK(guf_wrapping_mul_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(wrapped) == mul_res); + TEST_CHECK(guf_wrapping_mul_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(wrapped == wrapped2); + } + } + } + + int8_t mul_i8_res = -1; + TEST_CHECK(guf_wrapping_mul_i8(42, 5, &mul_i8_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i8_res == -46); + mul_i8_res = -1; + TEST_CHECK(guf_wrapping_mul_i8(5, 42, &mul_i8_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i8_res == -46); + + int16_t mul_i16_res = -1245; + TEST_CHECK(guf_wrapping_mul_i16(32767, 2, &mul_i16_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i16_res == -2); + mul_i16_res = -1245; + TEST_CHECK(guf_wrapping_mul_i16(-32767, 2, &mul_i16_res) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(mul_i16_res == 2); + /* + // https://play.rust-lang.org/?version=stable&mode=debug&edition=2024 + + use std::num::Wrapping; + + fn main() { + let a = Wrapping(-314159265_i32); + let b = Wrapping(4096_i32); + println!("{}", a * b); + } + */ + + int32_t mul_i32_res = -12345; + TEST_CHECK(guf_wrapping_mul_i32(INT32_MAX, 2, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i32_res == -2); + mul_i32_res = -12345; + TEST_CHECK(guf_wrapping_mul_i32(2, INT32_MAX, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i32_res == -2); + + mul_i32_res = -12345; + TEST_CHECK(guf_wrapping_mul_i32(INT32_MAX, -2, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(mul_i32_res == 2); + mul_i32_res = -12345; + TEST_CHECK(guf_wrapping_mul_i32(-2, INT32_MAX, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(mul_i32_res == 2); + + TEST_CHECK(guf_wrapping_mul_i32(42002718, 314159265, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i32_res == -972735522); + mul_i32_res = -12345; + TEST_CHECK(guf_wrapping_mul_i32(314159265, 42002718, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i32_res == -972735522); + + mul_i32_res = 12345; + guf_wrapping_mul_i32(42002718, 314159265, &mul_i32_res); + TEST_CHECK(mul_i32_res == -972735522); + + mul_i32_res = 12345; + guf_wrapping_mul_i32(-42002718, 314159265, &mul_i32_res); + TEST_CHECK(mul_i32_res == 972735522); + + mul_i32_res = 12345; + guf_wrapping_mul_i32(-88888888, 99999999, &mul_i32_res); + TEST_CHECK(mul_i32_res == 1374494264); + + mul_i32_res = 12345; + guf_wrapping_mul_i32(INT32_MIN, -1, &mul_i32_res); + TEST_CHECK(mul_i32_res == INT32_MIN); + + mul_i32_res = 12345; + guf_wrapping_mul_i32(-2147483648, 2147483640, &mul_i32_res); + TEST_CHECK(mul_i32_res == 0); + + mul_i32_res = 12345; + guf_wrapping_mul_i32(-2048, -314159265, &mul_i32_res); + TEST_CHECK(mul_i32_res == -846919680); + + mul_i32_res = 12345; + guf_wrapping_mul_i32(4096, -314159265, &mul_i32_res); + TEST_CHECK(mul_i32_res == 1693839360); + + + int_least32_t mul_i32least_res = -12345; + TEST_CHECK(guf_wrapping_mul_least_i32(INT32_MAX, 2, &mul_i32least_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i32least_res == -2); + mul_i32least_res = -12345; + TEST_CHECK(guf_wrapping_mul_least_i32(2, INT32_MAX, &mul_i32least_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i32least_res == -2); + + mul_i32least_res = -12345; + TEST_CHECK(guf_wrapping_mul_least_i32(INT32_MAX, -2, &mul_i32least_res) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(mul_i32least_res == 2); + mul_i32least_res = -12345; + TEST_CHECK(guf_wrapping_mul_least_i32(-2, INT32_MAX, &mul_i32least_res) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(mul_i32least_res == 2); + + TEST_CHECK(guf_wrapping_mul_least_i32(42002718, 314159265, &mul_i32least_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i32least_res == -972735522); + mul_i32least_res = -12345; + TEST_CHECK(guf_wrapping_mul_least_i32(314159265, 42002718, &mul_i32least_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(mul_i32least_res == -972735522); + + mul_i32least_res = 12345; + guf_wrapping_mul_least_i32(42002718, 314159265, &mul_i32least_res); + TEST_CHECK(mul_i32least_res == -972735522); + + mul_i32least_res = 12345; + guf_wrapping_mul_least_i32(-42002718, 314159265, &mul_i32least_res); + TEST_CHECK(mul_i32least_res == 972735522); + + mul_i32least_res = 12345; + guf_wrapping_mul_least_i32(-88888888, 99999999, &mul_i32least_res); + TEST_CHECK(mul_i32least_res == 1374494264); + + mul_i32least_res = 12345; + guf_wrapping_mul_least_i32(INT32_MIN, -1, &mul_i32least_res); + TEST_CHECK(mul_i32least_res == INT32_MIN); + + mul_i32least_res = 12345; + guf_wrapping_mul_least_i32(-2147483648, 2147483640, &mul_i32least_res); + TEST_CHECK(mul_i32least_res == 0); + + mul_i32least_res = 12345; + guf_wrapping_mul_least_i32(-2048, -314159265, &mul_i32least_res); + TEST_CHECK(mul_i32least_res == -846919680); + + mul_i32least_res = 12345; + guf_wrapping_mul_least_i32(4096, -314159265, &mul_i32least_res); + TEST_CHECK(mul_i32least_res == 1693839360); + + + + ptrdiff_t ptrdiff_res = -1234; + TEST_CHECK(guf_saturating_add_ptrdiff_t(PTRDIFF_MAX, 1, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(ptrdiff_res == PTRDIFF_MAX); + ptrdiff_res = -1234; + TEST_CHECK(guf_saturating_add_ptrdiff_t(PTRDIFF_MIN, -1, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(ptrdiff_res == PTRDIFF_MIN); + + ptrdiff_res = -1234; + TEST_CHECK(guf_saturating_mul_ptrdiff_t(PTRDIFF_MAX, 2, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(ptrdiff_res == PTRDIFF_MAX); + ptrdiff_res = -1234; + TEST_CHECK(guf_saturating_mul_ptrdiff_t(PTRDIFF_MIN, 2, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(ptrdiff_res == PTRDIFF_MIN); +} + +void CkdIntTest::test_ckd_uint() +{ + for (int32_t a = 0; a <= UINT8_MAX; ++a) { + for (int32_t b = 0; b <= UINT8_MAX; ++b) { + const int32_t add_res = a + b; + const guf_math_ckd_result ckd_add = guf_ckd_add_u8((uint8_t)a, (uint8_t)b); + GUF_ASSERT(ckd_add == guf_ckd_add_least_u8((uint_least8_t)a, (uint_least8_t)b)); + if (add_res > UINT8_MAX) { + TEST_CHECK(ckd_add == GUF_MATH_CKD_OVERFLOW_POS); + uint8_t saturated; + TEST_CHECK(guf_saturating_add_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(saturated == UINT8_MAX); + uint8_t wrapped; + TEST_CHECK(guf_wrapping_add_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(static_cast(wrapped) == 0 + (add_res % (UINT8_MAX + 1))); + } + else { + TEST_CHECK(ckd_add == GUF_MATH_CKD_SUCCESS); + uint8_t saturated; + TEST_CHECK(guf_saturating_add_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(saturated) == add_res); + uint8_t wrapped; + TEST_CHECK(guf_wrapping_add_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(wrapped) == add_res); + } + + const int32_t sub_res = a - b; + const guf_math_ckd_result ckd_sub = guf_ckd_sub_u8((uint8_t)a, (uint8_t)b); + GUF_ASSERT(ckd_sub == guf_ckd_sub_least_u8((uint_least8_t)a, (uint_least8_t)b)); + if (sub_res < 0) { + TEST_CHECK(ckd_sub == GUF_MATH_CKD_OVERFLOW_NEG); + uint8_t saturated; + TEST_CHECK(guf_saturating_sub_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(saturated == 0); + uint8_t wrapped; + TEST_CHECK(guf_wrapping_sub_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(wrapped == static_cast(static_cast(a) - static_cast(b))); + } else { + TEST_CHECK(ckd_sub == GUF_MATH_CKD_SUCCESS); + uint8_t saturated; + TEST_CHECK(guf_saturating_sub_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(saturated) == sub_res); + uint8_t wrapped; + TEST_CHECK(guf_wrapping_sub_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(wrapped) == sub_res); + } + + const int32_t mul_res = a * b; + const guf_math_ckd_result ckd_mul = guf_ckd_mul_u8((uint8_t)a, (uint8_t)b); + GUF_ASSERT(ckd_mul == guf_ckd_mul_least_u8((uint_least8_t)a, (uint_least8_t)b)); + if (mul_res > UINT8_MAX) { + TEST_CHECK(ckd_mul == GUF_MATH_CKD_OVERFLOW_POS); + uint8_t saturated; + TEST_CHECK(guf_saturating_mul_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(saturated == UINT8_MAX); + uint8_t wrapped; + TEST_CHECK(guf_wrapping_mul_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(wrapped == static_cast(static_cast(a) * static_cast(b))); + } else { + TEST_CHECK(ckd_mul == GUF_MATH_CKD_SUCCESS); + uint8_t saturated; + TEST_CHECK(guf_saturating_mul_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(saturated) == mul_res); + uint8_t wrapped; + TEST_CHECK(guf_wrapping_mul_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_SUCCESS); + TEST_CHECK(static_cast(wrapped) == mul_res); + } + } + } +} diff --git a/libguf/test/test_ckdint.hpp b/libguf/test/test_ckdint.hpp new file mode 100755 index 0000000..986689d --- /dev/null +++ b/libguf/test/test_ckdint.hpp @@ -0,0 +1,12 @@ +#pragma once +#include "test.hpp" + +struct CkdIntTest : public Test +{ + CkdIntTest(const std::string& nm) : Test(nm) {}; + void run() override; + +private: + void test_ckd(); + void test_ckd_uint(); +}; diff --git a/libguf/test/test_dbuf.cpp b/libguf/test/test_dbuf.cpp new file mode 100755 index 0000000..9ac1870 --- /dev/null +++ b/libguf/test/test_dbuf.cpp @@ -0,0 +1,685 @@ +#include "test_dbuf.hpp" + +extern "C" +{ + #include "guf_alloc_libc.h" + #include "impls/dbuf_impl.h" +} + +/* + DbufIntTest +*/ + +void DbufIntTest::run() +{ + if (done) { + return; + } + + // allocator_ctx.tracker.log = fopen("alloc_log.txt", "w"); + // allocator_ctx.tracker.err_log = fopen("alloc_err_log.txt", "w"); + + dbuf_int dbuf {}; + dbuf_int_init(&dbuf, 0, &allocator); + + push_check_name("test_push"); + + test_push(&dbuf, 256); + test_push(&dbuf, 128); + test_push(&dbuf, 17); + TEST_CHECK(dbuf.size == (256 + 128 + 17)); + + dbuf_int_free(&dbuf, NULL); + TEST_CHECK(dbuf.size == 0 && dbuf.capacity == 0 && dbuf.data == NULL); + + dbuf_int_init(&dbuf, 24, &allocator); + TEST_CHECK(dbuf.size == 0 && dbuf.capacity == 24 && dbuf.data); + + test_push(&dbuf, 365); + test_push(&dbuf, 4); + test_push(&dbuf, 25); + test_push(&dbuf, 64); + TEST_CHECK(dbuf.size == (365 + 4 + 25 + 64)); + + dbuf_int_free(&dbuf, NULL); + TEST_CHECK(dbuf.size == 0 && dbuf.capacity == 0 && dbuf.data == NULL); + + pop_check_name(); + + push_check_name("insert_remove"); + + for (int n = 0; n <= 128; ++n) { + test_insert_remove(n); + } + test_insert_remove(400); + test_insert_remove(401); + test_insert_remove(512); + test_insert_remove(513); + test_insert_remove(601); + test_insert_remove(2048); + test_insert_remove(2049); + + pop_check_name(); + + TEST_CHECK(!guf_alloc_tracker_found_leak(&allocator_ctx.tracker)); + // guf_alloc_tracker_print(&allocator_ctx.tracker, stdout); + // puts(""); + // fclose(allocator_ctx.tracker.log); + // fclose(allocator_ctx.tracker.err_log); +} + +std::vector DbufIntTest::dbuf_to_vec(dbuf_int *dbuf) +{ + std::vector vec; + GUF_CNT_FOREACH(dbuf, dbuf_int, it) { + vec.push_back(*it.ptr); + } + return vec; +} + +void DbufIntTest::test_push(dbuf_int *dbuf, int n) +{ + std::vector vec = dbuf_to_vec(dbuf); + + TEST_CHECK(std::ssize(vec) == dbuf->size); + + for (int i = 0; i < n; ++i) { + dbuf_int_push_val(dbuf, i); + vec.push_back(i); + TEST_CHECK(*dbuf_int_back(dbuf) == vec.back()); + } + + ptrdiff_t i = 0; + GUF_CNT_FOREACH(dbuf, dbuf_int, it) { + TEST_CHECK(*it.ptr == vec.at(i++)); + } + TEST_CHECK(i == dbuf->size); + + i = dbuf->size - 1; + GUF_CNT_FOREACH_REVERSE(dbuf, dbuf_int, rit) { + TEST_CHECK(*rit.ptr == vec.at(i--)); + } + TEST_CHECK(i == -1); + +} + +void DbufIntTest::test_insert_remove(int n) +{ + dbuf_int dbuf = {}; + dbuf_int_init(&dbuf, 0, &allocator); + std::vector vec = dbuf_to_vec(&dbuf); + + guf_err err = GUF_ERR_NONE; + dbuf_int_try_erase(&dbuf, 0, &err); + TEST_CHECK(err == GUF_ERR_IDX_RANGE); + + err = GUF_ERR_NONE; + dbuf_int_try_erase(&dbuf, 12, &err); + TEST_CHECK(err == GUF_ERR_IDX_RANGE); + + err = GUF_ERR_NONE; + dbuf_int_try_front(&dbuf, &err); + TEST_CHECK(err == GUF_ERR_IDX_RANGE); + + err = GUF_ERR_NONE; + dbuf_int_try_back(&dbuf, &err); + TEST_CHECK(err == GUF_ERR_IDX_RANGE); + + err = GUF_ERR_NONE; + dbuf_int_try_at(&dbuf, 0, &err); + TEST_CHECK(err == GUF_ERR_IDX_RANGE); + + for (int i = 0; i < n; ++i) { + dbuf_int_insert_val(&dbuf, i, i); + dbuf_int_insert_val(&dbuf, i * 2, 0); + dbuf_int_insert_val(&dbuf, i * 4, dbuf.size); + + vec.insert(vec.begin() + i, i); + vec.insert(vec.begin(), i * 2); + vec.insert(vec.end(), i * 4); + } + TEST_CHECK(std::ssize(vec) == dbuf.size); + + // Iterate + dbuf_int_iter it_dbuf = dbuf_int_begin(&dbuf); + std::vector::const_iterator it_vec = vec.begin(); + while (!dbuf_int_iter_is_end(&dbuf, it_dbuf) && it_vec != vec.end()) { + TEST_CHECK(*it_dbuf.ptr == *it_vec); + it_dbuf = dbuf_int_iter_next(&dbuf, it_dbuf, 1); + std::advance(it_vec, 1); + } + TEST_CHECK(dbuf_int_iter_is_end(&dbuf, it_dbuf) && it_vec == vec.end()); + + // Step iterate. + it_dbuf = dbuf_int_begin(&dbuf); + it_vec = vec.begin(); + while (!dbuf_int_iter_is_end(&dbuf, it_dbuf) && it_vec != vec.end()) { + TEST_CHECK(*it_dbuf.ptr == *it_vec); + it_dbuf = dbuf_int_iter_next(&dbuf, it_dbuf, 7); + + if (dbuf_int_iter_is_end(&dbuf, it_dbuf)) { + it_vec = vec.end(); + } else { + std::advance(it_vec, 7); + } + } + TEST_CHECK(dbuf_int_iter_is_end(&dbuf, it_dbuf) && it_vec == vec.end()); + + // Reverse iterate. + dbuf_int_iter rit_dbuf = dbuf_int_rbegin(&dbuf); + std::vector::const_reverse_iterator rit_vec = vec.crbegin(); + while (!dbuf_int_iter_is_end(&dbuf, rit_dbuf) && rit_vec != vec.crend()) { + TEST_CHECK(*rit_dbuf.ptr == *rit_vec); + rit_dbuf = dbuf_int_iter_next(&dbuf, rit_dbuf, 1); + std::advance(rit_vec, 1); + } + TEST_CHECK(dbuf_int_iter_is_end(&dbuf, rit_dbuf) && rit_vec == vec.rend()); + + // Reverse iterate step. + rit_dbuf = dbuf_int_rbegin(&dbuf); + rit_vec = vec.crbegin(); + while (!dbuf_int_iter_is_end(&dbuf, rit_dbuf) && rit_vec != vec.crend()) { + TEST_CHECK(*rit_dbuf.ptr == *rit_vec); + rit_dbuf = dbuf_int_iter_next(&dbuf, rit_dbuf, 4); + if (dbuf_int_iter_is_end(&dbuf, rit_dbuf)) { + rit_vec = vec.rend(); + } else { + std::advance(rit_vec, 4); + } + } + TEST_CHECK(dbuf_int_iter_is_end(&dbuf, rit_dbuf) && rit_vec == vec.rend()); + + TEST_CHECK(dbuf.size == std::ssize(vec)); + + for (ptrdiff_t i = 0; i < dbuf.size; i += 8) { + dbuf_int_erase(&dbuf, i); + dbuf_int_erase(&dbuf, 0); + dbuf_int_pop(&dbuf); + + vec.erase(vec.begin() + i); + vec.erase(vec.begin() + 0); + vec.pop_back(); + } + + TEST_CHECK(dbuf.size == std::ssize(vec)); + + for (ptrdiff_t i = 0; i < dbuf.size; i += 8) { + TEST_CHECK(*dbuf_int_at(&dbuf, i) == vec.at(i)); + } + + const ptrdiff_t size = dbuf.size; + for (ptrdiff_t i = 0; i < size; ++i) { + int a = dbuf_int_pop_move(&dbuf); + int b = vec.back(); + TEST_CHECK(a == b); + vec.pop_back(); + } + TEST_CHECK(dbuf.size == 0 && vec.size() == 0); + + dbuf_int_free(&dbuf, NULL); + TEST_CHECK(dbuf.size == 0 && dbuf.capacity == 0 && !dbuf.data); +} + + + + +/* + DbufCstringTest +*/ + +void DbufCstringTest::run() +{ + if (done) { + return; + } + + // allocator_ctx.tracker.log = fopen("alloc_log.txt", "w"); + // allocator_ctx.tracker.err_log = fopen("alloc_err_log.txt", "w"); + + push_check_name("push_insert_erase"); + + for (int i = 1; i <= 32; ++i) { + test_push_insert_erase(i); + test_push_insert_erase(i, i - 1); + test_push_insert_erase(i, i + 1); + test_push_insert_erase(i, i); + test_push_insert_erase(i, i / 2); + } + test_push_insert_erase(2048); + test_push_insert_erase(2048, 11); + + dbuf_heap_cstr str_dbuf = {}; + dbuf_heap_cstr_init(&str_dbuf, 0, &allocator); + std::vector str_vec {}; + + for (int i = 0; i < 512; ++i) { + char buf[128]; + memset(buf, '\0', GUF_ARR_SIZE(buf)); + snprintf(buf, GUF_ARR_SIZE(buf), "This is a pretty guf string (number %d)", i); + guf_cstr_heap str = buf; + dbuf_heap_cstr_push(&str_dbuf, &str, GUF_CPY_DEEP); + str_vec.push_back(std::string{buf}); + } + for (int i = 0; i < str_dbuf.size + 16; ++i) { + test_iter(str_vec, &str_dbuf, i); + } + + dbuf_heap_cstr_free(&str_dbuf, NULL); + TEST_CHECK(str_dbuf.size == 0 && str_dbuf.capacity == 0 && !str_dbuf.data); + + pop_check_name(); + + push_check_name("find"); + test_find(); + test_find(3); + test_find(42); + test_find(129); + pop_check_name(); + + TEST_CHECK(!guf_alloc_tracker_found_leak(&allocator_ctx.tracker)); + // guf_alloc_tracker_print(&allocator_ctx.tracker, stdout); + // puts(""); + // fclose(allocator_ctx.tracker.log); + // fclose(allocator_ctx.tracker.err_log); +} + +void DbufCstringTest::test_iter(std::vector& str_vec, dbuf_heap_cstr *str_dbuf, int step) +{ + GUF_ASSERT_RELEASE(str_dbuf); + if (step <= 0) { + step = 1; + } + + ptrdiff_t i = 0; + GUF_CNT_FOREACH(str_dbuf, dbuf_heap_cstr, it) { + char *str = *it.ptr; + TEST_CHECK(str_vec.at(i) == str); + ++i; + } + TEST_CHECK(i == str_dbuf->size); + + i = str_dbuf->size - 1; + GUF_CNT_FOREACH_REVERSE(str_dbuf, dbuf_heap_cstr, rit) { + char *str = *rit.ptr; + TEST_CHECK(str_vec.at(i) == str); + --i; + } + TEST_CHECK(i == -1); + + dbuf_heap_cstr_iter it_dbuf = dbuf_heap_cstr_begin(str_dbuf); + std::vector::iterator it_vec = str_vec.begin(); + while (!dbuf_heap_cstr_iter_is_end(str_dbuf, it_dbuf)) { + TEST_CHECK(it_vec != str_vec.end()); + TEST_CHECK(*it_vec == *it_dbuf.ptr); + it_dbuf = dbuf_heap_cstr_iter_next(str_dbuf, it_dbuf, step); + if (!dbuf_heap_cstr_iter_is_end(str_dbuf, it_dbuf)) { + std::advance(it_vec, step); + } else { + it_vec = str_vec.end(); + } + } + TEST_CHECK(dbuf_heap_cstr_iter_is_end(str_dbuf, it_dbuf) && it_vec == str_vec.end()); + + dbuf_heap_cstr_iter rit_dbuf = dbuf_heap_cstr_rbegin(str_dbuf); + std::vector::reverse_iterator rit_vec = str_vec.rbegin(); + while (!dbuf_heap_cstr_iter_is_end(str_dbuf, rit_dbuf)) { + TEST_CHECK(rit_vec != str_vec.rend()); + TEST_CHECK(*rit_vec == *rit_dbuf.ptr); + rit_dbuf = dbuf_heap_cstr_iter_next(str_dbuf, rit_dbuf, step); + if (!dbuf_heap_cstr_iter_is_end(str_dbuf, rit_dbuf)) { + std::advance(rit_vec, step); + } else { + rit_vec = str_vec.rend(); + } + } + TEST_CHECK(dbuf_heap_cstr_iter_is_end(str_dbuf, rit_dbuf) && rit_vec == str_vec.rend()); + + for (i = 0; i < str_dbuf->size; ++i) { + char *str = *dbuf_heap_cstr_at(str_dbuf, i); + TEST_CHECK(str_vec.at(i) == str); + } +} + +void DbufCstringTest::test_push_insert_erase(int n, ptrdiff_t start_cap) +{ + std::vector str_vec; + dbuf_heap_cstr str_dbuf {}; + dbuf_heap_cstr_init(&str_dbuf, start_cap, &allocator); + + for (int i = 0; i < n; ++i) { + constexpr int BUF_SZ = 128; + char buf[BUF_SZ]; + memset(buf, '\0', BUF_SZ); + snprintf(buf, BUF_SZ, "This is string number %d", i); + guf_cstr_heap str = buf; + + dbuf_heap_cstr_push(&str_dbuf, &str, GUF_CPY_DEEP); + dbuf_heap_cstr_push_val_cpy(&str_dbuf, str); + char *heap_buf = strdup("Move me plz"); + dbuf_heap_cstr_push(&str_dbuf, &heap_buf, GUF_CPY_MOVE); + TEST_CHECK(heap_buf == NULL); + + TEST_CHECK(strncmp(*dbuf_heap_cstr_back(&str_dbuf), "Move me plz", BUF_SZ) == 0); + TEST_CHECK(strncmp(*dbuf_heap_cstr_at(&str_dbuf, str_dbuf.size - 2), buf, BUF_SZ) == 0); + TEST_CHECK(strncmp(*dbuf_heap_cstr_at(&str_dbuf, str_dbuf.size - 3), buf, BUF_SZ) == 0); + + str_vec.push_back(std::string{buf}); + str_vec.push_back(std::string{buf}); + str_vec.emplace_back("Move me plz"); + } + + TEST_CHECK(str_dbuf.size == std::ssize(str_vec)); + TEST_CHECK(str_dbuf.size == 3 * n); + + for (int i = 1; i <= 8; ++i) { + test_iter(str_vec, &str_dbuf, i); + } + test_iter(str_vec, &str_dbuf, (int)str_dbuf.size); + test_iter(str_vec, &str_dbuf, (int)str_dbuf.size - 1); + test_iter(str_vec, &str_dbuf, (int)str_dbuf.size + 1); + + for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) { + TEST_CHECK(str_vec.at(i) == *dbuf_heap_cstr_at(&str_dbuf, i)); + } + + // Insert front. + for (ptrdiff_t i = 0; i < 16; ++i) { + char str[] = "front"; + dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, 0); + str_vec.insert(str_vec.begin(), std::string{str}); + } + TEST_CHECK(std::ssize(str_vec) == str_dbuf.size); + for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) { + TEST_CHECK(str_vec.at(i) == *dbuf_heap_cstr_at(&str_dbuf, i)); + } + // Insert back. + for (ptrdiff_t i = 0; i < 16; ++i) { + char str[] = "front"; + dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, str_dbuf.size); + str_vec.insert(str_vec.end(), std::string{str}); + } + TEST_CHECK(std::ssize(str_vec) == str_dbuf.size); + for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) { + TEST_CHECK(str_vec.at(i) == *dbuf_heap_cstr_at(&str_dbuf, i)); + } + + // Insert at i. + char str[] = "guf"; + dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, str_dbuf.size / 2); + str_vec.insert(str_vec.begin() + str_vec.size() / 2, str); + dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, str_dbuf.size / 4); + str_vec.insert(str_vec.begin() + str_vec.size() / 4, str); + dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, 1); + str_vec.insert(str_vec.begin() + 1, str); + dbuf_heap_cstr_insert_val_cpy(&str_dbuf, str, str_dbuf.size - 1); + str_vec.insert(str_vec.begin() + (str_vec.size() - 1), str); + + for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) { + TEST_CHECK(str_vec.at(i) == *dbuf_heap_cstr_at(&str_dbuf, i)); + } + + guf_err err = GUF_ERR_NONE; + dbuf_heap_cstr_try_insert_val_cpy(&str_dbuf, str, str_dbuf.size + 1, &err); + TEST_CHECK(err == GUF_ERR_IDX_RANGE); + + err = GUF_ERR_NONE; + dbuf_heap_cstr_try_insert_val_cpy(&str_dbuf, str, -1, &err); + TEST_CHECK(err == GUF_ERR_IDX_RANGE); + + err = GUF_ERR_NONE; + dbuf_heap_cstr_try_insert_val_cpy(&str_dbuf, str, str_dbuf.size + 2, &err); + TEST_CHECK(err == GUF_ERR_IDX_RANGE); + + TEST_CHECK(std::ssize(str_vec) == str_dbuf.size); + for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) { + TEST_CHECK(str_vec.at(i) == *dbuf_heap_cstr_at(&str_dbuf, i)); + } + + if (str_dbuf.size) { + dbuf_heap_cstr_erase(&str_dbuf, str_dbuf.size - 1); + str_vec.erase(str_vec.end() - 1); + } + + ptrdiff_t to_rem = 8; + while (str_dbuf.size && to_rem--) { + dbuf_heap_cstr_erase(&str_dbuf, 0); + str_vec.erase(str_vec.begin()); + TEST_CHECK(std::ssize(str_vec) == str_dbuf.size); + if (str_dbuf.size) { + dbuf_heap_cstr_pop(&str_dbuf); + str_vec.pop_back(); + TEST_CHECK(std::ssize(str_vec) == str_dbuf.size); + } + if (str_dbuf.size) { + dbuf_heap_cstr_erase(&str_dbuf, str_dbuf.size / 2); + str_vec.erase(str_vec.begin() + (str_vec.size() / 2)); + TEST_CHECK(std::ssize(str_vec) == str_dbuf.size); + } + } + + dbuf_heap_cstr_free(&str_dbuf, NULL); + TEST_CHECK(str_dbuf.size == 0 && str_dbuf.capacity == 0 && !str_dbuf.data); +} + +void DbufCstringTest::test_find(int n) +{ + if (n < 2) { + n = 2; + } + std::vector str_vec {}; + + dbuf_heap_cstr str_dbuf = {}; + dbuf_heap_cstr_init(&str_dbuf, 0, &allocator); + + for (int i = 0; i < n; ++i) { + constexpr int BUF_SZ = 128; + char buf[BUF_SZ]; + memset(buf, '\0', BUF_SZ); + snprintf(buf, BUF_SZ, "String number %d", i); + + dbuf_heap_cstr_push_val_cpy(&str_dbuf, buf); + str_vec.push_back(buf); + } + char *move_me = strdup("Moved string"); + dbuf_heap_cstr_push(&str_dbuf, &move_me, GUF_CPY_MOVE); + GUF_ASSERT_RELEASE(move_me == NULL); + str_vec.emplace_back("Moved string"); + + TEST_CHECK(std::ssize(str_vec) == str_dbuf.size); + + for (ptrdiff_t i = 0; i < str_dbuf.size; ++i) { + char *needle = *dbuf_heap_cstr_at(&str_dbuf, i); + TEST_CHECK(str_vec.at(i) == needle); + + TEST_CHECK(dbuf_heap_cstr_contains_val(&str_dbuf, needle)); + + dbuf_heap_cstr_iter fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), dbuf_heap_cstr_end(&str_dbuf), needle); + TEST_CHECK(!dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.cbegin(), str_vec.cend(), needle) != str_vec.end()); + + dbuf_heap_cstr_iter begin = dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), i); + dbuf_heap_cstr_iter end = dbuf_heap_cstr_end(&str_dbuf); + fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, begin, end, needle); + TEST_CHECK(!dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.cbegin() + i, str_vec.cend(), needle) != str_vec.end()); + + begin = dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), i + 1); + end = dbuf_heap_cstr_end(&str_dbuf); + fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, begin, end, needle); + TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.cbegin() + i + 1, str_vec.cend(), needle) == str_vec.end()); + + // Reverse. + fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_rbegin(&str_dbuf), dbuf_heap_cstr_rend(&str_dbuf), needle); + TEST_CHECK(!dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.crbegin(), str_vec.crend(), needle) != str_vec.rend()); + } + + char needle[] = "Definitely not inside"; + dbuf_heap_cstr_iter fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), dbuf_heap_cstr_end(&str_dbuf), needle); + TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.cbegin(), str_vec.cend(), needle) == str_vec.end()); + + fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_rbegin(&str_dbuf), dbuf_heap_cstr_rend(&str_dbuf), needle); + TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.crbegin(), str_vec.crend(), needle) == str_vec.rend()); + + char *needle2 = *dbuf_heap_cstr_at(&str_dbuf, 0); + fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), 1), dbuf_heap_cstr_end(&str_dbuf), needle2); + TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.cbegin() + 1, str_vec.cend(), needle2) == str_vec.end()); + + needle2 = *dbuf_heap_cstr_back(&str_dbuf); + fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), 1), dbuf_heap_cstr_iter_next(&str_dbuf, dbuf_heap_cstr_end(&str_dbuf), -1), needle2); + TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.begin(), str_vec.end() - 1, needle2) == (str_vec.end() - 1)); + + needle2 = *dbuf_heap_cstr_at(&str_dbuf, 0); + fnd_it = dbuf_heap_cstr_find_val(&str_dbuf, dbuf_heap_cstr_begin(&str_dbuf), dbuf_heap_cstr_begin(&str_dbuf), needle2); + TEST_CHECK(dbuf_heap_cstr_iter_is_end(&str_dbuf, fnd_it)); + TEST_CHECK(std::find(str_vec.cbegin(), str_vec.cbegin(), needle2) == str_vec.cbegin()); + + dbuf_heap_cstr_free(&str_dbuf, NULL); +} + + + +/* + DbufStrTest: +*/ + +void DbufStrTest::run() +{ + test_push_insert_erase(16); + test_push_insert_erase(16, 1); + test_push_insert_erase(16, 15); + test_push_insert_erase(16, 16); + test_push_insert_erase(16, 97); + test_push_insert_erase(16, 256); + + test_push_insert_erase(500); + test_push_insert_erase(500, 1); + test_push_insert_erase(500, 499); + test_push_insert_erase(500, 500); + test_push_insert_erase(500, 97); + test_push_insert_erase(500, 256); + +} + + +void DbufStrTest::test_push_insert_erase(size_t n, ptrdiff_t start_cap) +{ + dbuf_str strings = start_cap < 0 ? dbuf_str_new(&allocator) : dbuf_str_new_with_capacity(start_cap, &allocator); + std::vector strings_cpp {}; + + guf_libc_alloc_ctx str_allocator_ctx = { + .tracker = guf_alloc_tracker_new(42, "test_push_insert_erase: local str allocator", NULL, NULL), + .zero_init = false + }; + guf_allocator str_allocator = guf_libc_allocator_new(&str_allocator_ctx); + + for (size_t i = 0; i < n; ++i) { + std::string str; + for (size_t c = 0; c < 512 + GUF_STR_SSO_BUF_CAP; ++c) { + str += (char)(c % 10 + '0'); + } + const guf_str_view sv_long = guf_str_view{.str = str.data(), .len = (ptrdiff_t)str.size()}; + const guf_str_view sv_short = guf_str_view{.str = str.data(), .len = (ptrdiff_t)GUF_STR_SSO_BUF_CAP - 1}; + + guf_str long_str = GUF_STR_UNINITIALISED_CPP, short_str = GUF_STR_UNINITIALISED_CPP; + guf_str_init(&long_str, sv_long, &str_allocator); + guf_str_init(&short_str, sv_short, &str_allocator); + + TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 1 + (i*3)); + + // Move + guf_err err; + dbuf_str_try_push(&strings, &long_str, GUF_CPY_MOVE, &err); + TEST_CHECK(err == GUF_ERR_NONE); + dbuf_str_try_push(&strings, &short_str, GUF_CPY_MOVE, &err); + TEST_CHECK(err == GUF_ERR_NONE); + + strings_cpp.push_back(str.substr(0, str.size())); + strings_cpp.push_back(str.substr(0, GUF_STR_SSO_BUF_CAP - 1)); + + TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 1 + (i*3)); + + TEST_CHECK(guf_str_is_uninit(&long_str)); + TEST_CHECK(guf_str_is_uninit(&short_str)); + + // Deep-copy + guf_str_init(&long_str, sv_long, &str_allocator); + guf_str_init(&short_str, sv_short, &str_allocator); + + TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 2 + (i*3)); + + dbuf_str_try_push(&strings, &long_str, GUF_CPY_DEEP, &err); + TEST_CHECK(err == GUF_ERR_NONE); + dbuf_str_try_push(&strings, &short_str, GUF_CPY_DEEP, &err); + TEST_CHECK(err == GUF_ERR_NONE); + + strings_cpp.push_back(str.substr(0, str.size())); + strings_cpp.push_back(str.substr(0, GUF_STR_SSO_BUF_CAP - 1)); + + TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 3 + (i*3)); + + TEST_CHECK(guf_str_is_valid(&long_str) && guf_str_is_valid(&short_str)); + TEST_CHECK(guf_str_view_equal_val_arg(guf_str_view_from_str(&long_str), sv_long)); + TEST_CHECK(guf_str_view_equal_val_arg(guf_str_view_from_str(&short_str), sv_short)); + + guf_str_free(&long_str, NULL); + guf_str_free(&short_str, NULL); + + TEST_CHECK(str_allocator_ctx.tracker.free_count == 1 + (i*1)); + TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 3 + (i*3)); + } + + TEST_CHECK(str_allocator_ctx.tracker.free_count == n); + TEST_CHECK(str_allocator_ctx.tracker.alloc_count == 3 * n); + + TEST_CHECK(strings.size == 4 * (ptrdiff_t)n); + TEST_CHECK(strings.size == std::ssize(strings_cpp)); + + std::string str; + for (size_t c = 0; c < 512 + GUF_STR_SSO_BUF_CAP; ++c) { + str += (char)(c % 10 + '0'); + } + const guf_str_view sv_long = guf_str_view{.str = str.data(), .len = (ptrdiff_t)str.size()}; + const guf_str_view sv_short = guf_str_view{.str = str.data(), .len = (ptrdiff_t)GUF_STR_SSO_BUF_CAP - 1}; + size_t i = 0; + GUF_CNT_FOREACH(&strings, dbuf_str, it) { + if (TEST_CHECK(it.ptr)) { + const guf_str *s = it.ptr; + TEST_CHECK(guf_str_view_equal_val_arg(guf_str_view_from_str(s), i % 2 == 0 ? sv_long : sv_short)); + const guf_str_view sv_cpp = guf_str_view {.str = strings_cpp.at(i).data(), .len = (ptrdiff_t)strings_cpp.at(i).size()}; + TEST_CHECK(guf_str_view_equal_val_arg(guf_str_view_from_str(s), sv_cpp)); + } + ++i; + } + + GUF_CNT_FOREACH(&strings, dbuf_str, it) { + if (TEST_CHECK(it.ptr)) { + guf_str *s = it.ptr; + TEST_CHECK(guf_str_append(s, GUF_CSTR_LIT_TO_VIEW_CPP(""))); + } + } + std::vector delims = {guf_str_view{.str = "", .len = 5}}; + i = 0; + GUF_CNT_FOREACH(&strings, dbuf_str, it) { + if (TEST_CHECK(it.ptr)) { + const guf_str *s = it.ptr; + guf_str_tok_state tk_state = guf_str_tok_state_new(guf_str_view_from_str(s), delims.data(), std::ssize(delims), GUF_STR_TOK_DELIM_OPT_MATCH_LONGEST); + size_t tok_n = 0; + while (guf_str_tok_next(&tk_state, true)) { + TEST_CHECK(guf_str_view_equal_val_arg(tk_state.cur_tok , i % 2 == 0 ? sv_long : sv_short)); + TEST_CHECK(guf_str_view_equal_val_arg(tk_state.cur_delim, guf_str_view{.str = "", .len = 5})); + ++tok_n; + } + TEST_CHECK(tok_n == 1); + } + ++i; + } + + dbuf_str_free(&strings, NULL); + TEST_CHECK(!guf_alloc_tracker_found_leak(&str_allocator_ctx.tracker)); +} diff --git a/libguf/test/test_dbuf.hpp b/libguf/test/test_dbuf.hpp new file mode 100755 index 0000000..3cef1fd --- /dev/null +++ b/libguf/test/test_dbuf.hpp @@ -0,0 +1,69 @@ +#pragma once +#include +#include "test.hpp" + +extern "C" +{ + #include "guf_alloc_libc.h" + #include "impls/dbuf_impl.h" +} + +struct DbufIntTest : public Test +{ + DbufIntTest(const std::string& nm) : Test(nm) + { + allocator_ctx.zero_init = false; + guf_alloc_tracker_init(&allocator_ctx.tracker, 1, "DbufIntTest_allocator", NULL, NULL); + guf_libc_allocator_init(&allocator, &allocator_ctx); + } + + void run() override; + +private: + guf_allocator allocator; + guf_libc_alloc_ctx allocator_ctx; + + std::vector dbuf_to_vec(dbuf_int *dbuf); + void test_push(dbuf_int *dbuf, int n); + void test_insert_remove(int n); +}; + + +struct DbufCstringTest : public Test +{ + DbufCstringTest(std::string nm) : Test(nm) + { + allocator_ctx.zero_init = false; + guf_alloc_tracker_init(&allocator_ctx.tracker, 2, "DbufCstringTest_allocator", NULL, NULL); + guf_libc_allocator_init(&allocator, &allocator_ctx); + } + + void run() override; + +private: + guf_allocator allocator; + guf_libc_alloc_ctx allocator_ctx; + + void test_iter(std::vector& str_vec, dbuf_heap_cstr *str_dbuf, int step = 1); + void test_push_insert_erase(int n, ptrdiff_t start_cap = 0); + void test_find(int n = 32); +}; + + +struct DbufStrTest : public Test +{ + DbufStrTest(std::string nm) : Test(nm) + { + allocator_ctx.zero_init = false; + guf_alloc_tracker_init(&allocator_ctx.tracker, 3, "DbufStrTest_allocator", NULL, NULL); + guf_libc_allocator_init(&allocator, &allocator_ctx); + } + + void run() override; + +private: + guf_allocator allocator; + guf_libc_alloc_ctx allocator_ctx; + + void test_push_insert_erase(size_t n, ptrdiff_t start_cap = 0); +}; diff --git a/libguf/test/test_dict.cpp b/libguf/test/test_dict.cpp new file mode 100755 index 0000000..91d14ab --- /dev/null +++ b/libguf/test/test_dict.cpp @@ -0,0 +1,431 @@ +#include "test_dict.hpp" + +#include +#include +extern "C" +{ + #include "guf_alloc_libc.h" + #include "guf_str.h" + #include "impls/dict_impl.h" + #include "impls/dbuf_impl.h" +} + +/* + DictSvToIntTest: +*/ + +void DictSvToIntTest::run() +{ + if (done) { + return; + } + + push_check_name("insert_lookup(\"utf8-test.txt\")"); + if (TEST_CHECK(load_file(TEST_DATA_DIR "/utf8-test.txt"))) { + insert_lookup(); + for (ptrdiff_t i = 0; i <= 64; ++i) { + insert_lookup(i); + } + insert_lookup(512); + insert_lookup(1997); + insert_lookup(1999); + } + free_file(); + pop_check_name(); + + push_check_name("insert_lookup(\"bartleby.txt\")"); + if (TEST_CHECK(load_file(TEST_DATA_DIR "/bartleby.txt"))) { + insert_lookup(); + insert_lookup(201); + } + free_file(); + pop_check_name(); + + //guf_alloc_tracker_print(&allocator_ctx.tracker, NULL); + TEST_CHECK(!guf_alloc_tracker_found_leak(&allocator_ctx.tracker)); +} + +void DictSvToIntTest::insert_lookup(std::optional inital_dict_cap) +{ + std::unordered_map word_cnt_map {}; + dict_sv_i32 word_cnt_dict {}; + dict_str_i32 word_cnt_dict_str {}; + + if (inital_dict_cap) { + dict_sv_i32_init_with_capacity(&word_cnt_dict, &allocator, inital_dict_cap.value()); + dict_str_i32_init_with_capacity(&word_cnt_dict_str, &allocator, inital_dict_cap.value()); + } else { + dict_sv_i32_init(&word_cnt_dict, &allocator); + dict_str_i32_init(&word_cnt_dict_str, &allocator); + } + + dbuf_str_view delims = dbuf_str_view_new(&allocator); + for (size_t i = 0; i < GUF_ARR_SIZE(GUF_UTF8_WHITESPACE); ++i) { + guf_str_view d = {.str = GUF_UTF8_WHITESPACE[i], .len = (ptrdiff_t)strlen(GUF_UTF8_WHITESPACE[i])}; + dbuf_str_view_push_val(&delims, d); + } + for (size_t i = 0; i < GUF_ARR_SIZE(GUF_UTF8_COMMON_PUNCT); ++i) { + guf_str_view d = {.str = GUF_UTF8_COMMON_PUNCT[i], .len = (ptrdiff_t)strlen(GUF_UTF8_COMMON_PUNCT[i])}; + dbuf_str_view_push_val(&delims, d); + } + + guf_str_tok_state tok_state = guf_str_tok_state_new(guf_str_view{.str = text_buf.data, .len = text_buf.size}, delims.data, delims.size, GUF_STR_TOK_DELIM_OPT_MATCH_LONGEST); + while (guf_str_tok_next(&tok_state, true)) { + guf_str_view tok = tok_state.cur_tok; + // if (tok.len <= 0) { + // continue; + // } + std::string_view sv(tok.str , tok.len); + //std::cout << sv << std::string_view(tok_state.cur_delim.str, tok_state.cur_delim.len); + TEST_CHECK(dict_sv_i32_contains(&word_cnt_dict, &tok) == word_cnt_map.contains(sv)); + if (!dict_sv_i32_contains(&word_cnt_dict, &tok)) { + dict_sv_i32_insert_val_arg(&word_cnt_dict, tok, 1, GUF_CPY_VALUE, GUF_CPY_VALUE); + word_cnt_map.insert({sv, 1}); + if (TEST_CHECK(!dict_str_i32_contains_val_arg(&word_cnt_dict_str, guf_str_new_readonly(tok)))) { + dict_str_i32_insert_val_arg(&word_cnt_dict_str, guf_str_new(tok, &allocator), 1, GUF_CPY_MOVE, GUF_CPY_VALUE); + } + } else { + int32_t *cnt = dict_sv_i32_at_val_arg(&word_cnt_dict, tok); + if (TEST_CHECK(cnt)) { + *cnt += 1; + } + int32_t *cnt_2 = dict_str_i32_at_val_arg(&word_cnt_dict_str, guf_str_new_readonly(tok)); + if (TEST_CHECK(cnt_2)) { + *cnt_2 += 1; + } + // else { + // std::cout << "tok: " << std::string_view{tok.str, (size_t)tok.len} << "\n"; + // } + word_cnt_map.at(sv) += 1; + } + // printf("tok_len: %td ", tok.len); + // printf("'%.*s'\n", (int)tok.len, tok.str); + TEST_CHECK(dict_sv_i32_debug_valid_size(&word_cnt_dict)); + TEST_CHECK(dict_str_i32_debug_valid_size(&word_cnt_dict_str)); + + } + dbuf_str_view_free(&delims, NULL); + + TEST_CHECK(dict_sv_i32_size(&word_cnt_dict) == std::ssize(word_cnt_map)); + TEST_CHECK(dict_sv_i32_debug_valid_size(&word_cnt_dict)); + + TEST_CHECK(dict_str_i32_size(&word_cnt_dict_str) == std::ssize(word_cnt_map)); + TEST_CHECK(dict_str_i32_debug_valid_size(&word_cnt_dict_str)); + + for (const auto & [word, cnt] : word_cnt_map ) { + guf_str_view sv = {.str = word.data(), .len = (ptrdiff_t)word.size()}; + int32_t *res = dict_sv_i32_at(&word_cnt_dict, &sv); + int32_t *res2 = dict_str_i32_at_val_arg(&word_cnt_dict_str, guf_str_new_readonly(sv)); + TEST_CHECK(res && *res == cnt); + TEST_CHECK(res2 && *res2 == cnt); + } + + ptrdiff_t i = 0; + GUF_CNT_FOREACH(&word_cnt_dict, dict_sv_i32, kv_it) { + const dict_sv_i32_kv *kv = kv_it.ptr; + if (TEST_CHECK(kv)) { + const int32_t cnt = kv->val; + const std::string_view sv(kv->key.str, kv->key.len); + if (TEST_CHECK(word_cnt_map.contains(sv))) { + TEST_CHECK(word_cnt_map.at(sv) == cnt); + } + } + ++i; + } + TEST_CHECK(i == dict_sv_i32_size(&word_cnt_dict)); + TEST_CHECK(i == std::ssize(word_cnt_map)); + TEST_CHECK(dict_sv_i32_debug_valid_size(&word_cnt_dict)); + + i = 0; + GUF_CNT_FOREACH(&word_cnt_dict_str, dict_str_i32, kv_it) { + const dict_str_i32_kv *kv = kv_it.ptr; + if (TEST_CHECK(kv)) { + const int32_t cnt = kv->val; + const std::string_view sv(guf_str_const_cstr(&kv->key), guf_str_len(&kv->key)); + // std::cout << sv << "\n"; + + if (TEST_CHECK(word_cnt_map.contains(sv))) { + TEST_CHECK(word_cnt_map.at(sv) == cnt); + } + } + ++i; + } + TEST_CHECK(i == dict_str_i32_size(&word_cnt_dict_str)); + TEST_CHECK(i == std::ssize(word_cnt_map)); + TEST_CHECK(dict_str_i32_debug_valid_size(&word_cnt_dict_str)); + + // std::cout << "load fac: " << dict_sv_i32_load_factor(&word_cnt_dict) << ", cap: " << word_cnt_dict.kv_indices_cap << " elem cap: " << word_cnt_dict.kv_elems.capacity << "\n"; + // std::cout << "size: " << dict_sv_i32_size(&word_cnt_dict) << ", max probelen: " << word_cnt_dict.max_probelen << "\n"; + // std::cout << "mem usage: " << dict_sv_i32_memory_usage(&word_cnt_dict) << "\n"; + + // Erase tests: + const double load_fac_before_erase = dict_sv_i32_load_factor(&word_cnt_dict); + const ptrdiff_t size_before_erase = dict_sv_i32_size(&word_cnt_dict); + ptrdiff_t num_del = 0; + while (dict_sv_i32_size(&word_cnt_dict) > size_before_erase / 2) { + dict_sv_i32_kv *kv = NULL; + if (num_del % 2) { + dict_sv_i32_iter it = dict_sv_i32_begin(&word_cnt_dict); + GUF_ASSERT_RELEASE(!dict_sv_i32_iter_is_end(&word_cnt_dict, it)); + kv = it.ptr; + } else { + dict_sv_i32_iter rit = dict_sv_i32_rbegin(&word_cnt_dict); + GUF_ASSERT_RELEASE(!dict_sv_i32_iter_is_end(&word_cnt_dict, rit)); + kv = rit.ptr; + } + GUF_ASSERT_RELEASE(kv); + + const guf_str_view key = kv->key; + + const bool del_success = dict_sv_i32_erase(&word_cnt_dict, &key); + TEST_CHECK(del_success); + TEST_CHECK(!dict_sv_i32_contains(&word_cnt_dict, &key)); + + std::string_view sv(key.str, (size_t)key.len); + if (TEST_CHECK(word_cnt_map.contains(sv))) { + word_cnt_map.erase(sv); + } + TEST_CHECK(!word_cnt_map.contains(sv)); + + if (del_success) { + ++num_del; + } + } + TEST_CHECK(dict_sv_i32_size(&word_cnt_dict) >= 0); + TEST_CHECK(size_before_erase - num_del == dict_sv_i32_size(&word_cnt_dict)); + TEST_CHECK(std::ssize(word_cnt_map) == dict_sv_i32_size(&word_cnt_dict)); + + if (dict_sv_i32_size(&word_cnt_dict) != 0) { + TEST_CHECK(load_fac_before_erase == dict_sv_i32_load_factor(&word_cnt_dict)); + } else { + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == 0); + } + + if (dict_sv_i32_size(&word_cnt_dict) >= 4) { + dict_sv_i32_kv_dbuf_iter it = dict_sv_i32_begin(&word_cnt_dict); + it = dict_sv_i32_iter_next(&word_cnt_dict, it, 1); + GUF_ASSERT_RELEASE(!dict_sv_i32_iter_is_end(&word_cnt_dict, it)); + + guf_str_view key = it.ptr->key; + + bool del_success = dict_sv_i32_erase(&word_cnt_dict, &key); + TEST_CHECK(del_success); + TEST_CHECK(!dict_sv_i32_contains(&word_cnt_dict, &key)); + + std::string_view sv(key.str, (size_t)key.len); + if (TEST_CHECK(word_cnt_map.contains(sv))) { + word_cnt_map.erase(sv); + } + + it = dict_sv_i32_rbegin(&word_cnt_dict); + it = dict_sv_i32_iter_next(&word_cnt_dict, it, 1); + GUF_ASSERT_RELEASE(!dict_sv_i32_iter_is_end(&word_cnt_dict, it)); + key = it.ptr->key; + + del_success = dict_sv_i32_erase(&word_cnt_dict, &key); + TEST_CHECK(del_success); + TEST_CHECK(!dict_sv_i32_contains(&word_cnt_dict, &key)); + + sv = std::string_view(key.str, (size_t)key.len); + if (TEST_CHECK(word_cnt_map.contains(sv))) { + word_cnt_map.erase(sv); + } + } + TEST_CHECK(std::ssize(word_cnt_map) == dict_sv_i32_size(&word_cnt_dict)); + + i = 0; + GUF_CNT_FOREACH(&word_cnt_dict, dict_sv_i32, kv_it) { + const dict_sv_i32_kv *kv = kv_it.ptr; + if (TEST_CHECK(kv)) { + const int32_t cnt = kv->val; + const std::string_view sv(kv->key.str, (size_t)kv->key.len); + if (TEST_CHECK(word_cnt_map.contains(sv))) { + TEST_CHECK(word_cnt_map.at(sv) == cnt); + } + ++i; + } + } + TEST_CHECK(i == word_cnt_dict.kv_elems.size); + TEST_CHECK(i == std::ssize(word_cnt_map)); + + while (dict_sv_i32_size(&word_cnt_dict) > 0) { + const dict_sv_i32_iter beg = dict_sv_i32_begin(&word_cnt_dict); + if (TEST_CHECK(!dict_sv_i32_iter_is_end(&word_cnt_dict, beg))) { + const guf_str_view key = beg.ptr->key; + if (TEST_CHECK(dict_sv_i32_contains(&word_cnt_dict, &key))) { + const bool del_success = dict_sv_i32_erase(&word_cnt_dict, &key); + TEST_CHECK(del_success); + TEST_CHECK(!dict_sv_i32_contains(&word_cnt_dict, &key)); + } + const std::string_view sv(key.str, (size_t)key.len); + if (TEST_CHECK(word_cnt_map.contains(sv))) { + word_cnt_map.erase(sv); + } + } + } + TEST_CHECK(dict_sv_i32_size(&word_cnt_dict) == 0 && word_cnt_map.size() == 0); + TEST_CHECK(word_cnt_dict.num_tombstones == 0); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == 0); + + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Hej"), (size_t)64, GUF_CPY_VALUE, GUF_CPY_VALUE); + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("verden!"), (size_t)128, GUF_CPY_VALUE, GUF_CPY_VALUE); + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Flødeskum"), (size_t)256, GUF_CPY_VALUE, GUF_CPY_VALUE); + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("med"), (size_t)512, GUF_CPY_VALUE, GUF_CPY_VALUE); + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Faxe Kondi."), (size_t)1024, GUF_CPY_VALUE, GUF_CPY_VALUE); + + TEST_CHECK(dict_sv_i32_size(&word_cnt_dict) == 5); + + int32_t *val = dict_sv_i32_at_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Hej")); + TEST_CHECK(val && *val == 64); + val = dict_sv_i32_at_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Flødeskum")); + TEST_CHECK(val && *val == 256); + val = dict_sv_i32_at_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Faxe Kondi.")); + TEST_CHECK(val && *val == 1024); + val = dict_sv_i32_at_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("verden!")); + TEST_CHECK(val && *val == 128); + val = dict_sv_i32_at_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("med")); + TEST_CHECK(val && *val == 512); + + TEST_CHECK(word_cnt_dict.kv_elems.size == 5); + + TEST_CHECK(word_cnt_dict.kv_elems.data[0].val == 64 && std::strcmp(word_cnt_dict.kv_elems.data[0].key.str, "Hej") == 0); + TEST_CHECK(word_cnt_dict.kv_elems.data[1].val == 128 && std::strcmp(word_cnt_dict.kv_elems.data[1].key.str, "verden!") == 0); + TEST_CHECK(word_cnt_dict.kv_elems.data[2].val == 256 && std::strcmp(word_cnt_dict.kv_elems.data[2].key.str, "Flødeskum") == 0); + TEST_CHECK(word_cnt_dict.kv_elems.data[3].val == 512 && std::strcmp(word_cnt_dict.kv_elems.data[3].key.str, "med") == 0); + TEST_CHECK(word_cnt_dict.kv_elems.data[4].val == 1024 && std::strcmp(word_cnt_dict.kv_elems.data[4].key.str, "Faxe Kondi.") == 0); + + const double load_fac_beg = dict_sv_i32_load_factor(&word_cnt_dict); + const ptrdiff_t cap_begin = word_cnt_dict.kv_indices_cap; + ptrdiff_t del = 0; + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Hej"))); + TEST_CHECK(word_cnt_dict.num_tombstones == ++del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + for (ptrdiff_t n = 0; n < cap_begin + 128; ++n) { + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Hej"), 64, GUF_CPY_VALUE, GUF_CPY_VALUE); + TEST_CHECK(word_cnt_dict.num_tombstones == --del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Hej"))); + TEST_CHECK(word_cnt_dict.num_tombstones == ++del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + } + TEST_CHECK(word_cnt_dict.kv_indices_cap == cap_begin); + + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Faxe Kondi."))); + TEST_CHECK(word_cnt_dict.num_tombstones == ++del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + for (ptrdiff_t n = 0; n < 256; ++n) { + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Faxe Kondi."), 128, GUF_CPY_VALUE, GUF_CPY_VALUE); + TEST_CHECK(word_cnt_dict.num_tombstones == --del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Faxe Kondi."))); + TEST_CHECK(word_cnt_dict.num_tombstones == ++del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + } + TEST_CHECK(word_cnt_dict.kv_indices_cap == cap_begin); + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("med"))); + TEST_CHECK(word_cnt_dict.num_tombstones == ++del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + for (ptrdiff_t n = 0; n < 512 + cap_begin; ++n) { + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("med"), 256, GUF_CPY_VALUE, GUF_CPY_VALUE); + TEST_CHECK(word_cnt_dict.num_tombstones == --del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("med"))); + TEST_CHECK(word_cnt_dict.num_tombstones == ++del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + } + TEST_CHECK(word_cnt_dict.kv_indices_cap == cap_begin); + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Flødeskum"))); + TEST_CHECK(word_cnt_dict.num_tombstones == ++del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + for (ptrdiff_t n = 0; n < 71; ++n) { + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Flødeskum"), 512, GUF_CPY_VALUE, GUF_CPY_VALUE); + TEST_CHECK(word_cnt_dict.num_tombstones == --del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("Flødeskum"))); + TEST_CHECK(word_cnt_dict.num_tombstones == ++del); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == load_fac_beg); + } + TEST_CHECK(word_cnt_dict.kv_indices_cap == cap_begin); + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("verden!"))); + TEST_CHECK(word_cnt_dict.num_tombstones == 0); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == 0); + for (ptrdiff_t n = 0; n < 201; ++n) { + dict_sv_i32_insert_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("verden!"), 128, GUF_CPY_VALUE, GUF_CPY_VALUE); + TEST_CHECK(word_cnt_dict.num_tombstones == 0); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) > 0); + + TEST_CHECK(dict_sv_i32_erase_val_arg(&word_cnt_dict, GUF_CSTR_TO_VIEW_CPP("verden!"))); + TEST_CHECK(word_cnt_dict.num_tombstones == 0); + TEST_CHECK(dict_sv_i32_load_factor(&word_cnt_dict) == 0); + } + TEST_CHECK(word_cnt_dict.kv_indices_cap == cap_begin); + + TEST_CHECK(word_cnt_dict.kv_elems.size == 0); + TEST_CHECK(dict_sv_i32_size(&word_cnt_dict) == 0); + + + std::string str; + for (size_t c = 0; c < GUF_STR_SSO_BUF_CAP * 4; ++c) { + str += c % 2 ? "AAA" : "aaa"; + } + + guf_str str_cpy = guf_str_new(guf_str_view{.str = str.data(), .len = (ptrdiff_t)str.size()}, &allocator); + dict_str_i32_insert_val_arg(&word_cnt_dict_str, str_cpy, 42, GUF_CPY_DEEP, GUF_CPY_VALUE); + int32_t *foo = dict_str_i32_at_val_arg(&word_cnt_dict_str, guf_str_new_readonly(guf_str_view_from_str(&str_cpy))); + if (TEST_CHECK(foo)) { + TEST_CHECK(*foo == 42); + } + guf_str_append(&str_cpy, GUF_CSTR_LIT_TO_VIEW_CPP("Foobar")); + int32_t *foo2 = dict_str_i32_at_val_arg(&word_cnt_dict_str, guf_str_new_readonly(guf_str_view{.str = str.data(), .len = (ptrdiff_t)str.size()})); + if (TEST_CHECK(foo2)) { + TEST_CHECK(*foo2 == 42); + } + + guf_str_free(&str_cpy, NULL); + + dict_sv_i32_free(&word_cnt_dict, NULL); + dict_str_i32_free(&word_cnt_dict_str, NULL); + + bool dbuf_null = !word_cnt_dict.kv_elems.data && !word_cnt_dict.kv_elems.allocator && !word_cnt_dict.kv_elems.capacity && !word_cnt_dict.kv_elems.size; + TEST_CHECK(dbuf_null && !word_cnt_dict.kv_indices && !word_cnt_dict.kv_indices_cap && !word_cnt_dict.max_probelen && !word_cnt_dict.num_tombstones); +} + +bool DictSvToIntTest::load_file(const char *fname) +{ + FILE *in_file {nullptr}; + if (!in_file) { + in_file = fopen(fname, "r"); + } + + GUF_ASSERT_RELEASE(in_file); + + dbuf_char_init(&text_buf, 128, &allocator); + + int c = EOF; + while ((c = fgetc(in_file)) != EOF) { + dbuf_char_push_val(&text_buf, (char)c); + text_vec.push_back((char)c); + } + fclose(in_file); + + // dbuf_char_insert_val(&text_buf, '\xC0', 1); + // text_vec.insert(text_vec.cbegin() + 1, '\xC0'); + + return TEST_CHECK(std::ssize(text_vec) == text_buf.size); +} + +void DictSvToIntTest::free_file() +{ + dbuf_char_free(&text_buf, NULL); + text_buf = {}; + text_vec.clear(); +} diff --git a/libguf/test/test_dict.hpp b/libguf/test/test_dict.hpp new file mode 100755 index 0000000..da51229 --- /dev/null +++ b/libguf/test/test_dict.hpp @@ -0,0 +1,35 @@ +#pragma once +#include +#include +#include +#include "test.hpp" + +extern "C" +{ + #include "impls/dbuf_impl.h" + #include "guf_alloc_libc.h" +} + +struct DictSvToIntTest : public Test +{ + DictSvToIntTest(const std::string& nm) : Test(nm) + { + allocator_ctx.zero_init = false; + guf_alloc_tracker_init(&allocator_ctx.tracker, 3, "DictSvToIntTest_allocator", NULL, NULL); + guf_libc_allocator_init(&allocator, &allocator_ctx); + }; + + void run() override; + +private: + guf_allocator allocator; + guf_libc_alloc_ctx allocator_ctx; + + dbuf_char text_buf {}; + std::vector text_vec {}; + + bool load_file(const char *fname); + void free_file(); + + void insert_lookup(std::optional inital_dict_cap = {}); +}; diff --git a/libguf/test/test_str.cpp b/libguf/test/test_str.cpp new file mode 100755 index 0000000..9f816da --- /dev/null +++ b/libguf/test/test_str.cpp @@ -0,0 +1,379 @@ +#include "test_str.hpp" +extern "C" +{ + #include "guf_alloc_libc.h" +} + +/* + StrTest: +*/ + +void StrTest::run() +{ + if (done) { + return; + } + + const std::vector words = { + "", + "\0", + "Hello", + "Othell\0o", + "f\0\0", + "\0", + "0", + "a", + "ab", + "🌈 waow a rainboge!", + "orange cat(1) :3", + "xes yag", + "Hello, world! This is a pretty darn long string I'd say...", + "I want to eat crayons. I crave crayons because they are tasty, and everybody telling me crayons are not edible must be either lying or dumb. I like trains. 42 is a number. 3.14159265... is not a rational number, and it is called pi. I ate some pie (it was a crayon pie).", + std::string(32, 'a'), + std::string(64, 'b'), + std::string(1024, 'a'), + std::string(2048, 'a'), + std::string(4096, 'a'), + std::string(5001, 'a'), + std::string(7121, 'a'), + std::string(2000, 'a'), + std::string(GUF_STR_SSO_BUF_CAP, 'a'), + std::string(GUF_STR_SSO_BUF_CAP - 1, 'a'), + std::string(GUF_STR_SSO_BUF_CAP + 1, 'a'), + std::string(GUF_STR_SSO_BUF_CAP - 2, 'a'), + std::string(GUF_STR_SSO_BUF_CAP + 2, 'a'), + std::string(GUF_STR_SSO_BUF_CAP - 3, 'a'), + std::string(GUF_STR_SSO_BUF_CAP + 3, 'a'), + std::string(GUF_STR_SSO_BUF_CAP * 2, 'a'), + std::string(GUF_STR_SSO_BUF_CAP * 3, 'a'), + std::string(GUF_STR_SSO_BUF_CAP * 4, 'a'), + std::string(GUF_STR_SSO_BUF_CAP * 5, 'a'), + std::string(GUF_STR_SSO_BUF_CAP * 6, 'a'), + std::string(GUF_STR_SSO_BUF_CAP * 7, 'a'), + }; + + + push_check_name("init_empy"); + test_init_empty(); + pop_check_name(); + + push_check_name("append_char"); + for (const auto& word : words) { + test_init_free(word); + test_append_char(word); + test_append_char(word, true); + } + pop_check_name(); + + push_check_name("append_str"); + for (size_t i = 0; i < words.size(); ++i) { + const auto& w1 = words.at(i); + append_str(w1, w1); + append_str(w1, w1); + for (size_t j = i + 1; j < words.size(); ++j) { + const auto& w2 = words.at(j); + append_str(w1, w2); + append_str(w2, w1); + } + } + pop_check_name(); + + push_check_name("test_popsplit"); + std::vector split = test_popsplit("1997-04-01", "-"); + if (TEST_CHECK(split.size() == 3)) { + TEST_CHECK(split.at(0) == "1997" && split.at(1) == "04" && split.at(2) == "01"); + } + split = test_popsplit("1997-04-01-", "-"); + if (TEST_CHECK(split.size() == 3)) { + TEST_CHECK(split.at(0) == "1997" && split.at(1) == "04" && split.at(2) == "01"); + } + + split = test_popsplit("2025/05/08", "/"); + if (TEST_CHECK(split.size() == 3)) { + TEST_CHECK(split.at(0) == "2025" && split.at(1) == "05" && split.at(2) == "08"); + } + split = test_popsplit("2025/05/08/", "/"); + if (TEST_CHECK(split.size() == 3)) { + TEST_CHECK(split.at(0) == "2025" && split.at(1) == "05" && split.at(2) == "08"); + } + split = test_popsplit("2025/05/08//", "/"); + if (TEST_CHECK(split.size() == 4)) { + TEST_CHECK(split.at(0) == "2025" && split.at(1) == "05" && split.at(2) == "08" && split.at(3) == ""); + } + + split = test_popsplit("/2025/05/08", "/"); + if (TEST_CHECK(split.size() == 4)) { + TEST_CHECK(split.at(0) == "" && split.at(1) == "2025" && split.at(2) == "05" && split.at(3) == "08"); + } + split = test_popsplit("//2025/05/08", "/"); + if (TEST_CHECK(split.size() == 5)) { + TEST_CHECK(split.at(0) == "" && split.at(1) == "" && split.at(2) == "2025" && split.at(3) == "05" && split.at(4) == "08"); + } + + split = test_popsplit("I eat formidable crayons, oof, for real", "foo"); + if (TEST_CHECK(split.size() == 1)) { + TEST_CHECK(split.at(0) == "I eat formidable crayons, oof, for real"); + } + + split = test_popsplit("Hej <<", "<<"); + if (TEST_CHECK(split.size() == 1)) { + TEST_CHECK(split.at(0) == "Hej "); + } + split = test_popsplit("Hej << verden", "<<"); + if (TEST_CHECK(split.size() == 2)) { + TEST_CHECK(split.at(0) == "Hej " && split.at(1) == " verden"); + } + split = test_popsplit("<< Hej << verden", "<<"); + if (TEST_CHECK(split.size() == 3)) { + TEST_CHECK(split.at(0) == "" && split.at(1) == " Hej " && split.at(2) == " verden"); + } + split = test_popsplit("<< Hej << verden <<< foo<>", "<<"); + if (TEST_CHECK(split.size() == 4)) { + TEST_CHECK(split.at(0) == "" && split.at(1) == " Hej " && split.at(2) == " verden " && split.at(3) == "< foo<>"); + } + + split = test_popsplit("I eat tofu", ""); + if (TEST_CHECK(split.size() == 1)) { + TEST_CHECK(split.at(0) == "I eat tofu"); + } + + split = test_popsplit("At 3 a.m. during FULL-moon FULL-STOP Next to the public-library's -STOP sign FULL-STOP", "FULL-STOP"); + if (TEST_CHECK(split.size() == 2)) { + TEST_CHECK(split.at(0) == "At 3 a.m. during FULL-moon " && split.at(1) == " Next to the public-library's -STOP sign "); + } + split = test_popsplit("At 3 a.m. during FULL-moon FULL-STOP Next to the public-library's -STOP sign FULL-STOPI like trains, FULL-STO", "FULL-STOP"); + if (TEST_CHECK(split.size() == 3)) { + TEST_CHECK(split.at(0) == "At 3 a.m. during FULL-moon " && split.at(1) == " Next to the public-library's -STOP sign " && split.at(2) == "I like trains, FULL-STO"); + } + split = test_popsplit("At 3 a.m. during FULL-moon FULL-STOP Next to the public-library's -STOP sign FULL-STOPI like trains, FULL-STO Poo", "FULL-STOP"); + if (TEST_CHECK(split.size() == 3)) { + TEST_CHECK(split.at(0) == "At 3 a.m. during FULL-moon " && split.at(1) == " Next to the public-library's -STOP sign " && split.at(2) == "I like trains, FULL-STO Poo"); + } + pop_check_name(); + + push_check_name("get_toks"); + std::vector tok_words = {"hello", "world", "cat", "vertex", "normal", "pizza", "running", "mouse", "playing", "adjacent"}; + std::vector delims = {",", " ", "\n", "\t", "\r"}; + + for (int is_trailing = 0; is_trailing < 2; ++is_trailing) { + for (ptrdiff_t num_words = 1; num_words < std::ssize(tok_words); ++num_words) { + std::string str = ""; + for (ptrdiff_t j = 0; j < num_words; ++j) { + str += tok_words.at(j); + if (j < num_words - 1 || is_trailing) { + str += ", "; + } + } + std::vector toks = get_toks(std::string_view{str}, delims, false, GUF_STR_TOK_DELIM_OPT_MATCH_LONGEST); + if (TEST_CHECK(std::ssize(toks) == num_words)) { + for (ptrdiff_t i = 0; i < num_words; ++i) { + TEST_CHECK(toks.at(i) == tok_words.at(i)); + } + } + } + } + + std::string_view tok_str = "age: 28, occupation: NULL, crayons_eaten: 256 "; + delims = {"", "", ":", ",", " ", "\t", "", "" && tok_result.at(0) == "" && tok_result.at(1) == "age" && tok_result.at(2) == ":" && tok_result.at(3) == " " && tok_result.at(4) == "28"); + + tok_result = get_toks(tok_str, delims, false, GUF_STR_TOK_DELIM_OPT_MATCH_LONGEST); + TEST_CHECK(tok_result.size() == 6); + TEST_CHECK(tok_result.at(0) == "age" && tok_result.at(1) == "28" && tok_result.at(2) == "occupation" && tok_result.at(3) == "NULL" && + tok_result.at(4) == "crayons_eaten" && tok_result.at(5) == "256"); + pop_check_name(); + + // guf_alloc_tracker_print(&allocator_ctx.tracker, NULL); + TEST_CHECK(!guf_alloc_tracker_found_leak(&allocator_ctx.tracker)); +} + + +void StrTest::test_init_free(std::string str) +{ + guf_str s0; + guf_str_init(&s0, GUF_CSTR_TO_VIEW_CPP(str.c_str()), &allocator); + guf_str s1 = guf_str_new(GUF_CSTR_TO_VIEW_CPP(str.c_str()), &allocator); + guf_str s2; + guf_str_init_from_cstr(&s2, str.c_str(), &allocator); + + TEST_CHECK(guf_str_equal(&s0, &s1)); + TEST_CHECK(guf_str_equal(&s0, &s2)); + TEST_CHECK(guf_str_equal(&s1, &s2)); + + TEST_CHECK((ptrdiff_t)str.size() == guf_str_len(&s0)); + TEST_CHECK(str == guf_str_const_cstr(&s0)); + TEST_CHECK(str == guf_str_cstr(&s0)); + + TEST_CHECK((ptrdiff_t)str.size() == guf_str_len(&s1)); + TEST_CHECK(str == guf_str_const_cstr(&s1)); + TEST_CHECK(str == guf_str_cstr(&s1)); + + TEST_CHECK((ptrdiff_t)str.size() == guf_str_len(&s2)); + TEST_CHECK(str == guf_str_const_cstr(&s2)); + TEST_CHECK(str == guf_str_cstr(&s2)); + + guf_str_free(&s0, NULL); + guf_str_free(&s1, NULL); + guf_str_free(&s2, NULL); + TEST_CHECK(guf_str_is_uninit(&s0)); + TEST_CHECK(guf_str_is_uninit(&s1)); + TEST_CHECK(guf_str_is_uninit(&s2)); +} + +void StrTest::test_init_empty() +{ + std::string str = ""; + guf_str s = GUF_STR_UNINITIALISED_CPP; + guf_str_init_empty(&s, &allocator); + TEST_CHECK(guf_str_len(&s) == 0); + TEST_CHECK(str == guf_str_const_cstr(&s)); + + guf_str_append_char(&s, 'a', 1024); + str.append(1024, 'a'); + TEST_CHECK(guf_str_len(&s) == (ptrdiff_t)str.size()); + TEST_CHECK(guf_str_const_cstr(&s) == str); + + guf_str_append_char(&s, 'b', 24); + str.append(24, 'b'); + TEST_CHECK(guf_str_len(&s) == (ptrdiff_t)str.size()); + TEST_CHECK(guf_str_const_cstr(&s) == str); + + guf_str_append_char(&s, 'c', 255); + str.append(255, 'c'); + TEST_CHECK(guf_str_len(&s) == (ptrdiff_t)str.size()); + TEST_CHECK(guf_str_const_cstr(&s) == str); + + *guf_str_at(&s, 0) = '<'; + str.at(0) = '<'; + TEST_CHECK(guf_str_len(&s) == (ptrdiff_t)str.size()); + TEST_CHECK(guf_str_const_cstr(&s) == str); + + *guf_str_at(&s, guf_str_len(&s) - 1) = '>'; + str.at(str.size() - 1) = '>'; + TEST_CHECK(guf_str_len(&s) == (ptrdiff_t)str.size()); + TEST_CHECK(guf_str_const_cstr(&s) == str); + + guf_err err = GUF_ERR_NONE; + TEST_CHECK(NULL == guf_str_try_at(&s, guf_str_len(&s), &err)); + TEST_CHECK(err != GUF_ERR_NONE && err == GUF_ERR_IDX_RANGE); + err = GUF_ERR_NONE; + TEST_CHECK(NULL == guf_str_try_at(&s, -1, &err)); + TEST_CHECK(err != GUF_ERR_NONE && err == GUF_ERR_IDX_RANGE); + + guf_str_free(&s, NULL); + TEST_CHECK(guf_str_is_uninit(&s)); +} + +void StrTest::test_append_char(std::string str, bool include_null) +{ + guf_str s0 = guf_str_new(guf_str_view{.str = str.c_str(), .len = (ptrdiff_t)str.size()}, &allocator); + + TEST_CHECK((ptrdiff_t)str.size() == guf_str_len(&s0)); + TEST_CHECK((str == std::string_view{guf_str_const_cstr(&s0), (size_t)guf_str_len(&s0)})); + + for (int i = include_null ? 0 : 1; i < 128; ++i) { + char ch = (char)i; + guf_str_append_one_char(&s0, ch); + str.append(1, ch); + TEST_CHECK(guf_str_len(&s0) == (ptrdiff_t)str.size()); + TEST_CHECK((str == std::string_view{guf_str_const_cstr(&s0), (size_t)guf_str_len(&s0)})); + } + + for (int i = include_null ? 0 : 1; i < 128; ++i) { + char ch = (char)i; + guf_str_append_char(&s0, ch, i); + str.append(i, ch); + TEST_CHECK(guf_str_len(&s0) == (ptrdiff_t)str.size()); + TEST_CHECK((str == std::string_view{guf_str_const_cstr(&s0), (size_t)guf_str_len(&s0)})); + guf_str_append_char(&s0, ch, i * 16); + str.append(i * 16, ch); + TEST_CHECK(guf_str_len(&s0) == (ptrdiff_t)str.size()); + TEST_CHECK((str == std::string_view{guf_str_const_cstr(&s0), (size_t)guf_str_len(&s0)})); + } + + guf_str_free(&s0, NULL); + TEST_CHECK(guf_str_is_uninit(&s0)); +} + +void StrTest::append_str(const std::string& a, const std::string& b) +{ + std::string str0 = a; + guf_str s0 = guf_str_new(guf_str_view{.str = str0.c_str(), .len = (ptrdiff_t)str0.size()}, &allocator); + TEST_CHECK(guf_str_len(&s0) == (ptrdiff_t)str0.size()); + TEST_CHECK((str0 == std::string_view{guf_str_const_cstr(&s0), (size_t)guf_str_len(&s0)})); + TEST_CHECK((str0 == std::string_view{guf_str_cstr(&s0), (size_t)guf_str_len(&s0)})); + + for (int i = 0; i <= 64; ++i) { + str0.append(b); + guf_str_append(&s0, guf_str_view{.str = b.c_str(), .len = (ptrdiff_t)b.size()}); + TEST_CHECK(guf_str_len(&s0) == (ptrdiff_t)str0.size()); + TEST_CHECK((str0 == std::string_view{guf_str_const_cstr(&s0), (size_t)guf_str_len(&s0)})); + TEST_CHECK((str0 == std::string_view{guf_str_cstr(&s0), (size_t)guf_str_len(&s0)})); + } + + guf_str_free(&s0, NULL); + TEST_CHECK(guf_str_is_uninit(&s0)); +} + +std::vector StrTest::test_popsplit(std::string_view str, std::string_view delim) +{ + std::vector result = {}; + + if (delim.size() > 0) { // NOTE: str.find with an empty delimiter returns 0, not std::string::npos + std::string_view src_cpp = str; + for (size_t idx = src_cpp.find(delim, 0); src_cpp.size() > 0; idx = src_cpp.find(delim, 0)) { + result.push_back(src_cpp.substr(0, idx)); + if (idx == std::string::npos) { + break; + } + src_cpp = src_cpp.substr(idx + delim.size()); + } + } else { + result.push_back(str); + } + + + const guf_str_view delim_sv = guf_str_view{.str = delim.data(), .len = (ptrdiff_t)delim.size()}; + guf_str_view src = guf_str_view{.str = str.data(), .len = (ptrdiff_t)str.size()}; + size_t n = 0; + do { + const guf_str_view popped = guf_str_view_pop_split(&src, delim_sv); + TEST_CHECK(n < result.size()); + TEST_CHECK(std::string_view(popped.str, (size_t)popped.len) == result.at(n)); + const guf_str_view res = {.str = result.at(n).data(), .len = (ptrdiff_t)result.at(n).size()}; + TEST_CHECK(guf_str_view_equal(&popped, &res)); + TEST_CHECK(guf_str_view_equal_val_arg(popped, res)); + // std::cout << "guf: " << std::string_view{popped.str, (size_t)popped.len} << "\n"; + // std::cout << "cpp: " << std::string_view{res.str, (size_t)res.len} << "\n"; + ++n; + } while (src.len > 0); + TEST_CHECK(n == result.size()); + + return result; +} + +std::vector StrTest::get_toks(std::string_view sv_in, const std::vector& delims_in, bool preserve_delims, guf_str_tok_delim_opt opt) +{ + const guf_str_view sv = guf_str_view{.str = sv_in.data(), .len = (ptrdiff_t)sv_in.size()}; + std::vector delims; + for (const auto delim : delims_in) { + delims.push_back(guf_str_view{.str = delim.data(), .len = (ptrdiff_t)delim.size()}); + } + guf_str_tok_state tok_state = guf_str_tok_state_new(sv, delims.data(), std::ssize(delims), opt); + + std::vector toks_out; + while (guf_str_tok_next(&tok_state, preserve_delims)) { + if (tok_state.cur_tok.len > 0) { + toks_out.push_back( std::string_view{tok_state.cur_tok.str, (size_t)tok_state.cur_tok.len}); + } + if (preserve_delims && tok_state.cur_delim.len > 0) { + toks_out.push_back( std::string_view{tok_state.cur_delim.str, (size_t)tok_state.cur_delim.len}); + } + } + TEST_CHECK(tok_state.done); + const ptrdiff_t num_toks = preserve_delims ? tok_state.num_delims_read + tok_state.num_toks_read : tok_state.num_toks_read; + TEST_CHECK(num_toks == std::ssize(toks_out)); + return toks_out; +} diff --git a/libguf/test/test_str.hpp b/libguf/test/test_str.hpp new file mode 100755 index 0000000..6153700 --- /dev/null +++ b/libguf/test/test_str.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include +#include +#include "test.hpp" +extern "C" +{ + #include "guf_str.h" + #include "guf_alloc_libc.h" +} + +struct StrTest : public Test +{ + StrTest(const std::string& nm) : Test(nm) + { + allocator_ctx.zero_init = false; + guf_alloc_tracker_init(&allocator_ctx.tracker, 4, "StrTest_allocator", NULL, NULL); + guf_libc_allocator_init(&allocator, &allocator_ctx); + }; + + void run() override; + +private: + guf_allocator allocator; + guf_libc_alloc_ctx allocator_ctx; + + void test_init_free(std::string str); + void test_init_empty(); + void test_append_char(std::string str, bool include_null = false); + void append_str(const std::string& a, const std::string& b); + std::vector test_popsplit(std::string_view str, std::string_view delim); + std::vector get_toks(std::string_view sv_in, const std::vector& delims_in, bool preserve_delims = false, guf_str_tok_delim_opt opt = GUF_STR_TOK_DELIM_OPT_MATCH_LONGEST); +}; diff --git a/libguf/test/test_utf8.cpp b/libguf/test/test_utf8.cpp new file mode 100755 index 0000000..3294070 --- /dev/null +++ b/libguf/test/test_utf8.cpp @@ -0,0 +1,387 @@ +#include "test_utf8.hpp" +extern "C" +{ + #include "guf_alloc_libc.h" + #include "guf_str.h" + #include "impls/dict_impl.h" +} + +/* + UTF8Test: +*/ + +void UTF8Test::run() +{ + if (done) { + return; + } + + push_check_name("read_utf8_chars"); + ptrdiff_t valid = 0, invalid = 0; + read_utf8_chars(TEST_DATA_DIR "/" "utf8-test.txt", &valid, &invalid); + TEST_CHECK(valid == 2635 && invalid == 0); + read_utf8_chars(TEST_DATA_DIR "/" "bartleby.txt", &valid, &invalid); + TEST_CHECK(valid > 16000 && invalid == 0); + pop_check_name(); + + push_check_name("count_words"); + dbuf_str_view delims = dbuf_str_view_new(&allocator); + for (size_t i = 0; i < GUF_ARR_SIZE(GUF_UTF8_WHITESPACE); ++i) { + guf_str_view d = {.str = GUF_UTF8_WHITESPACE[i], .len = (ptrdiff_t)strlen(GUF_UTF8_WHITESPACE[i])}; + dbuf_str_view_push_val(&delims, d); + } + for (size_t i = 0; i < GUF_ARR_SIZE(GUF_UTF8_COMMON_PUNCT); ++i) { + guf_str_view d = {.str = GUF_UTF8_COMMON_PUNCT[i], .len = (ptrdiff_t)strlen(GUF_UTF8_COMMON_PUNCT[i])}; + dbuf_str_view_push_val(&delims, d); + } + int words = count_words(TEST_DATA_DIR "/" "utf8-test.txt", &delims); + TEST_CHECK(words == 422); + int words_with_delims = count_words_with_delims(TEST_DATA_DIR "/" "utf8-test.txt", &delims); + TEST_CHECK(words_with_delims == 950); + + int words2 = count_words(TEST_DATA_DIR "/" "bartleby.txt", &delims); + TEST_CHECK(words2 > 2048); + + dbuf_str_view_free(&delims, NULL); + pop_check_name(); + + push_check_name("encode_decode"); + encode_decode(); + encode_decode_file(TEST_DATA_DIR "/" "utf8-test.txt"); + encode_decode_file(TEST_DATA_DIR "/" "bartleby.txt"); + pop_check_name(); + + //guf_alloc_tracker_print(&allocator_ctx.tracker, NULL); + TEST_CHECK(!guf_alloc_tracker_found_leak(&allocator_ctx.tracker)); +} + + +bool UTF8Test::load_text(const char *fname) +{ + FILE *in_file {nullptr}; + if (!in_file) { + in_file = fopen(fname, "r"); + } + + if (!in_file) { + return false; + } + + dbuf_char_init(&text_buf, 128, &allocator); + + int c = EOF; + while ((c = fgetc(in_file)) != EOF) { + dbuf_char_push_val(&text_buf, (char)c); + text_vec.push_back((char)c); + } + fclose(in_file); + + return TEST_CHECK(std::ssize(text_vec) == text_buf.size); +} + +void UTF8Test::free_text() +{ + dbuf_char_free(&text_buf, NULL); + text_vec.clear(); +} + + +void UTF8Test::read_utf8_chars(const char *fname, ptrdiff_t *n_valid, ptrdiff_t *n_invalid) +{ + GUF_ASSERT_RELEASE(load_text(fname)); + + ptrdiff_t valid_chars = 0, invalid_chars = 0, bytes = 0; + guf_str_view input_str = {.str = text_buf.data, .len = text_buf.size}; + guf_utf8_char ch = {}; + for (guf_utf8_stat stat = guf_utf8_char_next(&ch, &input_str); stat != GUF_UTF8_READ_DONE; stat = guf_utf8_char_next(&ch, &input_str)) { + if (stat == GUF_UTF8_READ_VALID) { + ++valid_chars; + // printf("%s", ch.bytes); + } else { + ++invalid_chars; + // printf("::INVALID_UTF8_CHAR::"); + } + bytes += guf_utf8_char_num_bytes(&ch); + } + TEST_CHECK(input_str.len == 0 && input_str.str == NULL); + TEST_CHECK(bytes == text_buf.size); + + // printf("\nread %td bytes\n", bytes); + // printf("read %td valid and %td invalid utf-8 characters\n", valid_chars, invalid_chars); + + free_text(); + + if (n_valid) + *n_valid = valid_chars; + if (n_invalid) + *n_invalid = invalid_chars; +} + +int UTF8Test::count_words(const char *fname, const dbuf_str_view *delims) +{ + GUF_ASSERT_RELEASE(load_text(fname)); + + int num_words = 0; + + guf_str_tok_state tok_state = guf_str_tok_state_new(guf_str_view{.str = text_buf.data, .len = text_buf.size}, delims->data, delims->size, GUF_STR_TOK_DELIM_OPT_MATCH_LONGEST); + while (guf_str_tok_next(&tok_state, false)) { + TEST_CHECK(tok_state.cur_tok.len > 0); + ++num_words; + } + + free_text(); + return num_words; +} + +int UTF8Test::count_words_with_delims(const char *fname, const dbuf_str_view *delims) +{ + GUF_ASSERT_RELEASE(load_text(fname)); + + int num_words = 0, num_delims = 0; + guf_str_tok_state tok_state = guf_str_tok_state_new(guf_str_view{.str = text_buf.data, .len = text_buf.size}, delims->data, delims->size, GUF_STR_TOK_DELIM_OPT_MATCH_LONGEST); + while (guf_str_tok_next(&tok_state, true)) { + if (tok_state.cur_tok.len) { + ++num_words; + // printf("'%.*s'\n", (int)tok_state.cur_tok.len, tok_state.cur_tok.str); + } + if (tok_state.cur_delim.len) { + ++num_delims; + // if (tok_state.cur_delim.str[0] == '\n') + // printf("'\\n'\n"); + // else + // printf("'%.*s'\n", (int)tok_state.cur_delim.len, tok_state.cur_delim.str); + } + } + free_text(); + return num_words + num_delims; +} + +void UTF8Test::encode_decode_file(const char *fname) +{ + GUF_ASSERT_RELEASE(load_text(fname)); + + dbuf_i32 cp_buf = dbuf_i32_new(&allocator); + + ptrdiff_t valid_chars = 0, invalid_chars = 0; + guf_str_view input_str = {.str = text_buf.data, .len = text_buf.size}; + guf_utf8_char ch = {}; + for (guf_utf8_stat stat = guf_utf8_char_next(&ch, &input_str); stat != GUF_UTF8_READ_DONE; stat = guf_utf8_char_next(&ch, &input_str)) { + if (stat == GUF_UTF8_READ_VALID) { + ++valid_chars; + const int32_t codepoint = guf_utf8_decode(&ch); + TEST_CHECK(codepoint >= 0); + dbuf_i32_push_val(&cp_buf, codepoint); + } else { + ++invalid_chars; + const int32_t codepoint = guf_utf8_decode(&ch); + TEST_CHECK(codepoint < 0); + dbuf_i32_push_val(&cp_buf, -1); + } + } + TEST_CHECK(cp_buf.size == valid_chars + invalid_chars); + + guf_str_view in_str = {.str = text_buf.data, .len = text_buf.size}; + GUF_CNT_FOREACH(&cp_buf, dbuf_i32, it) { + GUF_ASSERT_RELEASE(it.ptr); + const int32_t codepoint = *it.ptr; + guf_utf8_char utf8_ch = {}; + const guf_utf8_stat stat = guf_utf8_char_next(&utf8_ch, &in_str); + if (codepoint >= 0) { + TEST_CHECK(stat == GUF_UTF8_READ_VALID); + guf_utf8_char encoded_ch = {}; + TEST_CHECK(guf_utf8_encode(&encoded_ch, codepoint)); + TEST_CHECK(guf_utf8_equal(&encoded_ch, &utf8_ch)); + } + } + guf_utf8_char utf8_ch = {}; + const guf_utf8_stat stat = guf_utf8_char_next(&utf8_ch, &in_str); + TEST_CHECK(stat == GUF_UTF8_READ_DONE); + + dbuf_i32_free(&cp_buf, NULL); + + free_text(); +} + +void UTF8Test::encode_decode() +{ + guf_utf8_char utf8 = {0}; + + // 1 byte characters. + for (uint8_t ascii = 0; ascii <= 0x7F; ++ascii) { + TEST_CHECK(guf_utf8_encode(&utf8, ascii)); + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 1); + TEST_CHECK(utf8.bytes[0] == ascii); + TEST_CHECK(utf8.bytes[1] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == ascii); + } + + // 2 byte characters: + TEST_CHECK(guf_utf8_encode(&utf8, 0x00E6)); // "æ" (Latin Small Letter Ae) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xC3' && utf8.bytes[1] == '\xA6'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x00E6); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x00E5)); // "å" (Latin Small Letter A with Ring Above) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xC3' && utf8.bytes[1] == '\xA5'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x00E5); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x00F8)); // "ø" (Latin Small Letter O with Stroke) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xC3' && utf8.bytes[1] == '\xB8'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x00F8); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x00E4)); // "ä" (Latin Small Letter A with Diaeresis) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xC3' && utf8.bytes[1] == '\xA4'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x00E4); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x00F6)); // "ö" (Latin Small Letter O with Diaeresis) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xC3' && utf8.bytes[1] == '\xB6'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x00F6); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x00D6)); // "Ö" (Latin Capital Letter O with Diaeresis) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xC3' && utf8.bytes[1] == '\x96'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x00D6); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x00FC)); // "ü" (Latin Small Letter U with Diaeresis) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xC3' && utf8.bytes[1] == '\xBC'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x00FC); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x00B5)); // "µ" (Micro Sign) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xC2' && utf8.bytes[1] == '\xB5'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x00B5); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x030A)); // "◌̊" (Combining Ring Above) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 2); + TEST_CHECK(utf8.bytes[0] == '\xCC' && utf8.bytes[1] == '\x8A'); + TEST_CHECK(utf8.bytes[2] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x030A); + + // 3 byte characters: + TEST_CHECK(guf_utf8_encode(&utf8, 0x7121)); // "無" (Nothingness; CJK Unified Ideograph-7121) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 3); + TEST_CHECK(!guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(utf8.bytes[0] == '\xE7' && utf8.bytes[1] == '\x84' && utf8.bytes[2] == '\xA1'); + TEST_CHECK(utf8.bytes[3] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x7121); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x201E)); // "„" (Double Low-9 Quotation Mark) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 3); + TEST_CHECK(!guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(utf8.bytes[0] == '\xE2' && utf8.bytes[1] == '\x80' && utf8.bytes[2] == '\x9E'); + TEST_CHECK(utf8.bytes[3] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x201E); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x20AC)); // "€" (Euro Sign) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 3); + TEST_CHECK(!guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(utf8.bytes[0] == '\xE2' && utf8.bytes[1] == '\x82' && utf8.bytes[2] == '\xAC'); + TEST_CHECK(utf8.bytes[3] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x20AC); + + TEST_CHECK(guf_utf8_encode(&utf8, 0xFC51)); // "ﱑ" (Arabic Ligature Heh with Jeem Isolated Form) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 3); + TEST_CHECK(!guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(utf8.bytes[0] == '\xEF' && utf8.bytes[1] == '\xB1' && utf8.bytes[2] == '\x91'); + TEST_CHECK(utf8.bytes[3] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0xFC51); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x1AA3)); // "᪣" (Tai Tham Sign Keow) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 3); + TEST_CHECK(!guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(utf8.bytes[0] == '\xE1' && utf8.bytes[1] == '\xAA' && utf8.bytes[2] == '\xA3'); + TEST_CHECK(utf8.bytes[3] == '\0'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x1AA3); + + TEST_CHECK(guf_utf8_encode(&utf8, GUF_UTF8_REPLACEMENT_CHAR_CODEPOINT)); // "�" (Replacement Character) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 3); + TEST_CHECK(utf8.bytes[0] == '\xEF' && utf8.bytes[1] == '\xBF' && utf8.bytes[2] == '\xBD'); + TEST_CHECK(utf8.bytes[3] == '\0'); + TEST_CHECK(guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(guf_utf8_decode(&utf8) == GUF_UTF8_REPLACEMENT_CHAR_CODEPOINT); + + // 4 byte characters: + TEST_CHECK(guf_utf8_encode(&utf8, 0x1F308)); // "🌈" (Rainbow) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 4); + TEST_CHECK(utf8.bytes[0] == '\xF0' && utf8.bytes[1] == '\x9F' && utf8.bytes[2] == '\x8C' && utf8.bytes[3] == '\x88'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x1F308); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x130B8)); // "𓂸" (Egyptian Hieroglyph D052) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 4); + TEST_CHECK(utf8.bytes[0] == '\xF0' && utf8.bytes[1] == '\x93' && utf8.bytes[2] == '\x82' && utf8.bytes[3] == '\xB8'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x130B8); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x1F97A)); // "🥺" (Face with Pleading Eyes) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 4); + TEST_CHECK(utf8.bytes[0] == '\xF0' && utf8.bytes[1] == '\x9F' && utf8.bytes[2] == '\xA5' && utf8.bytes[3] == '\xBA'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x1F97A); + + TEST_CHECK(guf_utf8_encode(&utf8, 0x1F980)); // "🦀" (Crab) + TEST_CHECK(guf_utf8_char_num_bytes(&utf8) == 4); + TEST_CHECK(utf8.bytes[0] == '\xF0' && utf8.bytes[1] == '\x9F' && utf8.bytes[2] == '\xA6' && utf8.bytes[3] == '\x80'); + TEST_CHECK(guf_utf8_decode(&utf8) == 0x1F980); + + // Invalid characters: + utf8 = {.bytes = {'\xC0', '\x80', 0, 0}}; + TEST_CHECK(guf_utf8_decode(&utf8) < 0); + + utf8 = {.bytes = {'\xC0', 0, 0, 0}}; + TEST_CHECK(guf_utf8_decode(&utf8) < 0); + + utf8 = {.bytes = {'\x80', 0, 0, 0}}; + TEST_CHECK(guf_utf8_decode(&utf8) < 0); + + // "The definition of UTF-8 prohibits encoding character numbers between U+D800 and U+DFFF" (surrogate pairs). + TEST_CHECK(!guf_utf8_encode(&utf8, 0xD800)); + TEST_CHECK(guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(guf_utf8_decode(&utf8) == GUF_UTF8_REPLACEMENT_CHAR_CODEPOINT); + + TEST_CHECK(!guf_utf8_encode(&utf8, 0xDFFF)); + TEST_CHECK(guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(guf_utf8_decode(&utf8) == GUF_UTF8_REPLACEMENT_CHAR_CODEPOINT); + + TEST_CHECK(!guf_utf8_encode(&utf8, 0xDA00)); + TEST_CHECK(guf_utf8_equal(&utf8, &GUF_UTF8_REPLACEMENT_CHAR)); + TEST_CHECK(guf_utf8_decode(&utf8) == GUF_UTF8_REPLACEMENT_CHAR_CODEPOINT); + + char buf[] = {'\x2F', '\xC0', '\xAE', '\x2E', '\x2F'}; + guf_str_view input_str = {.str = buf, .len = GUF_ARR_SIZE(buf)}; + guf_utf8_char ch = {}; + int valid_chars = 0, invalid_chars = 0; + for (guf_utf8_stat stat = guf_utf8_char_next(&ch, &input_str); stat != GUF_UTF8_READ_DONE; stat = guf_utf8_char_next(&ch, &input_str)) { + if (stat == GUF_UTF8_READ_VALID) { + ++valid_chars; + } else { + ++invalid_chars; + } + } + TEST_CHECK(invalid_chars == 2 && valid_chars == 3); + + char buf2[] = {'\xE0', '\x80', 'a', 'b', 'c'}; // 1 invalid 3-byte-character, 2 valid 1-byte-characters + input_str = {.str = buf2, .len = GUF_ARR_SIZE(buf2)}; + ch = {}; + valid_chars = invalid_chars = 0; + for (guf_utf8_stat stat = guf_utf8_char_next(&ch, &input_str); stat != GUF_UTF8_READ_DONE; stat = guf_utf8_char_next(&ch, &input_str)) { + if (stat == GUF_UTF8_READ_VALID) { + // printf("%s", ch.bytes); + ++valid_chars; + } else { + // printf("%s", GUF_UTF8_REPLACEMENT_CHAR.bytes); + ++invalid_chars; + } + } + TEST_CHECK(invalid_chars == 1 && valid_chars == 2); +} diff --git a/libguf/test/test_utf8.hpp b/libguf/test/test_utf8.hpp new file mode 100755 index 0000000..e6e6846 --- /dev/null +++ b/libguf/test/test_utf8.hpp @@ -0,0 +1,36 @@ +#pragma once +#include +#include "test.hpp" +extern "C" +{ + #include "impls/dbuf_impl.h" + #include "guf_alloc_libc.h" +} + +struct UTF8Test : public Test +{ + UTF8Test(const std::string& nm) : Test(nm) + { + allocator_ctx.zero_init = false; + guf_alloc_tracker_init(&allocator_ctx.tracker, 5, "UTF8Test_allocator", NULL, NULL); + guf_libc_allocator_init(&allocator, &allocator_ctx); + }; + + void run() override; + +private: + guf_allocator allocator; + guf_libc_alloc_ctx allocator_ctx; + + dbuf_char text_buf {}; + std::vector text_vec; + + bool load_text(const char *fname); + void free_text(); + + void read_utf8_chars(const char *fname, ptrdiff_t *n_valid, ptrdiff_t *n_invalid); + int count_words(const char *fname, const dbuf_str_view *delims); + int count_words_with_delims(const char *fname, const dbuf_str_view *delims); + void encode_decode_file(const char *fname); + void encode_decode(); +};