Lift alloc requirement for bits feature (#614)

Author: amboar

.github/workflows/main.yml

@@ -26,6 +26,7 @@ jobs:
       - run: cargo test --no-default-features --features=descriptive-errors
       - run: cargo test --no-default-features --features=bits
       - run: cargo test --no-default-features --features=logging
+      - run: cargo test --no-default-features --features=bits,alloc
       # run examples
       - run: cargo run --example 2>&1 | grep -P '   ' | awk '{print $1}' | xargs -i cargo run --example {}
 
@@ -36,7 +37,7 @@ jobs:
       matrix:
         toolchain:
             # msrv
-          - 1.81
+          - 1.82
 
     steps:
       - uses: actions/checkout@v4

Cargo.toml

@@ -9,7 +9,7 @@ keywords = ["deku", "bits", "serialization", "deserialization", "struct"]
 categories = ["encoding", "parsing", "no-std"]
 description = "bit level serialization/deserialization proc-macro for structs"
 readme = "README.md"
-rust-version = "1.81"
+rust-version = "1.82"
 
 [lib]
 bench = false
@@ -24,7 +24,7 @@ default = ["std", "bits", "descriptive-errors"]
 std = ["deku_derive/std", "bitvec?/std", "alloc", "no_std_io/std"]
 alloc = ["bitvec?/alloc", "deku_derive/alloc", "no_std_io/alloc" ]
 logging = ["deku_derive/logging", "log"]
-bits = ["dep:bitvec", "deku_derive/bits", "alloc" ]
+bits = ["dep:bitvec", "deku_derive/bits" ]
 descriptive-errors = ["alloc"]
 
 [dependencies]
@@ -60,27 +60,27 @@ manual-unwrap-or-default = "allow"
 
 [[example]]
 name = "custom_reader_and_writer"
-required-features = ["bits"]
+required-features = ["alloc", "bits"]
 
 [[example]]
 name = "deku_input"
 required-features = ["std"]
 
 [[example]]
 name = "enums_catch_all"
-required-features = ["bits"]
+required-features = ["alloc", "bits"]
 
 [[example]]
 name = "enums"
 required-features = ["std"]
 
 [[example]]
 name = "example"
-required-features = ["bits"]
+required-features = ["alloc", "bits"]
 
 [[example]]
 name = "ipv4"
-required-features = ["bits"]
+required-features = ["alloc", "bits"]
 
 [[example]]
 name = "80211"

deku-derive/Cargo.toml

@@ -7,7 +7,7 @@ license = "MIT OR Apache-2.0"
 repository = "https://github.com/sharksforarms/deku"
 description = "bit level serialization/deserialization proc-macro for structs"
 readme = "../README.md"
-rust-version = "1.81"
+rust-version = "1.82"
 
 [lib]
 proc-macro = true

deku-derive/src/lib.rs

@@ -48,7 +48,6 @@ mod macros;
 //
 // [github-search-pad-bytes]:
 //   https://github.com/search?q=pad_bytes_before+OR+pad_bytes_after&type=code
-#[cfg(not(feature = "bits"))]
 const PAD_ARRAY_SIZE: usize = 64;
 
 #[derive(Debug)]

deku-derive/src/macros/deku_read.rs

@@ -117,7 +117,7 @@ fn emit_struct(input: &DekuData) -> Result<TokenStream, syn::Error> {
             use ::#crate_::DekuReader as _;
             let __deku_reader = &mut deku::reader::Reader::new(__deku_input.0);
             if __deku_input.1 != 0 {
-                __deku_reader.skip_bits(__deku_input.1)?;
+                __deku_reader.skip_bits(__deku_input.1, ::#crate_::ctx::Order::default())?;
             }
 
             let __deku_value = Self::from_reader_with_ctx(__deku_reader, ())?;
@@ -131,7 +131,7 @@ fn emit_struct(input: &DekuData) -> Result<TokenStream, syn::Error> {
             let mut __deku_cursor = #crate_::no_std_io::Cursor::new(__deku_input.0);
             let mut __deku_reader = &mut deku::reader::Reader::new(&mut __deku_cursor);
             if __deku_input.1 != 0 {
-                __deku_reader.skip_bits(__deku_input.1)?;
+                __deku_reader.skip_bits(__deku_input.1, ::#crate_::ctx::Order::default())?;
             }
 
             let __deku_value = Self::from_reader_with_ctx(__deku_reader, ())?;
@@ -406,7 +406,7 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
             use ::#crate_::DekuReader as _;
             let __deku_reader = &mut deku::reader::Reader::new(__deku_input.0);
             if __deku_input.1 != 0 {
-                __deku_reader.skip_bits(__deku_input.1)?;
+                __deku_reader.skip_bits(__deku_input.1, ::#crate_::ctx::Order::default())?;
             }
 
             let __deku_value = Self::from_reader_with_ctx(__deku_reader, ())?;
@@ -420,7 +420,7 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
             let mut __deku_cursor = #crate_::no_std_io::Cursor::new(__deku_input.0);
             let mut __deku_reader = &mut deku::reader::Reader::new(&mut __deku_cursor);
             if __deku_input.1 != 0 {
-                __deku_reader.skip_bits(__deku_input.1)?;
+                __deku_reader.skip_bits(__deku_input.1, ::#crate_::ctx::Order::default())?;
             }
 
             let __deku_value = Self::from_reader_with_ctx(__deku_reader, ())?;
@@ -607,43 +607,21 @@ fn emit_padding(bit_size: &TokenStream, bit_order: Option<&LitStr>) -> TokenStre
         let order = gen_bit_order_from_str(bit_order).unwrap();
         quote! {
             {
-                extern crate alloc;
-
                 use core::convert::TryFrom;
                 let __deku_pad = usize::try_from(#bit_size).map_err(|e|
                     ::#crate_::deku_error!(::#crate_::DekuError::InvalidParam, "Invalid padding param, cannot convert ot usize", "{}", stringify!(#bit_size))
                 )?;
-
-                if (__deku_pad % 8) == 0 {
-                    let bytes_read = __deku_pad / 8;
-                    let mut buf = alloc::vec![0; bytes_read];
-                    // TODO: use skip_bytes, or Seek in the future?
-                    let _ = __deku_reader.read_bytes(bytes_read, &mut buf, #order)?;
-                } else {
-                    // TODO: use skip_bits, or Seek in the future?
-                    let _ = __deku_reader.read_bits(__deku_pad, #order)?;
-                }
+                __deku_reader.skip_bits(__deku_pad, #order)?;
             }
         }
     } else {
         quote! {
             {
-                extern crate alloc;
-
                 use core::convert::TryFrom;
                 let __deku_pad = usize::try_from(#bit_size).map_err(|e|
                     ::#crate_::deku_error!(::#crate_::DekuError::InvalidParam, "Invalid padding param, cannot convert to usize", "{}", stringify!(#bit_size))
                 )?;
-
-                if (__deku_pad % 8) == 0 {
-                    let bytes_read = __deku_pad / 8;
-                    let mut buf = alloc::vec![0; bytes_read];
-                    // TODO: use skip_bytes, or Seek in the future?
-                    let _ = __deku_reader.read_bytes(bytes_read, &mut buf, ::#crate_::ctx::Order::default())?;
-                } else {
-                    // TODO: use skip_bits, or Seek in the future?
-                    let _ = __deku_reader.read_bits(__deku_pad, ::#crate_::ctx::Order::default())?;
-                }
+                __deku_reader.skip_bits(__deku_pad, ::#crate_::ctx::Order::default())?;
             }
         }
     }
@@ -1070,9 +1048,14 @@ pub fn emit_try_from(
             fn try_from(input: &#lifetime [u8]) -> core::result::Result<Self, Self::Error> {
                 let total_len = input.len();
                 let mut cursor = ::#crate_::no_std_io::Cursor::new(input);
-                let (amt_read, res) = <Self as ::#crate_::DekuContainerRead>::from_reader((&mut cursor, 0))?;
-                if (amt_read / 8) != total_len {
-                    return Err(::#crate_::deku_error!(::#crate_::DekuError::Parse, "Too much data"));
+                let (bits_read, res) = <Self as ::#crate_::DekuContainerRead>::from_reader((&mut cursor, 0))?;
+                let bytes_read = bits_read / 8;
+                if bytes_read < total_len {
+                    return Err(::#crate_::deku_error!(::#crate_::DekuError::Parse, "Too much data", "Read {} but total length was {}", {bits_read / 8}, total_len));
+                }
+                // Possible Seek beyond end
+                if bytes_read > total_len {
+                    return Err(::#crate_::DekuError::Incomplete(::#crate_::error::NeedSize::new(bits_read - { total_len * 8 })));
                 }
                 Ok(res)
             }

deku-derive/src/macros/deku_write.rs

@@ -99,7 +99,7 @@ fn emit_struct(input: &DekuData) -> Result<TokenStream, syn::Error> {
 
     // Implement `DekuContainerWrite` for types that don't need a context
     if input.ctx.is_none() || (input.ctx.is_some() && input.ctx_default.is_some()) {
-        #[cfg(feature = "bits")]
+        #[cfg(all(feature = "alloc", feature = "bits"))]
         tokens.extend(quote! {
             #[automatically_derived]
              impl #imp core::convert::TryFrom<#ident> for ::#crate_::bitvec::BitVec<u8, ::#crate_::bitvec::Msb0> #wher {
@@ -357,7 +357,7 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
 
     // Implement `DekuContainerWrite` for types that don't need a context
     if input.ctx.is_none() || (input.ctx.is_some() && input.ctx_default.is_some()) {
-        #[cfg(feature = "bits")]
+        #[cfg(all(feature = "alloc", feature = "bits"))]
         tokens.extend(quote! {
             #[automatically_derived]
              impl #imp core::convert::TryFrom<#ident> for ::#crate_::bitvec::BitVec<u8, ::#crate_::bitvec::Msb0> #wher {
@@ -544,25 +544,36 @@ fn emit_bit_byte_offsets(
 #[cfg(feature = "bits")]
 fn emit_padding(bit_size: &TokenStream, bit_order: Option<&LitStr>) -> TokenStream {
     let crate_ = super::get_crate_name();
+    const PAD: usize = crate::PAD_ARRAY_SIZE * 8;
     if let Some(bit_order) = bit_order {
         let order = gen_bit_order_from_str(bit_order).unwrap();
         quote! {
             {
                 use core::convert::TryFrom;
-                let __deku_pad = usize::try_from(#bit_size).map_err(|e|
+                let mut __deku_pad = usize::try_from(#bit_size).map_err(|e|
                     ::#crate_::deku_error!(::#crate_::DekuError::InvalidParam, "Invalid padding param, cannot convert to usize", "{}", stringify!(#bit_size))
                 )?;
-                __deku_writer.write_bits_order(::#crate_::bitvec::bitvec![u8, ::#crate_::bitvec::Msb0; 0; __deku_pad].as_bitslice(), #order)?;
+                let __deku_pad_source = ::#crate_::bitvec::bitarr!(u8, ::#crate_::bitvec::Msb0; 0; #PAD);
+                while __deku_pad > 0 {
+                    let __deku_pad_chunk = core::cmp::min(__deku_pad_source.len(), __deku_pad);
+                    __deku_writer.write_bits_order(&__deku_pad_source[..__deku_pad_chunk], #order)?;
+                    __deku_pad -= __deku_pad_chunk;
+                }
             }
         }
     } else {
         quote! {
             {
                 use core::convert::TryFrom;
-                let __deku_pad = usize::try_from(#bit_size).map_err(|e|
+                let mut __deku_pad = usize::try_from(#bit_size).map_err(|e|
                     ::#crate_::deku_error!(::#crate_::DekuError::InvalidParam, "Invalid padding param, cannot convert to usize", "{}", stringify!(#bit_size))
                 )?;
-                __deku_writer.write_bits(::#crate_::bitvec::bitvec![u8, ::#crate_::bitvec::Msb0; 0; __deku_pad].as_bitslice())?;
+                let __deku_pad_source = ::#crate_::bitvec::bitarr!(u8, ::#crate_::bitvec::Msb0; 0; #PAD);
+                while __deku_pad > 0 {
+                    let __deku_pad_chunk = core::cmp::min(__deku_pad_source.len(), __deku_pad);
+                    __deku_writer.write_bits(&__deku_pad_source[..__deku_pad_chunk])?;
+                    __deku_pad -= __deku_pad_chunk;
+                }
             }
         }
     }

src/attributes.rs

@@ -230,7 +230,7 @@ pub struct BigEndian {
     t: u8,
 }
 
-# #[cfg(feature = "bits")]
+# #[cfg(all(feature = "alloc", feature = "bits"))]
 # fn main() {
 let data = vec![0x10, 0x81];
 let big_endian = BigEndian::try_from(data.as_ref()).unwrap();
@@ -245,7 +245,7 @@ let bytes = big_endian.to_bytes().unwrap();
 assert_eq!(bytes, data);
 # }
 #
-# #[cfg(not(feature = "bits"))]
+# #[cfg(not(all(feature = "alloc", feature = "bits")))]
 # fn main() {}
 ````
 ### Field Example
@@ -261,7 +261,7 @@ pub struct LsbField {
     t: u8,
 }
 
-# #[cfg(feature = "bits")]
+# #[cfg(all(feature = "alloc", feature = "bits"))]
 # fn main() {
 let data = vec![0x40, 0x40];
 let more_first = LsbField::try_from(data.as_ref()).unwrap();
@@ -270,7 +270,7 @@ let bytes = more_first.to_bytes().unwrap();
 assert_eq!(bytes, data);
 # }
 #
-# #[cfg(not(feature = "bits"))]
+# #[cfg(not(all(feature = "alloc", feature = "bits")))]
 # fn main() {}
 ```
 
@@ -1570,7 +1570,7 @@ Specify custom reader or writer tokens for reading a field or variant
 Example:
 ```rust
 use core::convert::{TryInto, TryFrom};
-# #[cfg(feature = "bits")]
+# #[cfg(all(feature = "alloc", feature = "bits"))]
 use deku::bitvec::{BitSlice, BitVec, Msb0};
 use deku::prelude::*;
 

src/error.rs

@@ -213,3 +213,9 @@ impl From<DekuError> for std::io::Error {
         }
     }
 }
+
+impl From<no_std_io::io::Error> for DekuError {
+    fn from(value: no_std_io::io::Error) -> Self {
+        DekuError::Io(value.kind())
+    }
+}

src/impls/bool.rs

@@ -53,8 +53,6 @@ mod tests {
     use no_std_io::io::Cursor;
     use rstest::rstest;
 
-    #[cfg(feature = "bits")]
-    use crate::ctx::BitSize;
     use crate::reader::Reader;
 
     use super::*;
@@ -87,6 +85,8 @@ mod tests {
     #[cfg(all(feature = "alloc", feature = "bits"))]
     #[test]
     fn test_writer_bits() {
+        use crate::ctx::BitSize;
+
         let mut writer = Writer::new(Cursor::new(alloc::vec![]));
         true.to_writer(&mut writer, BitSize(1)).unwrap();
         assert_eq!(alloc::vec![true], writer.rest());

src/impls/cstring.rs

@@ -67,8 +67,8 @@ where
 }
 
 #[cfg(test)]
+#[cfg(all(feature = "alloc", feature = "descriptive-errors"))]
 mod tests {
-    #[cfg(feature = "alloc")]
     use alloc::vec;
     use no_std_io::io::Cursor;
     use rstest::rstest;
@@ -77,7 +77,6 @@ mod tests {
 
     use super::*;
 
-    #[cfg(feature = "alloc")]
     #[rstest(input, len, expected, expected_rest,
         case(
             b"test\0",