address review comments by coderabbit

Signed-off-by: Elazar Gershuni <[email protected]>

Author: elazarg

src/crab/interval.hpp

@@ -489,9 +489,7 @@ class interval_t final {
         case 16: return truncate_to<int16_t>();
         case 32: return truncate_to<int32_t>();
         case 64: return truncate_to<int64_t>();
-        default: {
-            CRAB_ERROR("invalid width");
-        }
+        default: CRAB_ERROR("Invalid width ", width);
         }
     }
 
@@ -503,9 +501,7 @@ class interval_t final {
         case 16: return truncate_to<uint16_t>();
         case 32: return truncate_to<uint32_t>();
         case 64: return truncate_to<uint64_t>();
-        default: {
-            CRAB_ERROR("invalid width");
-        }
+        default: CRAB_ERROR("Invalid width ", width);
         }
     }
 
@@ -535,7 +531,7 @@ class interval_t final {
         case 16: return full<int16_t>();
         case 32: return full<int32_t>();
         case 64: return full<int64_t>();
-        default: throw std::exception();
+        default: CRAB_ERROR("Invalid width ", width);
         }
     }
 
@@ -545,10 +541,10 @@ class interval_t final {
     static interval_t unsigned_int(const int width) {
         switch (width) {
         case 8: return full<uint8_t>();
-        case 32: return full<uint32_t>();
         case 16: return full<uint16_t>();
+        case 32: return full<uint32_t>();
         case 64: return full<uint64_t>();
-        default: throw std::exception();
+        default: CRAB_ERROR("Invalid width ", width);
         }
     }
 
@@ -561,7 +557,7 @@ class interval_t final {
         case 16: return nonnegative<int16_t>();
         case 32: return nonnegative<int32_t>();
         case 64: return nonnegative<int64_t>();
-        default: throw std::exception();
+        default: CRAB_ERROR("Invalid width ", width);
         }
     }
 
@@ -574,7 +570,7 @@ class interval_t final {
         case 16: return negative<int16_t>();
         case 32: return negative<int32_t>();
         case 64: return negative<int64_t>();
-        default: throw std::exception();
+        default: CRAB_ERROR("Invalid width ", width);
         }
     }
 
@@ -601,15 +597,15 @@ class interval_t final {
 
     interval_t unsigned_high(bool is64) const = delete;
     // Return an interval in the range [INT_MAX+1, UINT_MAX], which can only
-    // be represented as a uvalue.  The svalue equivalent using the same
-    // width would be negative_int().
+    // be represented as a uvalue.
+    // The svalue equivalent using the same width would be negative_int().
     static interval_t unsigned_high(const int width) {
         switch (width) {
-        case 8: return high<uint8_t>(); ;
+        case 8: return high<uint8_t>();
         case 16: return high<uint16_t>();
         case 32: return high<uint32_t>();
         case 64: return high<uint64_t>();
-        default: throw std::exception();
+        default: CRAB_ERROR("Invalid width ", width);
         }
     }
 

src/crab_utils/bignums.hpp

@@ -26,6 +26,26 @@ T truncate_to(const cpp_int& n) {
     return static_cast<T>(static_cast<U>(n & mask));
 }
 
+// coderabbit implementation - TODO try in the future
+template <std::unsigned_integral U>
+U truncate_to_coderabbit(const cpp_int& n) {
+    constexpr U mask = std::numeric_limits<U>::max();
+    return static_cast<U>(n & mask);
+}
+
+// coderabbit implementation - TODO try in the future
+template <std::signed_integral S>
+S truncate_to_coderabbit(const cpp_int& n) {
+    using U = std::make_unsigned_t<S>;
+    constexpr uint32_t size = sizeof(S) * CHAR_BIT;
+    constexpr U mask = (U{1} << size) - 1;
+    const auto truncated = n & mask;
+    if (truncated >= cpp_int{1} << (size - 1)) {
+        truncated -= cpp_int{1} << size;
+    }
+    return static_cast<S>(truncated);
+}
+
 template <std::integral T>
 bool fits(const cpp_int& n) {
     return std::numeric_limits<T>::min() <= n && n <= std::numeric_limits<T>::max();
@@ -128,15 +148,15 @@ class z_number final {
 
     template <std::unsigned_integral U>
     [[nodiscard]]
-    uint64_t cast_to() const {
+    U cast_to() const {
         using S = std::make_signed_t<U>;
         if (fits<U>()) {
             return (U)_n;
         } else if (fits<S>()) {
             // Convert 32 bits from int32_t to uint32_t.
             return (U)(S)_n;
         } else {
-            CRAB_ERROR("z_number ", _n.str(), " does not fit into an unsigned 32-bit integer");
+            CRAB_ERROR("z_number ", _n.str(), " does not fit into ", typeid(U).name());
         }
     }
 
@@ -154,8 +174,8 @@ class z_number final {
 
     template <std::signed_integral S>
     [[nodiscard]]
-    int32_t cast_to() const {
-        return (S)cast_to_sint64();
+    S cast_to() const {
+        return static_cast<S>(cast_to_sint64());
     }
 
     // For 64-bit operations, get the value as a signed 64-bit integer.
@@ -174,7 +194,7 @@ class z_number final {
     // For 32-bit operations, get the low 32 bits as a signed integer.
     [[nodiscard]]
     int32_t cast_to_sint32() const {
-        return (int32_t)cast_to_sint64();
+        return cast_to<int32_t>();
     }
 
     // Allow casting to int32_t or int64_t as needed for finite width operations.