Merge rust-embedded-community#3

3: add a std feature r=japaric a=japaric



Co-authored-by: Jorge Aparicio <jorge@japaric.io>

Author: bors[bot]

Cargo.toml

@@ -12,3 +12,6 @@ version = "1.0.33"
 
 [dev-dependencies]
 serde_derive = "1.0.33"
+
+[features]
+std = ["serde/std"]

ci/script.sh

@@ -5,6 +5,7 @@ main() {
 
     if [ $TARGET = x86_64-unknown-linux-gnu ]; then
         cargo test --target $TARGET
+        cargo check --target $TARGET --features std
         return
     fi
 }

src/de/mod.rs

@@ -67,6 +67,13 @@ pub enum Error {
     __Extensible,
 }
 
+#[cfg(feature = "std")]
+impl ::std::error::Error for Error {
+    fn description(&self) -> &str {
+        ""
+    }
+}
+
 pub(crate) struct Deserializer<'b> {
     slice: &'b [u8],
     index: usize,
@@ -185,7 +192,7 @@ impl<'a> Deserializer<'a> {
 // is what upstream does, to avoid pulling in 64-bit compiler intrinsics, which waste a few KBs of
 // Flash, when targeting non 64-bit architectures
 macro_rules! deserialize_unsigned {
-    ($self:ident, $visitor:ident, $uxx:ident, $visit_uxx:ident) => ({
+    ($self:ident, $visitor:ident, $uxx:ident, $visit_uxx:ident) => {{
         let peek = $self.parse_whitespace().ok_or(Error::EofWhileParsingValue)?;
 
         match peek {
@@ -205,7 +212,7 @@ macro_rules! deserialize_unsigned {
                             number = number
                                 .checked_mul(10)
                                 .ok_or(Error::InvalidNumber)?
-                            .checked_add((c - b'0') as $uxx)
+                                .checked_add((c - b'0') as $uxx)
                                 .ok_or(Error::InvalidNumber)?;
                         }
                         _ => return $visitor.$visit_uxx(number),
@@ -214,11 +221,11 @@ macro_rules! deserialize_unsigned {
             }
             _ => Err(Error::InvalidType),
         }
-    })
+    }};
 }
 
 macro_rules! deserialize_signed {
-    ($self:ident, $visitor:ident, $ixx:ident, $visit_ixx:ident) => ({
+    ($self:ident, $visitor:ident, $ixx:ident, $visit_ixx:ident) => {{
         let signed = match $self.parse_whitespace().ok_or(Error::EofWhileParsingValue)? {
             b'-' => {
                 $self.eat_char();
@@ -252,7 +259,7 @@ macro_rules! deserialize_signed {
             }
             _ => return Err(Error::InvalidType),
         }
-    })
+    }};
 }
 
 impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {

src/lib.rs

@@ -50,8 +50,10 @@
 #![deny(missing_docs)]
 #![deny(warnings)]
 #![feature(unsize)]
-#![no_std]
+#![cfg_attr(not(feature = "std"), no_std)]
 
+#[cfg(feature = "std")]
+extern crate core;
 extern crate heapless;
 extern crate serde;
 #[cfg(test)]

src/ser/mod.rs

@@ -10,8 +10,8 @@ use heapless::{BufferFullError, String, Vec};
 use self::seq::SerializeSeq;
 use self::struct_::SerializeStruct;
 
-mod struct_;
 mod seq;
+mod struct_;
 
 /// Serialization result
 pub type Result<T> = ::core::result::Result<T, Error>;
@@ -25,6 +25,13 @@ pub enum Error {
     __Extensible,
 }
 
+#[cfg(feature = "std")]
+impl ::std::error::Error for Error {
+    fn description(&self) -> &str {
+        ""
+    }
+}
+
 impl From<BufferFullError> for Error {
     fn from(_: BufferFullError) -> Self {
         Error::BufferFull
@@ -56,29 +63,29 @@ where
 // NOTE(serialize_*signed) This is basically the numtoa implementation minus the lookup tables,
 // which take 200+ bytes of ROM / Flash
 macro_rules! serialize_unsigned {
-    ($self:ident, $N:expr, $v:expr) => ({
+    ($self:ident, $N:expr, $v:expr) => {{
         let mut buf: [u8; $N] = unsafe { mem::uninitialized() };
 
         let mut v = $v;
         let mut i = $N - 1;
-        loop  {
+        loop {
             buf[i] = (v % 10) as u8 + b'0';
             v /= 10;
 
             if v == 0 {
-                break
+                break;
             } else {
                 i -= 1;
             }
         }
 
         $self.buf.extend_from_slice(&buf[i..])?;
         Ok(())
-    })
+    }};
 }
 
 macro_rules! serialize_signed {
-    ($self:ident, $N:expr, $v:expr, $ixx:ident, $uxx:ident) => ({
+    ($self:ident, $N:expr, $v:expr, $ixx:ident, $uxx:ident) => {{
         let v = $v;
         let (signed, mut v) = if v == $ixx::min_value() {
             (true, $ixx::max_value() as $uxx + 1)
@@ -108,7 +115,7 @@ macro_rules! serialize_signed {
         }
         $self.buf.extend_from_slice(&buf[i..])?;
         Ok(())
-    })
+    }};
 }
 
 impl<'a, B> ser::Serializer for &'a mut Serializer<B>