From 2f50db1858d9a5008d7fe9f73e071dcd38973d19 Mon Sep 17 00:00:00 2001 From: zeichensystem <83899451+zeichensystem@users.noreply.github.com> Date: Sun, 21 Dec 2025 19:51:42 +0100 Subject: [PATCH] Fix more GCC warnings --- CMakeLists.txt | 2 +- src/guf_alloc_libc.h | 3 +- src/guf_dict.h | 4 +- src/guf_math.h | 8 +- src/guf_math_ckdint.h | 947 ++++++++++++++++++++------------------- src/guf_rand.h | 14 +- src/guf_str.h | 4 +- src/guf_utf8.h | 10 +- src/test/example.c | 2 +- src/test/test_ckdint.hpp | 2 +- src/test/test_dbuf.cpp | 6 +- src/test/test_dbuf.hpp | 6 +- src/test/test_dict.hpp | 2 +- src/test/test_str.hpp | 2 +- src/test/test_utf8.hpp | 2 +- tools/ckdint-gen.py | 10 +- 16 files changed, 512 insertions(+), 512 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f989e9d..348cc67 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -18,7 +18,7 @@ if (NOT DEFINED CMAKE_DEBUG_POSTFIX) endif () if (NOT DEFINED MSVC) - set(WARNING_FLAGS_C -Wall -Wextra -Wpedantic -Wvla -Wshadow -Wundef -Wmisleading-indentation -Wnull-dereference -Wswitch-default -Wstrict-overflow=5 -Wconversion -Wno-sign-conversion -Wsign-promo -Wcast-align -Wcast-qual -Wdouble-promotion -Wformat=2 -Winit-self -Wdisabled-optimization -Wno-unused-function) + set(WARNING_FLAGS_C -Wall -Wextra -Wpedantic -Wvla -Wshadow -Wundef -Wmisleading-indentation -Wnull-dereference -Wswitch-default -Wstrict-overflow=5 -Wconversion -Wno-sign-conversion -Wcast-align -Wcast-qual -Wdouble-promotion -Wformat=2 -Winit-self -Wdisabled-optimization -Wno-unused-function) set(WARNING_FLAGS_CXX -Wall -Wextra -Wpedantic -Wvla -Wshadow -Wundef -Wmisleading-indentation -Wnull-dereference -Wswitch-default -Wstrict-overflow=5 -Wconversion -Wno-sign-conversion -Wsign-promo -Wcast-align -Wcast-qual -Wdouble-promotion -Wformat=2 -Winit-self -Wdisabled-optimization -Woverloaded-virtual -Wredundant-decls -Wctor-dtor-privacy -Wno-unused-function) set(DBG_FLAGS -fsanitize=undefined,address -g3 -Og) else () diff --git a/src/guf_alloc_libc.h b/src/guf_alloc_libc.h index 2adb63c..b8a5f7c 100755 --- a/src/guf_alloc_libc.h +++ b/src/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/src/guf_dict.h b/src/guf_dict.h index 37308fe..7e27dd5 100755 --- a/src/guf_dict.h +++ b/src/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/src/guf_math.h b/src/guf_math.h index 44f3896..4863bca 100755 --- a/src/guf_math.h +++ b/src/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/src/guf_math_ckdint.h b/src/guf_math_ckdint.h index d5aa5e9..61db381 100755 --- a/src/guf_math_ckdint.h +++ b/src/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/src/guf_rand.h b/src/guf_rand.h index 867a4a4..0d5d4b9 100755 --- a/src/guf_rand.h +++ b/src/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/src/guf_str.h b/src/guf_str.h index 703c599..84ff870 100755 --- a/src/guf_str.h +++ b/src/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{.data = {0}, .allocator = 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/src/guf_utf8.h b/src/guf_utf8.h index eb6253b..22f969f 100755 --- a/src/guf_utf8.h +++ b/src/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/src/test/example.c b/src/test/example.c index c4a98c9..6fa37b0 100755 --- a/src/test/example.c +++ b/src/test/example.c @@ -113,7 +113,7 @@ int main(void) floats = dbuf_float_new(&allocator); for (int i = 0; i <= 16; ++i) { - dbuf_float_push_val(&floats, i % 2 ? i * -2.f : i * 2.f); + 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); diff --git a/src/test/test_ckdint.hpp b/src/test/test_ckdint.hpp index 0f45f9b..986689d 100755 --- a/src/test/test_ckdint.hpp +++ b/src/test/test_ckdint.hpp @@ -3,7 +3,7 @@ struct CkdIntTest : public Test { - CkdIntTest(const std::string& name) : Test(name) {}; + CkdIntTest(const std::string& nm) : Test(nm) {}; void run() override; private: diff --git a/src/test/test_dbuf.cpp b/src/test/test_dbuf.cpp index d3b8646..9ac1870 100755 --- a/src/test/test_dbuf.cpp +++ b/src/test/test_dbuf.cpp @@ -581,7 +581,7 @@ void DbufStrTest::test_push_insert_erase(size_t n, ptrdiff_t start_cap) 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 += c % 10 + '0'; + 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}; @@ -642,7 +642,7 @@ void DbufStrTest::test_push_insert_erase(size_t n, ptrdiff_t start_cap) std::string str; for (size_t c = 0; c < 512 + GUF_STR_SSO_BUF_CAP; ++c) { - str += c % 10 + '0'; + 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}; @@ -682,4 +682,4 @@ void DbufStrTest::test_push_insert_erase(size_t n, ptrdiff_t start_cap) dbuf_str_free(&strings, NULL); TEST_CHECK(!guf_alloc_tracker_found_leak(&str_allocator_ctx.tracker)); -} \ No newline at end of file +} diff --git a/src/test/test_dbuf.hpp b/src/test/test_dbuf.hpp index 832d88a..3cef1fd 100755 --- a/src/test/test_dbuf.hpp +++ b/src/test/test_dbuf.hpp @@ -10,7 +10,7 @@ extern "C" struct DbufIntTest : public Test { - DbufIntTest(const std::string& name) : Test(name) + DbufIntTest(const std::string& nm) : Test(nm) { allocator_ctx.zero_init = false; guf_alloc_tracker_init(&allocator_ctx.tracker, 1, "DbufIntTest_allocator", NULL, NULL); @@ -31,7 +31,7 @@ private: struct DbufCstringTest : public Test { - DbufCstringTest(std::string name) : Test(name) + DbufCstringTest(std::string nm) : Test(nm) { allocator_ctx.zero_init = false; guf_alloc_tracker_init(&allocator_ctx.tracker, 2, "DbufCstringTest_allocator", NULL, NULL); @@ -52,7 +52,7 @@ private: struct DbufStrTest : public Test { - DbufStrTest(std::string name) : Test(name) + DbufStrTest(std::string nm) : Test(nm) { allocator_ctx.zero_init = false; guf_alloc_tracker_init(&allocator_ctx.tracker, 3, "DbufStrTest_allocator", NULL, NULL); diff --git a/src/test/test_dict.hpp b/src/test/test_dict.hpp index 5762fe1..da51229 100755 --- a/src/test/test_dict.hpp +++ b/src/test/test_dict.hpp @@ -12,7 +12,7 @@ extern "C" struct DictSvToIntTest : public Test { - DictSvToIntTest(const std::string& name) : Test(name) + DictSvToIntTest(const std::string& nm) : Test(nm) { allocator_ctx.zero_init = false; guf_alloc_tracker_init(&allocator_ctx.tracker, 3, "DictSvToIntTest_allocator", NULL, NULL); diff --git a/src/test/test_str.hpp b/src/test/test_str.hpp index b24bd44..6153700 100755 --- a/src/test/test_str.hpp +++ b/src/test/test_str.hpp @@ -11,7 +11,7 @@ extern "C" struct StrTest : public Test { - StrTest(const std::string& name) : Test(name) + StrTest(const std::string& nm) : Test(nm) { allocator_ctx.zero_init = false; guf_alloc_tracker_init(&allocator_ctx.tracker, 4, "StrTest_allocator", NULL, NULL); diff --git a/src/test/test_utf8.hpp b/src/test/test_utf8.hpp index b582a87..e6e6846 100755 --- a/src/test/test_utf8.hpp +++ b/src/test/test_utf8.hpp @@ -9,7 +9,7 @@ extern "C" struct UTF8Test : public Test { - UTF8Test(const std::string& name) : Test(name) + UTF8Test(const std::string& nm) : Test(nm) { allocator_ctx.zero_init = false; guf_alloc_tracker_init(&allocator_ctx.tracker, 5, "UTF8Test_allocator", NULL, NULL); diff --git a/tools/ckdint-gen.py b/tools/ckdint-gen.py index c68b594..6d53d17 100755 --- a/tools/ckdint-gen.py +++ b/tools/ckdint-gen.py @@ -223,10 +223,10 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s *result = a + b; break; case GUF_MATH_CKD_OVERFLOW_POS: - *result = (a + {int_min}) + (b + {int_min}); + *result = ({type})( (a + ({type}){int_min}) + (b + ({type}){int_min}) ); break; case GUF_MATH_CKD_OVERFLOW_NEG: - *result = (a - {int_min}) + (b - {int_min}); + *result = ({type})( (a - ({type}){int_min}) + (b - ({type}){int_min}) ); break; default: GUF_ASSERT(false); @@ -244,11 +244,11 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s break; case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); - *result = (a + {int_min}) - (b - {int_min}); // TODO: not sure + *result = ({type})( (a + ({type}){int_min}) - (b - ({type}){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 = ({type})( (a - ({type}){int_min}) - (b + ({type}){int_min}) ); // TODO: not sure break; default: GUF_ASSERT(false); @@ -271,7 +271,7 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s const {uint_type} mod = ({uint_type}){int_max} + 1u; GUF_ASSERT(mod > 0); res = 1u * res % mod; - *result = {int_min} + ({type})res; + *result = ({type}){int_min} + ({type})res; }} else {{ *result = ({type})res; }}