decimal: Cut precision on overflow

Author: syyyr

Cargo.toml

@@ -5,7 +5,7 @@ name = "shvproto"
 description = "Rust implementation of the SHV protocol"
 license = "MIT"
 repository = "https://github.com/silicon-heaven/libshvproto-rs"
-version = "6.1.8"
+version = "6.1.9"
 edition = "2024"
 
 [dependencies]

src/chainpack.rs

@@ -576,15 +576,10 @@ where
             ));
         }
 
-        if !(-(1i64 << 55)..(1i64 << 55)).contains(&mantissa) {
-            return Err(self.make_error(
-                &format!("Decimal mantissa {mantissa} overflows 56-bit field"),
-                ReadErrorReason::NumericValueOverflow,
-            ));
-        }
-
-        let d = Decimal::new(mantissa, exponent as i8);
-        Ok(Value::from(d))
+        Decimal::try_new_with_precision_reduction(mantissa, exponent as i8).map_or_else(|| Err(self.make_error(
+                    &format!("Decimal mantissa {mantissa} overflows 56-bit field"),
+                    ReadErrorReason::NumericValueOverflow,
+        )), |d| Ok(Value::from(d)))
     }
 
 }
@@ -899,7 +894,10 @@ fn test_decimal() {
     let dec = crate::decimal::Decimal::new(0, 0);
     assert_eq!(hex_chainpack_to_rpcvalue("8C0000").unwrap(), dec.into());
     assert_eq!(rpcvalue_to_hex_chainpack(&dec.into()), "8C0000");
-    assert_eq!(hex_chainpack_to_rpcvalue("8CF400B201AB082063B54F").unwrap_err().msg, "ChainPack read error - Decimal mantissa 50104379941872565 overflows 56-bit field");
+    let val = hex_chainpack_to_rpcvalue("8CF400B201AB082063B54F").unwrap();
+    let dec_val = val.as_decimal();
+    assert_eq!(dec_val.mantissa(), 5_010_437_994_187_256);
+    assert_eq!(dec_val.exponent(), -14);
     assert_eq!(hex_chainpack_to_rpcvalue("8C4FF400B201AB082063B5").unwrap_err().msg, "ChainPack read error - Decimal exponent 50104379941872565 overflows i8");
 }
 

src/cpon.rs

@@ -736,8 +736,8 @@ mod test
         assert_eq!(RpcValue::from_cpon("0.123e3").unwrap().as_decimal(), Decimal::new(123, 0));
         test_cpon_round_trip("1000000.", Decimal::new(1_000_000, 0));
         test_cpon_round_trip("50.03138741402532", Decimal::new(5_003_138_741_402_532, -14));
-        // We do not support such high precision.
-        assert!(RpcValue::from_cpon("36.028797018963968").is_err_and(|err| matches!(err.reason, ReadErrorReason::NumericValueOverflow)));
+        // Precision reduction should handle high precision by cutting digits from the right.
+        assert_eq!(RpcValue::from_cpon("36.028797018963968").unwrap().as_decimal(), Decimal::new(3_602_879_701_896_396, -14));
         assert_eq!(RpcValue::from_cpon(r#""foo""#).unwrap().as_str(), "foo");
         assert_eq!(RpcValue::from_cpon(r#""ěščřžýáí""#).unwrap().as_str(), "ěščřžýáí");
         assert_eq!(RpcValue::from_cpon("b\"foo\tbar\nbaz\"").unwrap().as_blob(), b"foo\tbar\nbaz");

src/decimal.rs

@@ -11,6 +11,28 @@ impl Decimal {
         n |= i64::from(exponent) & 0xff;
         Decimal(n)
     }
+    pub fn try_new_with_precision_reduction(mantissa: i64, exponent: i8) -> Option<Decimal> {
+        const MANTISSA_MIN: i64 = -(1i64 << 55);
+        const MANTISSA_MAX: i64 = 1i64 << 55;
+
+        let mut m = mantissa;
+        let mut e = i64::from(exponent);
+
+        while !(MANTISSA_MIN..MANTISSA_MAX).contains(&m) {
+            m /= 10;
+            e += 1;
+
+            if e < i64::from(i8::MIN) || e > i64::from(i8::MAX) {
+                return None;
+            }
+        }
+
+        if !(MANTISSA_MIN..MANTISSA_MAX).contains(&m) {
+            return None;
+        }
+
+        Some(Decimal::new(m, e as i8))
+    }
     #[must_use]
     pub fn normalize(self) -> Decimal {
         let (mut mantissa, mut exponent) = self.decode();

src/textrdwr.rs

@@ -195,6 +195,7 @@ pub trait TextReader : Reader {
         let mut is_uint = false;
         let mut is_negative = false;
         let mut decimal_overflow = false;
+        let mut i64_overflow = false;
 
         let b = self.peek_byte()?;
         if b == b'+' {
@@ -207,6 +208,7 @@ pub trait TextReader : Reader {
         }
 
         let ReadInt { value, digit_cnt, is_overflow, .. } = self.read_int(0, false)?;
+        i64_overflow = i64_overflow || is_overflow;
         decimal_overflow = decimal_overflow || is_overflow;
         if digit_cnt == 0 {
             return Err(self.make_error("Number should contain at least one digit.", ReadErrorReason::InvalidCharacter))
@@ -230,9 +232,10 @@ pub trait TextReader : Reader {
                     is_decimal = true;
                     self.get_byte()?;
                     let ReadInt { value, digit_cnt, is_overflow, .. } = self.read_int(mantissa, true)?;
+                    i64_overflow = i64_overflow || is_overflow;
                     decimal_overflow = decimal_overflow || is_overflow;
                     mantissa = value;
-                    if mantissa >= 0x80_0000_0000_0000 || mantissa < -0x80_0000_0000_0000 {
+                    if !(-0x80_0000_0000_0000..0x80_0000_0000_0000).contains(&mantissa) {
                         decimal_overflow = true;
                     }
                     dec_cnt = i64::from(digit_cnt);
@@ -245,6 +248,7 @@ pub trait TextReader : Reader {
                     is_decimal = true;
                     self.get_byte()?;
                     let ReadInt { value, digit_cnt, is_negative, is_overflow } = self.read_int(0, false)?;
+                    i64_overflow = i64_overflow || is_overflow;
                     decimal_overflow = decimal_overflow || is_overflow;
                     exponent = value;
                     if is_negative { exponent = -exponent; }
@@ -259,6 +263,13 @@ pub trait TextReader : Reader {
         let mantissa = if is_negative { -mantissa } else { mantissa };
         if is_decimal {
             if decimal_overflow {
+                if !i64_overflow {
+                    #[expect(clippy::cast_possible_truncation, reason = "We hope that the new exponent is not big enough to truncate")]
+                    let target_exp = (exponent - dec_cnt) as i8;
+                    if let Some(d) = Decimal::try_new_with_precision_reduction(mantissa, target_exp) {
+                        return Ok(Value::from(d));
+                    }
+                }
                 return Err(self.make_error("Not enough precision to read the Decimal", ReadErrorReason::NumericValueOverflow))
             }
             #[expect(clippy::cast_possible_truncation, reason = "We hope that the new exponent is not big enough to truncate")]