Expose alloc as a selectable feature (sharksforarms#582)

Co-authored-by: Matt Johnston <[email protected]>

Author: amboar

.github/workflows/main.yml

@@ -20,10 +20,14 @@ jobs:
       - run: cargo build --all
       # test
       - run: cargo test --all
+      - run: cargo test --all-features
+      - run: cargo test --no-default-features
+      - run: cargo test --no-default-features --features=alloc
+      - 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 examples
       - run: cargo run --example 2>&1 | grep -P '   ' | awk '{print $1}' | xargs -i cargo run --example {}
-      # test with no bits feature (don't test docs)
-      - run: cargo test --lib --examples --tests --features std --no-default-features
 
   # Only build on MSRV, since trybuild will fail on older version
   build-msrv:
@@ -64,6 +68,7 @@ jobs:
           toolchain: nightly
           targets: thumbv7em-none-eabihf
       - run: cd ensure_no_std && cargo build --release --target thumbv7em-none-eabihf
+      - run: cd ensure_no_std && cargo build --release --target thumbv7em-none-eabihf --no-default-features
 
   ensure_wasm:
     name: Ensure wasm

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## Added
+
+- The `alloc` feature, allowing use in environments lacking a heap [#582](https://github.com/sharksforarms/deku/pull/582)
+- The `descriptive-errors` feature, replacing `no-assertion-string` [#582](https://github.com/sharksforarms/deku/pull/582)
+
 ## [0.19.1] - 2025-05-22
 
 ## Added

Cargo.toml

@@ -20,18 +20,18 @@ members = [
 ]
 
 [features]
-default = ["std", "bits"]
+default = ["std", "bits", "descriptive-errors"]
 std = ["deku_derive/std", "bitvec?/std", "alloc", "no_std_io/std"]
-alloc = ["bitvec?/alloc"]
+alloc = ["bitvec?/alloc", "deku_derive/alloc", "no_std_io/alloc" ]
 logging = ["deku_derive/logging", "log"]
-no-assert-string = ["deku_derive/no-assert-string"]
-bits = ["dep:bitvec", "deku_derive/bits"]
+bits = ["dep:bitvec", "deku_derive/bits", "alloc" ]
+descriptive-errors = ["alloc"]
 
 [dependencies]
 deku_derive = { version = "^0.19.1", path = "deku-derive", default-features = false}
 bitvec = { version = "1.0.1", default-features = false, optional = true }
 log = { version = "0.4.22", optional = true }
-no_std_io = { version = "0.9.0", default-features = false, features = ["alloc"], package = "no_std_io2" }
+no_std_io = { version = "0.9.0", default-features = false, package = "no_std_io2" }
 rustversion = "1.0.17"
 
 [dev-dependencies]
@@ -48,6 +48,7 @@ log = { version = "0.4.22" }
 [[bench]]
 name = "deku"
 harness = false
+required-features = ["alloc"]
 
 [lints]
 workspace = true
@@ -63,13 +64,15 @@ required-features = ["bits"]
 
 [[example]]
 name = "deku_input"
+required-features = ["std"]
 
 [[example]]
 name = "enums_catch_all"
 required-features = ["bits"]
 
 [[example]]
 name = "enums"
+required-features = ["std"]
 
 [[example]]
 name = "example"
@@ -85,6 +88,8 @@ required-features = ["bits"]
 
 [[example]]
 name = "many"
+required-features = ["std"]
 
 [[example]]
 name = "read_all"
+required-features = ["std"]

benches/deku.rs

@@ -1,4 +1,4 @@
-use std::io::{Cursor, Read, Seek};
+use no_std_io::io::{Cursor, Read, Seek};
 
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use deku::prelude::*;
@@ -132,6 +132,7 @@ pub fn read_all_vs_count_vs_read_exact(c: &mut Criterion) {
 
     #[derive(DekuRead, DekuWrite)]
     #[deku(ctx = "len: usize")]
+    #[expect(dead_code)]
     pub struct CountFromCtxWrapper {
         #[deku(count = "len")]
         pub data: Vec<u8>,

deku-derive/Cargo.toml

@@ -13,9 +13,9 @@ rust-version = "1.81"
 proc-macro = true
 
 [features]
-std = ["proc-macro-crate"]
+std = ["proc-macro-crate", "alloc"]
+alloc = []
 logging = []
-no-assert-string = []
 bits = []
 
 [dependencies]

deku-derive/src/lib.rs

@@ -21,6 +21,36 @@ use crate::macros::deku_write::emit_deku_write;
 
 mod macros;
 
+// Pad attribute values are not bounded by the implementation, however, for
+// implementation purposes we need a concrete object to contain padding data.
+// To allow use of padding in constrained environments we define the object as
+// an array (by contrast to a vec). PAD_ARRAY_SIZE controls the length of
+// these arrays.
+//
+// The length of the padding array is chosen with the following considerations:
+//
+// - A loop is necessary to avoid arbitrarily picking an upper-bound for
+//   requested padding values
+//
+// - Given the loop there aren't any strong constraints on the size of the
+//   padding array
+//
+// - My estimate is padding requests tend to be in the range of 1-16 bytes.
+//   From a [brief inspection][github-search-pad-bytes] it seems that estimate
+//   is reasonable
+//
+// - We desire a value large enough to cover common cases and avoid unnecessary
+//   loop trips, but small enough not to cause trouble on the stack (for
+//   instance, requesting a page of zeros feels unreasonable)
+//
+// - Try to pick something that only requires 1 execution of the loop body for
+//   common cases.
+//
+// [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)]
 enum Id {
     TokenStream(TokenStream),

deku-derive/src/macros/deku_read.rs

@@ -4,12 +4,16 @@ use darling::ast::{Data, Fields};
 use darling::ToTokens;
 use proc_macro2::TokenStream;
 use quote::quote;
+#[cfg(feature = "bits")]
 use syn::LitStr;
 use syn::{Ident, LitByteStr};
 
+#[cfg(feature = "bits")]
+use crate::macros::gen_bit_order_from_str;
+
 use crate::macros::{
-    assertion_failed, gen_bit_order_from_str, gen_ctx_types_and_arg, gen_field_args,
-    gen_internal_field_idents, token_contains_string, wrap_default_ctx,
+    assertion_failed, gen_ctx_types_and_arg, gen_field_args, gen_internal_field_idents,
+    token_contains_string, wrap_default_ctx,
 };
 use crate::{from_token, DekuData, DekuDataEnum, DekuDataStruct, FieldData, Id};
 
@@ -356,16 +360,7 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
     if !has_default_match && default_reader.is_none() {
         variant_matches.push(quote! {
             _ => {
-                extern crate alloc;
-                use alloc::borrow::Cow;
-                use alloc::format;
-                return Err(::#crate_::DekuError::Parse(
-                            Cow::from(format!(
-                                "Could not match enum variant id = {:?} on enum `{}`",
-                                __deku_variant_id,
-                                #ident_as_string
-                            ))
-                        ));
+                return Err(::#crate_::deku_error!(::#crate_::DekuError::Parse, "Could not match enum variant", "ID {:?} not found on {}", __deku_variant_id, #ident_as_string));
             }
         });
     }
@@ -540,10 +535,7 @@ fn emit_magic_read_lit(crate_: &Ident, magic: &LitByteStr) -> TokenStream {
         for __deku_byte in __deku_magic {
             let __deku_read_byte = u8::from_reader_with_ctx(__deku_reader, ())?;
             if *__deku_byte != __deku_read_byte {
-                extern crate alloc;
-                use alloc::borrow::Cow;
-                use alloc::format;
-                return Err(::#crate_::DekuError::Parse(Cow::from(format!("Missing magic value {:?}", #magic))));
+                return Err(::#crate_::deku_error!(::#crate_::DekuError::Parse, "Missing magic value", "{:?}", #magic));
             }
         }
     }
@@ -615,19 +607,13 @@ fn emit_padding(bit_size: &TokenStream, bit_order: Option<&LitStr>) -> TokenStre
         let order = gen_bit_order_from_str(bit_order).unwrap();
         quote! {
             {
-                use core::convert::TryFrom;
-                // TODO: I hope this consts in most cases?
                 extern crate alloc;
-                use alloc::borrow::Cow;
-                use alloc::format;
+
+                use core::convert::TryFrom;
                 let __deku_pad = usize::try_from(#bit_size).map_err(|e|
-                    ::#crate_::DekuError::InvalidParam(Cow::from(format!(
-                        "Invalid padding param \"({})\": cannot convert to usize",
-                        stringify!(#bit_size)
-                    )))
+                    ::#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];
@@ -642,19 +628,13 @@ fn emit_padding(bit_size: &TokenStream, bit_order: Option<&LitStr>) -> TokenStre
     } else {
         quote! {
             {
-                use core::convert::TryFrom;
-                // TODO: I hope this consts in most cases?
                 extern crate alloc;
-                use alloc::borrow::Cow;
-                use alloc::format;
+
+                use core::convert::TryFrom;
                 let __deku_pad = usize::try_from(#bit_size).map_err(|e|
-                    ::#crate_::DekuError::InvalidParam(Cow::from(format!(
-                        "Invalid padding param \"({})\": cannot convert to usize",
-                        stringify!(#bit_size)
-                    )))
+                    ::#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];
@@ -673,22 +653,20 @@ fn emit_padding(bit_size: &TokenStream, bit_order: Option<&LitStr>) -> TokenStre
 #[cfg(not(feature = "bits"))]
 fn emit_padding_bytes(bit_size: &TokenStream) -> TokenStream {
     let crate_ = super::get_crate_name();
+    let pad = crate::PAD_ARRAY_SIZE;
     quote! {
         {
             use core::convert::TryFrom;
-            extern crate alloc;
-            use alloc::borrow::Cow;
-            use alloc::format;
-            let __deku_pad = usize::try_from(#bit_size).map_err(|e|
-                ::#crate_::DekuError::InvalidParam(Cow::from(format!(
-                    "Invalid padding param \"({})\": cannot convert to usize",
-                    stringify!(#bit_size)
-                )))
+            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))
             )?;
 
-
-            let mut buf = alloc::vec![0; __deku_pad];
-            let _ = __deku_reader.read_bytes(__deku_pad, &mut buf, ::#crate_::ctx::Order::default())?;
+            while __deku_pad > 0 {
+                let mut __deku_pad_source = [0u8; #pad];
+                let __deku_pad_chunk = core::cmp::min(__deku_pad_source.len(), __deku_pad);
+                __deku_reader.read_bytes(__deku_pad_chunk, &mut __deku_pad_source[..__deku_pad_chunk], ::#crate_::ctx::Order::default())?;
+                __deku_pad -= __deku_pad_chunk;
+            }
         }
     }
 }
@@ -1094,9 +1072,7 @@ pub fn emit_try_from(
                 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 {
-                    extern crate alloc;
-                    use alloc::borrow::Cow;
-                    return Err(::#crate_::DekuError::Parse(Cow::from("Too much data")));
+                    return Err(::#crate_::deku_error!(::#crate_::DekuError::Parse, "Too much data"));
                 }
                 Ok(res)
             }