[PATCH 40/80] rust: serde_cbor: add no_fp_fmt_parse support

From: Ariel Miculas <amiculas@cisco.com>
To: rust-for-linux@vger.kernel.org
Cc: Ariel Miculas <amiculas@cisco.com>
Subject: [PATCH 40/80] rust: serde_cbor: add no_fp_fmt_parse support
Date: Fri,  9 Jun 2023 09:30:38 +0300	[thread overview]
Message-ID: <20230609063118.24852-41-amiculas@cisco.com> (raw)
In-Reply-To: <20230609063118.24852-1-amiculas@cisco.com>

We do not have formatting for floating point in the kernel,
thus simple compile out all that.

Signed-off-by: Ariel Miculas <amiculas@cisco.com>
---
 rust/serde_cbor/de.rs        | 8 ++++++++
 rust/serde_cbor/ser.rs       | 3 +++
 rust/serde_cbor/tags.rs      | 2 ++
 rust/serde_cbor/value/ser.rs | 2 ++
 4 files changed, 15 insertions(+)

diff --git a/rust/serde_cbor/de.rs b/rust/serde_cbor/de.rs
index 1c9a9acc8eb5..534f9d53aa3b 100644
--- a/rust/serde_cbor/de.rs
+++ b/rust/serde_cbor/de.rs
@@ -2,10 +2,12 @@
 
 //! Deserialization.
 
+#[cfg(not(no_fp_fmt_parse))]
 use core::f32;
 use core::marker::PhantomData;
 use core::result;
 use core::str;
+#[cfg(not(no_fp_fmt_parse))]
 use half::f16;
 use serde::de;
 #[cfg(feature = "std")]
@@ -566,14 +568,17 @@ fn parse_indefinite_enum<V>(&mut self, visitor: V) -> Result<V::Value>
         })
     }
 
+    #[cfg(not(no_fp_fmt_parse))]
     fn parse_f16(&mut self) -> Result<f32> {
         Ok(f32::from(f16::from_bits(self.parse_u16()?)))
     }
 
+    #[cfg(not(no_fp_fmt_parse))]
     fn parse_f32(&mut self) -> Result<f32> {
         self.parse_u32().map(|i| f32::from_bits(i))
     }
 
+    #[cfg(not(no_fp_fmt_parse))]
     fn parse_f64(&mut self) -> Result<f64> {
         self.parse_u64().map(|i| f64::from_bits(i))
     }
@@ -756,14 +761,17 @@ fn parse_value<V>(&mut self, visitor: V) -> Result<V::Value>
             0xf6 => visitor.visit_unit(),
             0xf7 => visitor.visit_unit(),
             0xf8 => Err(self.error(ErrorCode::UnassignedCode)),
+            #[cfg(not(no_fp_fmt_parse))]
             0xf9 => {
                 let value = self.parse_f16()?;
                 visitor.visit_f32(value)
             }
+            #[cfg(not(no_fp_fmt_parse))]
             0xfa => {
                 let value = self.parse_f32()?;
                 visitor.visit_f32(value)
             }
+            #[cfg(not(no_fp_fmt_parse))]
             0xfb => {
                 let value = self.parse_f64()?;
                 visitor.visit_f64(value)
diff --git a/rust/serde_cbor/ser.rs b/rust/serde_cbor/ser.rs
index 9f5bb67f0479..8c2273f9f544 100644
--- a/rust/serde_cbor/ser.rs
+++ b/rust/serde_cbor/ser.rs
@@ -10,6 +10,7 @@
 pub use crate::write::{SliceWrite, Write};
 
 use crate::error::{Error, Result};
+#[cfg(not(no_fp_fmt_parse))]
 use half::f16;
 use serde::ser::{self, Serialize};
 #[cfg(feature = "std")]
@@ -311,6 +312,7 @@ fn serialize_u128(self, value: u128) -> Result<()> {
 
     #[inline]
     #[allow(clippy::float_cmp)]
+    #[cfg(not(no_fp_fmt_parse))]
     fn serialize_f32(self, value: f32) -> Result<()> {
         if value.is_infinite() {
             if value.is_sign_positive() {
@@ -334,6 +336,7 @@ fn serialize_f32(self, value: f32) -> Result<()> {
 
     #[inline]
     #[allow(clippy::float_cmp)]
+    #[cfg(not(no_fp_fmt_parse))]
     fn serialize_f64(self, value: f64) -> Result<()> {
         if !value.is_finite() || f64::from(value as f32) == value {
             self.serialize_f32(value as f32)
diff --git a/rust/serde_cbor/tags.rs b/rust/serde_cbor/tags.rs
index 057765b9d2f8..81f749fa68e8 100644
--- a/rust/serde_cbor/tags.rs
+++ b/rust/serde_cbor/tags.rs
@@ -129,7 +129,9 @@ fn expecting(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
     delegate!(visit_u32, u32);
     delegate!(visit_u64, u64);
 
+    #[cfg(not(no_fp_fmt_parse))]
     delegate!(visit_f32, f32);
+    #[cfg(not(no_fp_fmt_parse))]
     delegate!(visit_f64, f64);
 
     delegate!(visit_char, char);
diff --git a/rust/serde_cbor/value/ser.rs b/rust/serde_cbor/value/ser.rs
index e52987778288..b4ff47c2e106 100644
--- a/rust/serde_cbor/value/ser.rs
+++ b/rust/serde_cbor/value/ser.rs
@@ -101,11 +101,13 @@ fn serialize_u64(self, value: u64) -> Result<Value, Error> {
     }
 
     #[inline]
+    #[cfg(not(no_fp_fmt_parse))]
     fn serialize_f32(self, value: f32) -> Result<Value, Error> {
         self.serialize_f64(f64::from(value))
     }
 
     #[inline]
+    #[cfg(not(no_fp_fmt_parse))]
     fn serialize_f64(self, value: f64) -> Result<Value, Error> {
         Ok(Value::Float(value))
     }
-- 
2.40.1

