From 466982ffcbe2cb8e68869733c4213649b0a6e9f4 Mon Sep 17 00:00:00 2001 From: jun <83899451+zeichensystem@users.noreply.github.com> Date: Thu, 15 May 2025 09:11:31 +0200 Subject: [PATCH] Use better terminology for overflow and integer 'underflow' --- src/guf_math_ckdint.h | 452 +++++++++++++++++++-------------------- src/test/test_ckdint.cpp | 86 ++++---- tools/ckdint-gen.py | 66 +++--- 3 files changed, 301 insertions(+), 303 deletions(-) diff --git a/src/guf_math_ckdint.h b/src/guf_math_ckdint.h index a3849be..c7fb0cd 100644 --- a/src/guf_math_ckdint.h +++ b/src/guf_math_ckdint.h @@ -6,70 +6,68 @@ // Functions for safely checking for over- and underflow of arithmetic operations guf_math_ckd_result guf_ckd_add_TYPE(TYPE a, TYPE b); - - if a + b doesn't over/underflow TYPE: return GUF_MATH_CKD_SUCCESS (falsy) - - if a + b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (truthy) - - if a + b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (truthy) + - if a + b doesn't over/underflow TYPE: return GUF_MATH_CKD_SUCCESS (falsy) + - if a + b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (truthy) + - if a + b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (truthy) guf_math_ckd_result guf_ckd_sub_TYPE(TYPE a, TYPE b); - - if a - b doesn't over/underflow TYPE: return GUF_MATH_CKD_SUCCESS (falsy) - - if a - b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (truthy) - - if a - b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (truthy) + - if a - b doesn't over/underflow TYPE: return GUF_MATH_CKD_SUCCESS (falsy) + - if a - b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (truthy) + - if a - b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (truthy) guf_math_ckd_result guf_ckd_mul_TYPE(TYPE a, TYPE b); - - if a * b doesn't over/underflow TYPE: return GUF_MATH_CKD_SUCCESS (falsy) - - if a * b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (truthy) - - if a * b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (truthy) + - if a * b doesn't over/underflow TYPE: return GUF_MATH_CKD_SUCCESS (falsy) + - if a * b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (truthy) + - if a * b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (truthy) // Functions for safely computing arithmetic operations with saturating over- and underflow semantics // (cf. https://doc.rust-lang.org/std/intrinsics/fn.saturating_add.html (last-retrieved 2025-05-10)) guf_math_ckd_result guf_saturating_add_TYPE(TYPE a, TYPE b, TYPE *result); - - if a + b does not over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a + b) - - if a + b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (if result is not NULL, set result to TYPE_MAX, i.e. use saturating overflow semantics). - - if a + b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (if result is not NULL, set result to TYPE_MIN, i.e. use saturating underflow semantics). + - if a + b does not over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a + b) + - if a + b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (if result is not NULL, set result to TYPE_MAX, i.e. use saturating overflow semantics). + - if a + b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (if result is not NULL, set result to TYPE_MIN, i.e. use saturating underflow semantics). guf_math_ckd_result guf_saturating_sub_TYPE(TYPE a, TYPE b, TYPE *result); - - if a - b does not over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a - b) - - if a - b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (if result is not NULL, set result to TYPE_MAX, i.e. use saturating overflow semantics). - - if a - b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (if result is not NULL, set result to TYPE_MIN, i.e. use saturating underflow semantics). + - if a - b does not over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a - b) + - if a - b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (if result is not NULL, set result to TYPE_MAX, i.e. use saturating overflow semantics). + - if a - b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (if result is not NULL, set result to TYPE_MIN, i.e. use saturating underflow semantics). guf_math_ckd_result guf_saturating_mul_TYPE(TYPE a, TYPE b, TYPE *result); - - if a * b does not over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a * b) - - if a * b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (if result is not NULL, set result to TYPE_MAX, i.e. use saturating overflow semantics). - - if a * b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (if result is not NULL, set result to TYPE_MIN, i.e. use saturating underflow semantics). + - if a * b does not over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a * b) + - if a * b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (if result is not NULL, set result to TYPE_MAX, i.e. use saturating overflow semantics). + - if a * b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (if result is not NULL, set result to TYPE_MIN, i.e. use saturating underflow semantics). // Functions for safely computing arithmetic operations with wrapping over- and underflow semantics // (cf. https://doc.rust-lang.org/std/intrinsics/fn.wrapping_add.html (last-retrieved 2025-05-10)) guf_math_ckd_result guf_wrapping_add_TYPE(TYPE a, TYPE b, TYPE *result); - - if a + b does not over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a + b) - - if a + b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (if result is not NULL, set result using two's complement wrap-around overflow semantics). - - if a + b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (if result is not NULL, set result using two's complement wrap-around underflow semantics). + - if a + b does not over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a + b) + - if a + b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (if result is not NULL, set result using two's complement wrap-around overflow semantics). + - if a + b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (if result is not NULL, set result using two's complement wrap-around underflow semantics). guf_math_ckd_result guf_wrapping_sub_TYPE(TYPE a, TYPE b, TYPE *result); - - if a - b doesn't over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a - b) - - if a - b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (if result is not NULL, set result using two's complement wrap-around overflow semantics). - - if a - b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (if result is not NULL, set result using two's complement wrap-around underflow semantics). + - if a - b doesn't over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a - b) + - if a - b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (if result is not NULL, set result using two's complement wrap-around overflow semantics). + - if a - b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (if result is not NULL, set result using two's complement wrap-around underflow semantics). guf_math_ckd_result guf_wrapping_mul_TYPE(TYPE a, TYPE b, TYPE *result); // NOTE/TODO: guf_wrapping_mul_TYPE relies on implementation-defined unsigned-to-signed two's complement conversion on over/underflow // cf. https://stackoverflow.com/questions/76900522/can-you-ensure-overflow-wrapping-behavior-for-signed-integer-arithmetic-in-c (last-retrieved 2025-05-13) - - if a * b doesn't over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a * b) - - if a * b overflows TYPE: return GUF_MATH_CKD_OVERFLOW (if result is not NULL, set result using two's complement wrap-around overflow semantics). - - if a * b underflows TYPE: return GUF_MATH_CKD_UNDERFLOW (if result is not NULL, set result using two's complement wrap-around underflow semantics). + - if a * b doesn't over-/underflow TYPE: return GUF_MATH_CKD_SUCCESS (if result is not NULL, set result to a * b) + - if a * b overflows TYPE: return GUF_MATH_CKD_OVERFLOW_POS (if result is not NULL, set result using two's complement wrap-around overflow semantics). + - if a * b "underflows" TYPE: return GUF_MATH_CKD_OVERFLOW_NEG (if result is not NULL, set result using two's complement wrap-around underflow semantics). - cf. https://stackoverflow.com/questions/199333/how-do-i-detect-unsigned-integer-overflow (last-retrieved 2025-03-17) - cf. https://stackoverflow.com/questions/59307930/how-to-implement-wrapping-signed-int-addition-in-c (last-retrieved 2025-05-10) - cf. https://stackoverflow.com/questions/54318815/integer-overflow-w-multiplication-in-c (last-retrieved 2025-05-11) - cf. https://stackoverflow.com/questions/29808397/how-to-portably-find-out-minint-max-absint-min (last-retrieved 2025-05-11) + cf. https://stackoverflow.com/questions/199333/how-do-i-detect-unsigned-integer-overflow (last-retrieved 2025-03-17) + cf. https://stackoverflow.com/questions/59307930/how-to-implement-wrapping-signed-int-addition-in-c (last-retrieved 2025-05-10) + cf. https://stackoverflow.com/questions/54318815/integer-overflow-w-multiplication-in-c (last-retrieved 2025-05-11) + cf. https://stackoverflow.com/questions/29808397/how-to-portably-find-out-minint-max-absint-min (last-retrieved 2025-05-11) + cf. https://stackoverflow.com/questions/27001604/32-bit-unsigned-multiply-on-64-bit-causing-undefined-behavior (last-retrieved 2025-05-15) */ - - - #if defined(GUF_MATH_CKDINT_IMPL_STATIC) #define GUF_MATH_CKDINT_KWRDS static inline #else @@ -80,8 +78,7 @@ #define GUF_MATH_CKDINT_H #include "guf_common.h" -typedef enum guf_math_ckd_result {GUF_MATH_CKD_SUCCESS = 0, GUF_MATH_CKD_OVERFLOW, GUF_MATH_CKD_UNDERFLOW} guf_math_ckd_result; - +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) // Signed integer arithmetic checks (generated with libguf/tools/ckdint-gen.py) @@ -270,9 +267,9 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_size_t(size_t a, size GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_int(int a, int b) { if (b > 0 && a > INT_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b < 0 && a < INT_MIN - b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -280,9 +277,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) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b > 0 && a < INT_MIN + b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -291,19 +288,19 @@ 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; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { 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 : GUF_MATH_CKD_SUCCESS; + return a == INT_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT_MAX / b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -315,9 +312,9 @@ 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_i8(int8_t a, int8_t b) { if (b > 0 && a > INT8_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b < 0 && a < INT8_MIN - b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -325,9 +322,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) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b > 0 && a < INT8_MIN + b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -336,19 +333,19 @@ 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; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT8_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { 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 : GUF_MATH_CKD_SUCCESS; + return a == INT8_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT8_MAX / b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT8_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -360,9 +357,9 @@ 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_add_i16(int16_t a, int16_t b) { if (b > 0 && a > INT16_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b < 0 && a < INT16_MIN - b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -370,9 +367,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) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b > 0 && a < INT16_MIN + b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -381,19 +378,19 @@ 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; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT16_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { 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 : GUF_MATH_CKD_SUCCESS; + return a == INT16_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT16_MAX / b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT16_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -405,9 +402,9 @@ 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_add_i32(int32_t a, int32_t b) { if (b > 0 && a > INT32_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b < 0 && a < INT32_MIN - b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -415,9 +412,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) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b > 0 && a < INT32_MIN + b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -426,19 +423,19 @@ 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; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT32_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { 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 : GUF_MATH_CKD_SUCCESS; + return a == INT32_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT32_MAX / b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT32_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -450,9 +447,9 @@ 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_add_i64(int64_t a, int64_t b) { if (b > 0 && a > INT64_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b < 0 && a < INT64_MIN - b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -460,9 +457,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) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b > 0 && a < INT64_MIN + b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -471,19 +468,19 @@ 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; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < INT64_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { 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 : GUF_MATH_CKD_SUCCESS; + return a == INT64_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < INT64_MAX / b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > INT64_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -495,9 +492,9 @@ 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_add_ptrdiff_t(ptrdiff_t a, ptrdiff_t b) { if (b > 0 && a > PTRDIFF_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b < 0 && a < PTRDIFF_MIN - b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -505,9 +502,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) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (b > 0 && a < PTRDIFF_MIN + b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -516,19 +513,19 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ptrdiff_t(ptrdiff_t a, ptr { if (b > 0) { if (a > PTRDIFF_MAX / b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a < PTRDIFF_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { 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 : GUF_MATH_CKD_SUCCESS; + return a == PTRDIFF_MIN ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } else if (a < PTRDIFF_MAX / b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else if (a > PTRDIFF_MIN / b) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -542,7 +539,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_ptrdiff_t(ptrdiff_t a, ptr 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) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; } @@ -550,7 +547,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_uchar(unsigned char a, uns GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_uchar(unsigned char a, unsigned char b) { if (b > a) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -558,13 +555,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_uchar(unsigned char a, uns GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_uchar(unsigned char a, unsigned char b) { const unsigned char c = 1u * a * b; - return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW : GUF_MATH_CKD_SUCCESS; + 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_unsigned(unsigned a, unsigned b) { if (b > 0 && a > UINT_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; } @@ -572,7 +569,7 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_unsigned(unsigned a, unsig GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_unsigned(unsigned a, unsigned b) { if (b > a) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -580,13 +577,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_unsigned(unsigned a, unsig GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_unsigned(unsigned a, unsigned b) { const unsigned c = 1u * a * b; - return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW : GUF_MATH_CKD_SUCCESS; + 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_u8(uint8_t a, uint8_t b) { if (b > 0 && a > UINT8_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; } @@ -594,7 +591,7 @@ 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) { if (b > a) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -602,13 +599,13 @@ 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) { const uint8_t c = 1u * a * b; - return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW : GUF_MATH_CKD_SUCCESS; + 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_u16(uint16_t a, uint16_t b) { if (b > 0 && a > UINT16_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; } @@ -616,7 +613,7 @@ 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) { if (b > a) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -624,13 +621,13 @@ 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) { const uint16_t c = 1u * a * b; - return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW : GUF_MATH_CKD_SUCCESS; + 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_u32(uint32_t a, uint32_t b) { if (b > 0 && a > UINT32_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; } @@ -638,7 +635,7 @@ 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) { if (b > a) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -646,13 +643,13 @@ 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) { const uint32_t c = 1u * a * b; - return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW : GUF_MATH_CKD_SUCCESS; + 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_u64(uint64_t a, uint64_t b) { if (b > 0 && a > UINT64_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; } @@ -660,7 +657,7 @@ 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) { if (b > a) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -668,13 +665,13 @@ 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) { const uint64_t c = 1u * a * b; - return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW : GUF_MATH_CKD_SUCCESS; + 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_size_t(size_t a, size_t b) { if (b > 0 && a > SIZE_MAX - b) { - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; } else { return GUF_MATH_CKD_SUCCESS; } @@ -682,7 +679,7 @@ 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) { if (b > a) { - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; } else { return GUF_MATH_CKD_SUCCESS; } @@ -690,7 +687,7 @@ 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) { const size_t c = 1u * a * b; - return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW : GUF_MATH_CKD_SUCCESS; + return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; } @@ -704,10 +701,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_int(int a, int b, i case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT_MIN; break; default: @@ -724,10 +721,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_int(int a, int b, i case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT_MIN; break; default: @@ -744,10 +741,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_int(int a, int b, i case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT_MIN; break; default: @@ -765,10 +762,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_int(int a, int b, int case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = (a + INT_MIN) + (b + INT_MIN); break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = (a - INT_MIN) + (b - INT_MIN); break; default: @@ -785,11 +782,11 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_int(int a, int b, int case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); *result = (a + INT_MIN) - (b - INT_MIN); // TODO: not sure break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); *result = (a - INT_MIN) - (b + INT_MIN); // TODO: not sure break; @@ -807,8 +804,8 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_int(int a, int b, int case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: - case GUF_MATH_CKD_UNDERFLOW: { + case GUF_MATH_CKD_OVERFLOW_POS: + case GUF_MATH_CKD_OVERFLOW_NEG: { unsigned res = 1u * (unsigned)a * (unsigned)b; if (res > INT_MAX) { // This is the fix for implementation defined conversion from unsigned to signed. const unsigned mod = (1u * (unsigned)INT_MAX + 1u); @@ -836,10 +833,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i8(int8_t a, int8_t case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT8_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT8_MIN; break; default: @@ -856,10 +853,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i8(int8_t a, int8_t case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT8_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT8_MIN; break; default: @@ -876,10 +873,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i8(int8_t a, int8_t case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT8_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT8_MIN; break; default: @@ -897,10 +894,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i8(int8_t a, int8_t b case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = (a + INT8_MIN) + (b + INT8_MIN); break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = (a - INT8_MIN) + (b - INT8_MIN); break; default: @@ -917,11 +914,11 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i8(int8_t a, int8_t b case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); *result = (a + INT8_MIN) - (b - INT8_MIN); // TODO: not sure break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); *result = (a - INT8_MIN) - (b + INT8_MIN); // TODO: not sure break; @@ -939,8 +936,8 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i8(int8_t a, int8_t b case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: - case GUF_MATH_CKD_UNDERFLOW: { + case GUF_MATH_CKD_OVERFLOW_POS: + case GUF_MATH_CKD_OVERFLOW_NEG: { uint8_t res = 1u * (uint8_t)a * (uint8_t)b; if (res > INT8_MAX) { // This is the fix for implementation defined conversion from unsigned to signed. const uint8_t mod = (1u * (uint8_t)INT8_MAX + 1u); @@ -968,10 +965,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i16(int16_t a, int1 case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT16_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT16_MIN; break; default: @@ -988,10 +985,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i16(int16_t a, int1 case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT16_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT16_MIN; break; default: @@ -1008,10 +1005,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i16(int16_t a, int1 case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT16_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT16_MIN; break; default: @@ -1029,10 +1026,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i16(int16_t a, int16_ case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = (a + INT16_MIN) + (b + INT16_MIN); break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = (a - INT16_MIN) + (b - INT16_MIN); break; default: @@ -1049,11 +1046,11 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i16(int16_t a, int16_ case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); *result = (a + INT16_MIN) - (b - INT16_MIN); // TODO: not sure break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); *result = (a - INT16_MIN) - (b + INT16_MIN); // TODO: not sure break; @@ -1071,8 +1068,8 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i16(int16_t a, int16_ case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: - case GUF_MATH_CKD_UNDERFLOW: { + case GUF_MATH_CKD_OVERFLOW_POS: + case GUF_MATH_CKD_OVERFLOW_NEG: { uint16_t res = 1u * (uint16_t)a * (uint16_t)b; if (res > INT16_MAX) { // This is the fix for implementation defined conversion from unsigned to signed. const uint16_t mod = (1u * (uint16_t)INT16_MAX + 1u); @@ -1100,10 +1097,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i32(int32_t a, int3 case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT32_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT32_MIN; break; default: @@ -1120,10 +1117,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i32(int32_t a, int3 case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT32_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT32_MIN; break; default: @@ -1140,10 +1137,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i32(int32_t a, int3 case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT32_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT32_MIN; break; default: @@ -1161,10 +1158,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i32(int32_t a, int32_ case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = (a + INT32_MIN) + (b + INT32_MIN); break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = (a - INT32_MIN) + (b - INT32_MIN); break; default: @@ -1181,11 +1178,11 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i32(int32_t a, int32_ case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); *result = (a + INT32_MIN) - (b - INT32_MIN); // TODO: not sure break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); *result = (a - INT32_MIN) - (b + INT32_MIN); // TODO: not sure break; @@ -1203,8 +1200,8 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i32(int32_t a, int32_ case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: - case GUF_MATH_CKD_UNDERFLOW: { + case GUF_MATH_CKD_OVERFLOW_POS: + case GUF_MATH_CKD_OVERFLOW_NEG: { uint32_t res = 1u * (uint32_t)a * (uint32_t)b; if (res > INT32_MAX) { // This is the fix for implementation defined conversion from unsigned to signed. const uint32_t mod = (1u * (uint32_t)INT32_MAX + 1u); @@ -1232,10 +1229,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_i64(int64_t a, int6 case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT64_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT64_MIN; break; default: @@ -1252,10 +1249,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_i64(int64_t a, int6 case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT64_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT64_MIN; break; default: @@ -1272,10 +1269,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_i64(int64_t a, int6 case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = INT64_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = INT64_MIN; break; default: @@ -1293,10 +1290,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_i64(int64_t a, int64_ case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = (a + INT64_MIN) + (b + INT64_MIN); break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = (a - INT64_MIN) + (b - INT64_MIN); break; default: @@ -1313,11 +1310,11 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_i64(int64_t a, int64_ case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); *result = (a + INT64_MIN) - (b - INT64_MIN); // TODO: not sure break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); *result = (a - INT64_MIN) - (b + INT64_MIN); // TODO: not sure break; @@ -1335,8 +1332,8 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_i64(int64_t a, int64_ case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: - case GUF_MATH_CKD_UNDERFLOW: { + case GUF_MATH_CKD_OVERFLOW_POS: + case GUF_MATH_CKD_OVERFLOW_NEG: { uint64_t res = 1u * (uint64_t)a * (uint64_t)b; if (res > INT64_MAX) { // This is the fix for implementation defined conversion from unsigned to signed. const uint64_t mod = (1u * (uint64_t)INT64_MAX + 1u); @@ -1364,10 +1361,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_ptrdiff_t(ptrdiff_t case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = PTRDIFF_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = PTRDIFF_MIN; break; default: @@ -1384,10 +1381,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_ptrdiff_t(ptrdiff_t case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = PTRDIFF_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = PTRDIFF_MIN; break; default: @@ -1404,10 +1401,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_ptrdiff_t(ptrdiff_t case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = PTRDIFF_MAX; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = PTRDIFF_MIN; break; default: @@ -1425,10 +1422,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_add_ptrdiff_t(ptrdiff_t a case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = (a + PTRDIFF_MIN) + (b + PTRDIFF_MIN); break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = (a - PTRDIFF_MIN) + (b - PTRDIFF_MIN); break; default: @@ -1445,11 +1442,11 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_sub_ptrdiff_t(ptrdiff_t a case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); *result = (a + PTRDIFF_MIN) - (b - PTRDIFF_MIN); // TODO: not sure break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); *result = (a - PTRDIFF_MIN) - (b + PTRDIFF_MIN); // TODO: not sure break; @@ -1467,8 +1464,8 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ptrdiff_t(ptrdiff_t a case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: - case GUF_MATH_CKD_UNDERFLOW: { + case GUF_MATH_CKD_OVERFLOW_POS: + case GUF_MATH_CKD_OVERFLOW_NEG: { size_t res = 1u * (size_t)a * (size_t)b; if (res > PTRDIFF_MAX) { // This is the fix for implementation defined conversion from unsigned to signed. const size_t mod = (1u * (size_t)PTRDIFF_MAX + 1u); @@ -1493,13 +1490,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_ptrdiff_t(ptrdiff_t a 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UCHAR_MAX; break; default: @@ -1511,13 +1508,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_UNDERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = 0; break; default: @@ -1529,13 +1526,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UCHAR_MAX; break; default: @@ -1574,13 +1571,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_uchar(unsigned char a 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT_MAX; break; default: @@ -1592,13 +1589,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_UNDERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = 0; break; default: @@ -1610,13 +1607,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT_MAX; break; default: @@ -1655,13 +1652,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_unsigned(unsigned a, 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT8_MAX; break; default: @@ -1673,13 +1670,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_UNDERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = 0; break; default: @@ -1691,13 +1688,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT8_MAX; break; default: @@ -1736,13 +1733,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u8(uint8_t a, uint8_t 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT16_MAX; break; default: @@ -1754,13 +1751,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_UNDERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = 0; break; default: @@ -1772,13 +1769,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT16_MAX; break; default: @@ -1817,13 +1814,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u16(uint16_t a, uint1 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT32_MAX; break; default: @@ -1835,13 +1832,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_UNDERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = 0; break; default: @@ -1853,13 +1850,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT32_MAX; break; default: @@ -1898,13 +1895,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u32(uint32_t a, uint3 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT64_MAX; break; default: @@ -1916,13 +1913,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_UNDERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = 0; break; default: @@ -1934,13 +1931,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = UINT64_MAX; break; default: @@ -1979,13 +1976,13 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_u64(uint64_t a, uint6 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = SIZE_MAX; break; default: @@ -1997,13 +1994,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_UNDERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = 0; break; default: @@ -2015,13 +2012,13 @@ 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); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) { switch (check) { case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = SIZE_MAX; break; default: @@ -2057,9 +2054,10 @@ GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_wrapping_mul_size_t(size_t a, size } -#endif +#endif /* End impl */ + +#endif /* End header-guard */ -#endif #undef GUF_MATH_CKDINT_KWRDS #undef GUF_MATH_CKDINT_IMPL #undef GUF_MATH_CKDINT_IMPL_STATIC diff --git a/src/test/test_ckdint.cpp b/src/test/test_ckdint.cpp index 0ee139f..b10d157 100644 --- a/src/test/test_ckdint.cpp +++ b/src/test/test_ckdint.cpp @@ -28,31 +28,31 @@ void CkdIntTest::test_ckd() const guf_math_ckd_result ckd_add = guf_ckd_add_i8((int8_t)a, (int8_t)b); TEST_CHECK(ckd_add == guf_ckd_add_i8((int8_t)b, (int8_t)a)); if (add_res > INT8_MAX) { - TEST_CHECK(ckd_add == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(ckd_add == GUF_MATH_CKD_OVERFLOW_POS); int8_t saturated, saturated2; - TEST_CHECK(guf_saturating_add_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_add_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(saturated == INT8_MAX); - TEST_CHECK(guf_saturating_add_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_add_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(saturated == saturated2); int8_t wrapped, wrapped2; - TEST_CHECK(guf_wrapping_add_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_add_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(static_cast(wrapped) == INT8_MIN + (add_res % (INT8_MAX + 1))); - TEST_CHECK(guf_wrapping_add_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_add_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(wrapped == wrapped2); } else if (add_res < INT8_MIN) { - TEST_CHECK(ckd_add == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(ckd_add == GUF_MATH_CKD_OVERFLOW_NEG); int8_t saturated, saturated2; - TEST_CHECK(guf_saturating_add_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_saturating_add_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(saturated == INT8_MIN); - TEST_CHECK(guf_saturating_add_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_saturating_add_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(saturated == saturated2); int8_t wrapped, wrapped2; - TEST_CHECK(guf_wrapping_add_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_wrapping_add_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(static_cast(wrapped) == INT8_MAX - (-add_res % (-INT8_MIN + 1))); - TEST_CHECK(guf_wrapping_add_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_wrapping_add_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(wrapped == wrapped2); } else { @@ -73,20 +73,20 @@ void CkdIntTest::test_ckd() const int32_t sub_res = a - b; const guf_math_ckd_result ckd_sub = guf_ckd_sub_i8((int8_t)a, (int8_t)b); if (sub_res > INT8_MAX) { - TEST_CHECK(ckd_sub == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(ckd_sub == GUF_MATH_CKD_OVERFLOW_POS); int8_t saturated; - TEST_CHECK(guf_saturating_sub_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_sub_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(saturated == INT8_MAX); int8_t wrapped; - TEST_CHECK(guf_wrapping_sub_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_sub_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(static_cast(wrapped) == INT8_MIN + (sub_res % (INT8_MAX + 1))); } else if (sub_res < INT8_MIN) { - TEST_CHECK(ckd_sub == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(ckd_sub == GUF_MATH_CKD_OVERFLOW_NEG); int8_t saturated; - TEST_CHECK(guf_saturating_sub_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_saturating_sub_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(saturated == INT8_MIN); int8_t wrapped; - TEST_CHECK(guf_wrapping_sub_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_wrapping_sub_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(static_cast(wrapped) == INT8_MAX - (-sub_res % (-INT8_MIN + 1))); } else { TEST_CHECK(ckd_sub == GUF_MATH_CKD_SUCCESS); @@ -102,31 +102,31 @@ void CkdIntTest::test_ckd() const guf_math_ckd_result ckd_mul = guf_ckd_mul_i8((int8_t)a, (int8_t)b); TEST_CHECK(ckd_mul == guf_ckd_mul_i8((int8_t)b, (int8_t)a)); if (mul_res > INT8_MAX) { - TEST_CHECK(ckd_mul == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(ckd_mul == GUF_MATH_CKD_OVERFLOW_POS); int8_t saturated, saturated2; - TEST_CHECK(guf_saturating_mul_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_mul_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(saturated == INT8_MAX); - TEST_CHECK(guf_saturating_mul_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_mul_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(saturated == saturated2); int8_t wrapped, wrapped2; - TEST_CHECK(guf_wrapping_mul_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW); - TEST_CHECK(guf_wrapping_mul_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_mul_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); + TEST_CHECK(guf_wrapping_mul_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(wrapped == wrapped2); // TODO: check wrapped } else if (mul_res < INT8_MIN) { - TEST_CHECK(ckd_mul == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(ckd_mul == GUF_MATH_CKD_OVERFLOW_NEG); int8_t saturated, saturated2; - TEST_CHECK(guf_saturating_mul_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_saturating_mul_i8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(saturated == INT8_MIN); - TEST_CHECK(guf_saturating_mul_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_saturating_mul_i8(static_cast(b), static_cast(a), &saturated2) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(saturated == saturated2); int8_t wrapped, wrapped2; - TEST_CHECK(guf_wrapping_mul_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_UNDERFLOW); - TEST_CHECK(guf_wrapping_mul_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_wrapping_mul_i8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_NEG); + TEST_CHECK(guf_wrapping_mul_i8(static_cast(b), static_cast(a), &wrapped2) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(wrapped == wrapped2); // TODO: check wrapped } else { @@ -148,10 +148,10 @@ void CkdIntTest::test_ckd() } int8_t mul_i8_res = -1; - TEST_CHECK(guf_wrapping_mul_i8(42, 5, &mul_i8_res) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_mul_i8(42, 5, &mul_i8_res) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(mul_i8_res == -46); mul_i8_res = -1; - TEST_CHECK(guf_wrapping_mul_i8(5, 42, &mul_i8_res) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_mul_i8(5, 42, &mul_i8_res) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(mul_i8_res == -46); /* @@ -167,10 +167,10 @@ void CkdIntTest::test_ckd() */ int32_t mul_i32_res = -1; - TEST_CHECK(guf_wrapping_mul_i32(42002718, 314159265, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_mul_i32(42002718, 314159265, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(mul_i32_res == -972735522); mul_i32_res = -1; - TEST_CHECK(guf_wrapping_mul_i32(314159265, 42002718, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_mul_i32(314159265, 42002718, &mul_i32_res) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(mul_i32_res == -972735522); mul_i32_res = 12345; @@ -202,14 +202,14 @@ void CkdIntTest::test_ckd() TEST_CHECK(mul_i32_res == 1693839360); ptrdiff_t ptrdiff_res = -1234; - TEST_CHECK(guf_saturating_add_ptrdiff_t(PTRDIFF_MAX, 1, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_add_ptrdiff_t(PTRDIFF_MAX, 1, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(ptrdiff_res == PTRDIFF_MAX); - TEST_CHECK(guf_saturating_add_ptrdiff_t(PTRDIFF_MIN, -1, &ptrdiff_res) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_saturating_add_ptrdiff_t(PTRDIFF_MIN, -1, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(ptrdiff_res == PTRDIFF_MIN); - TEST_CHECK(guf_saturating_mul_ptrdiff_t(PTRDIFF_MAX, 2, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_mul_ptrdiff_t(PTRDIFF_MAX, 2, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(ptrdiff_res == PTRDIFF_MAX); - TEST_CHECK(guf_saturating_mul_ptrdiff_t(PTRDIFF_MIN, 2, &ptrdiff_res) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_saturating_mul_ptrdiff_t(PTRDIFF_MIN, 2, &ptrdiff_res) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(ptrdiff_res == PTRDIFF_MIN); } @@ -220,12 +220,12 @@ void CkdIntTest::test_ckd_uint() const int32_t add_res = a + b; const guf_math_ckd_result ckd_add = guf_ckd_add_u8((uint8_t)a, (uint8_t)b); if (add_res > UINT8_MAX) { - TEST_CHECK(ckd_add == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(ckd_add == GUF_MATH_CKD_OVERFLOW_POS); uint8_t saturated; - TEST_CHECK(guf_saturating_add_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_add_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(saturated == UINT8_MAX); uint8_t wrapped; - TEST_CHECK(guf_wrapping_add_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_add_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(static_cast(wrapped) == 0 + (add_res % (UINT8_MAX + 1))); } else { @@ -241,12 +241,12 @@ void CkdIntTest::test_ckd_uint() const int32_t sub_res = a - b; const guf_math_ckd_result ckd_sub = guf_ckd_sub_u8((uint8_t)a, (uint8_t)b); if (sub_res < 0) { - TEST_CHECK(ckd_sub == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(ckd_sub == GUF_MATH_CKD_OVERFLOW_NEG); uint8_t saturated; - TEST_CHECK(guf_saturating_sub_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_saturating_sub_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(saturated == 0); uint8_t wrapped; - TEST_CHECK(guf_wrapping_sub_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_UNDERFLOW); + TEST_CHECK(guf_wrapping_sub_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_NEG); TEST_CHECK(wrapped == static_cast(static_cast(a) - static_cast(b))); } else { TEST_CHECK(ckd_sub == GUF_MATH_CKD_SUCCESS); @@ -261,12 +261,12 @@ void CkdIntTest::test_ckd_uint() const int32_t mul_res = a * b; const guf_math_ckd_result ckd_mul = guf_ckd_mul_u8((uint8_t)a, (uint8_t)b); if (mul_res > UINT8_MAX) { - TEST_CHECK(ckd_mul == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(ckd_mul == GUF_MATH_CKD_OVERFLOW_POS); uint8_t saturated; - TEST_CHECK(guf_saturating_mul_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_saturating_mul_u8(static_cast(a), static_cast(b), &saturated) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(saturated == UINT8_MAX); uint8_t wrapped; - TEST_CHECK(guf_wrapping_mul_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW); + TEST_CHECK(guf_wrapping_mul_u8(static_cast(a), static_cast(b), &wrapped) == GUF_MATH_CKD_OVERFLOW_POS); TEST_CHECK(wrapped == static_cast(static_cast(a) * static_cast(b))); } else { TEST_CHECK(ckd_mul == GUF_MATH_CKD_SUCCESS); diff --git a/tools/ckdint-gen.py b/tools/ckdint-gen.py index de200d7..3355739 100644 --- a/tools/ckdint-gen.py +++ b/tools/ckdint-gen.py @@ -32,7 +32,7 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_{type_abbr}({type} a, {type} b) {{ if (b > 0 && a > {int_max} - b) {{ - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; }} else {{ return GUF_MATH_CKD_SUCCESS; }} @@ -40,7 +40,7 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_{type_abbr}({type} a, {type} b) {{ if (b > a) {{ - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; }} else {{ return GUF_MATH_CKD_SUCCESS; }} @@ -48,7 +48,7 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_mul_{type_abbr}({type} a, {type} b) {{ const {type} c = 1u * a * b; - return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW : GUF_MATH_CKD_SUCCESS; + return a != 0 && ((1u * c / a) != b) ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; }} """) @@ -62,9 +62,9 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_add_{type_abbr}({type} a, {type} b) {{ if (b > 0 && a > {int_max} - b) {{ - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; }} else if (b < 0 && a < {int_min} - b) {{ - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; }} else {{ return GUF_MATH_CKD_SUCCESS; }} @@ -72,9 +72,9 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_ckd_sub_{type_abbr}({type} a, {type} b) {{ if (b < 0 && a > {int_max} + b) {{ - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; }} else if (b > 0 && a < {int_min} + b) {{ - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; }} else {{ return GUF_MATH_CKD_SUCCESS; }} @@ -83,19 +83,19 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s {{ if (b > 0) {{ if (a > {int_max} / b) {{ - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; }} else if (a < {int_min} / b) {{ - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; }} else {{ 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 : GUF_MATH_CKD_SUCCESS; + return a == {int_min} ? GUF_MATH_CKD_OVERFLOW_POS : GUF_MATH_CKD_SUCCESS; }} else if (a < {int_max} / b) {{ - return GUF_MATH_CKD_OVERFLOW; + return GUF_MATH_CKD_OVERFLOW_POS; }} else if (a > {int_min} / b) {{ - return GUF_MATH_CKD_UNDERFLOW; + return GUF_MATH_CKD_OVERFLOW_NEG; }} else {{ return GUF_MATH_CKD_SUCCESS; }} @@ -125,10 +125,10 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = {int_max}; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = {int_min}; break; default: @@ -145,10 +145,10 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = {int_max}; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = {int_min}; break; default: @@ -165,10 +165,10 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = {int_max}; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = {int_min}; break; default: @@ -186,10 +186,10 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = (a + {int_min}) + (b + {int_min}); break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = (a - {int_min}) + (b - {int_min}); break; default: @@ -206,11 +206,11 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: GUF_ASSERT(b < 0); *result = (a + {int_min}) - (b - {int_min}); // TODO: not sure break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: GUF_ASSERT(b > 0); *result = (a - {int_min}) - (b + {int_min}); // TODO: not sure break; @@ -228,8 +228,8 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: - case GUF_MATH_CKD_UNDERFLOW: {{ + case GUF_MATH_CKD_OVERFLOW_POS: + case GUF_MATH_CKD_OVERFLOW_NEG: {{ {uint_type} res = 1u * ({uint_type})a * ({uint_type})b; if (res > {int_max}) {{ // This is the fix for implementation defined conversion from unsigned to signed. const {uint_type} mod = (1u * ({uint_type}){int_max} + 1u); @@ -263,13 +263,13 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_add_{type_abbr}({type} a, {type} b, {type} *result) {{ const guf_math_ckd_result check = guf_ckd_add_{type_abbr}(a, b); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) {{ switch (check) {{ case GUF_MATH_CKD_SUCCESS: *result = a + b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = {int_max}; break; default: @@ -281,13 +281,13 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_sub_{type_abbr}({type} a, {type} b, {type} *result) {{ const guf_math_ckd_result check = guf_ckd_sub_{type_abbr}(a, b); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_UNDERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_NEG); if (result) {{ switch (check) {{ case GUF_MATH_CKD_SUCCESS: *result = a - b; break; - case GUF_MATH_CKD_UNDERFLOW: + case GUF_MATH_CKD_OVERFLOW_NEG: *result = 0; break; default: @@ -299,13 +299,13 @@ def generate_ckdint_functions(int_types: list, uint_types: list) -> Tuple[str, s GUF_MATH_CKDINT_KWRDS guf_math_ckd_result guf_saturating_mul_{type_abbr}({type} a, {type} b, {type} *result) {{ const guf_math_ckd_result check = guf_ckd_mul_{type_abbr}(a, b); - GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW); + GUF_ASSERT(check == GUF_MATH_CKD_SUCCESS || check == GUF_MATH_CKD_OVERFLOW_POS); if (result) {{ switch (check) {{ case GUF_MATH_CKD_SUCCESS: *result = a * b; break; - case GUF_MATH_CKD_OVERFLOW: + case GUF_MATH_CKD_OVERFLOW_POS: *result = {int_max}; break; default: @@ -404,7 +404,7 @@ if __name__ == "__main__": #define GUF_MATH_CKDINT_H #include "guf_common.h" - typedef enum guf_math_ckd_result {GUF_MATH_CKD_SUCCESS = 0, GUF_MATH_CKD_OVERFLOW, GUF_MATH_CKD_UNDERFLOW} guf_math_ckd_result; + 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; """)) @@ -416,9 +416,9 @@ if __name__ == "__main__": print("#if defined(GUF_MATH_CKDINT_IMPL) || defined(GUF_MATH_CKDINT_IMPL_STATIC)") print('#include "guf_assert.h"') print(code_impl) - print("#endif\n") + print("#endif /* End impl */\n") - print("#endif") + print("#endif /* End header-guard */\n") print("#undef GUF_MATH_CKDINT_KWRDS") print("#undef GUF_MATH_CKDINT_IMPL")