From c9ee529341e8f8e553bcb6299d8fe38dbe9fa6d1 Mon Sep 17 00:00:00 2001
From: "Jomer.Dev" <Jomer.Dev@posteo.de>
Date: Fri, 13 Oct 2023 00:41:26 +0200
Subject: [PATCH 1/7] Added prepend attribute Still working on adding it to the
 pack call

---
 packed_struct_codegen/src/pack.rs             |   3 +-
 packed_struct_codegen/src/pack_codegen.rs     |  28 +++++
 packed_struct_codegen/src/pack_parse.rs       | 106 +++++++++++++++---
 .../src/pack_parse_attributes.rs              |  27 +++--
 4 files changed, 143 insertions(+), 21 deletions(-)

diff --git a/packed_struct_codegen/src/pack.rs b/packed_struct_codegen/src/pack.rs
index 2129b56..3612bf5 100644
--- a/packed_struct_codegen/src/pack.rs
+++ b/packed_struct_codegen/src/pack.rs
@@ -49,7 +49,8 @@ pub struct PackStruct<'a> {
     pub num_bytes: usize,
     pub num_bits: usize,
     pub data_struct: &'a syn::DataStruct,
-    pub derive_input: &'a syn::DeriveInput
+    pub derive_input: &'a syn::DeriveInput,
+    pub prepend: Option<Prepend>,
 }
 
 
diff --git a/packed_struct_codegen/src/pack_codegen.rs b/packed_struct_codegen/src/pack_codegen.rs
index 2762e67..0380d63 100644
--- a/packed_struct_codegen/src/pack_codegen.rs
+++ b/packed_struct_codegen/src/pack_codegen.rs
@@ -4,6 +4,7 @@ extern crate syn;
 use crate::pack::*;
 use crate::pack_codegen_docs::*;
 use crate::common::*;
+use crate::pack_parse::Prepend;
 use syn::spanned::Spanned;
 use crate::utils::*;
 
@@ -17,6 +18,8 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
     let type_documentation = type_docs(parsed);
     let num_bytes = parsed.num_bytes;
     let num_bits = parsed.num_bits;
+
+    let prepend = &parsed.prepend;
     
 
     let mut pack_fields = vec![];
@@ -79,6 +82,31 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
             }        
         }
 
+        //TODO: Move prepend check to before the reg. Either make target be a slice into target after the header or pass an offset into pack_bits to make sure headers don't get overwritten
+        //      Call teh trait method if the enum is set to that. Add the trait. 
+        //      Do the same stuff for append
+        //      The trait should return a result, in case we want to verify that the header is correct before unpacking fore example. Or if we want to check the xor appended at the end  
+        //      In case we just have the bytes array, we do need to remove the header in unpack!
+
+        if let Some(pre) = prepend {
+            match pre {
+                Prepend::Trait => {
+                    // pack_fields.push(quote! {
+                    //     {
+                    //         let packed = { #pack };
+                    //         #pack_bits
+                    //     }
+                    // });
+                },
+                Prepend::Bytes(bytes) => {
+                    pack_fields.push(quote! {
+                        assert!(#num_bytes >= bytes.len(), "Packed bytes array is smaller than prepend array even though we added the prepend length!"); 
+                        std::ptr::copy_nonoverlapping(target, bytes, bytes.len());
+                    });
+                },
+            }
+        }
+
     }
 
     let result_ty = result_type();
diff --git a/packed_struct_codegen/src/pack_parse.rs b/packed_struct_codegen/src/pack_parse.rs
index ff27bfe..d1fb99a 100644
--- a/packed_struct_codegen/src/pack_parse.rs
+++ b/packed_struct_codegen/src/pack_parse.rs
@@ -4,6 +4,7 @@ extern crate syn;
 use crate::pack::*;
 use crate::pack_parse_attributes::*;
 
+use proc_macro2::Span;
 use syn::Meta;
 use syn::Token;
 use syn::punctuated::Punctuated;
@@ -14,8 +15,8 @@ use std::ops::Range;
 
 use crate::utils_syn::{get_expr_int_val, get_single_segment, tokens_to_string};
 
-pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str, wrong_attribute: &str) -> syn::Result<Vec<(String, String)>> {
-    let mut r = vec![];
+pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str, wrong_attribute: &str) -> syn::Result<Vec<(String, syn::Expr)>> {
+    let mut r: Vec<(String, syn::Expr)> = vec![];
 
     for attr in attributes {
         if attr.path().is_ident(wrong_attribute) {
@@ -31,13 +32,16 @@ pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str,
             };
             for meta in nested {
                 match meta {            
-                    syn::Meta::Path(_) => (),
+                    syn::Meta::Path(path) => {
+                        if let Some(key) = path.get_ident() {
+                            // Not the nicest of hacks, but I did not want to make the syn::Expr in the vec an option as well
+                            r.push((key.to_string(), syn::Expr::Lit(syn::ExprLit{ attrs: vec![],lit: syn::Lit::Bool(syn::LitBool { value: true, span: Span::call_site()})})));
+                        }
+                    },
                     syn::Meta::List(_) => (),
                     syn::Meta::NameValue(nv) => {
-                        if let (Some(key), syn::Expr::Lit(lit)) = (nv.path.get_ident(), &nv.value) {
-                            if let syn::Lit::Str(lit) = &lit.lit {
-                                r.push((key.to_string(), lit.value()));
-                            }
+                        if let (Some(key), lit) = (nv.path.get_ident(), &nv.value) {
+                            r.push((key.to_string(), lit.clone()));
                         }
                     }
                 }
@@ -48,6 +52,26 @@ pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str,
     Ok(r)
 }
 
+pub fn parse_sub_attributes_as_string(attributes: &[syn::Attribute], main_attribute: &str, wrong_attribute: &str) -> syn::Result<Vec<(String, String)>> {
+    parse_sub_attributes(attributes, main_attribute, wrong_attribute).and_then(|vec| {
+        Ok(vec.into_iter().map(|(key, expr)| {
+            (key, get_string_from_expr(&expr).unwrap_or_default())
+        }).collect())
+    })
+}
+
+pub fn get_string_from_expr(expr: &syn::Expr) -> Option<String> {
+    if let syn::Expr::Lit(lit) = expr {
+        if let syn::Lit::Str(lit) = &lit.lit {
+            Some(lit.value())
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 /// https://en.wikipedia.org/wiki/Bit_numbering
@@ -86,6 +110,52 @@ impl IntegerEndianness {
     }
 }
 
+#[derive(Clone, Debug)]
+/// https://en.wikipedia.org/wiki/Bit_numbering
+pub enum Prepend{
+    Bytes(Vec<u8>),
+    Trait,
+}
+
+fn get_bytes_from_expr_lit(bytes: &mut Vec<u8>, use_trait: &mut bool, expr_lit: &syn::ExprLit) {
+    match &expr_lit.lit {
+        syn::Lit::Byte( byte) => bytes.push(byte.value()),
+        syn::Lit::ByteStr(st) => bytes.append(&mut st.value()),
+        syn::Lit::Int(i) => {
+            if let Ok(val) = i.base10_parse::<u8>() {
+                bytes.push(val);
+            }
+        },
+        syn::Lit::Bool(bl) => *use_trait = bl.value(),
+        _ => ()
+    }
+}
+
+fn get_bytes_from_expr(bytes: &mut Vec<u8>, use_trait: &mut bool, expr: &syn::Expr) {
+    match expr {
+        syn::Expr::Lit(lit) => get_bytes_from_expr_lit(bytes, use_trait, lit),
+        syn::Expr::Array(arr) => {
+            arr.elems.iter().for_each(|expr| get_bytes_from_expr(bytes, use_trait, &expr) )
+        },
+        _ => (),
+    }
+}
+
+impl Prepend {
+    pub fn from_expr(expr: &syn::Expr) -> Option<Self> {
+        let mut bytes = vec![];
+        let mut use_trait = false;
+        get_bytes_from_expr(&mut bytes, &mut use_trait, expr);
+        if use_trait {
+            Some(Prepend::Trait)
+        } else if bytes.len() > 0 {
+            Some(Prepend::Bytes(bytes))
+        } else {
+            None
+        }
+    }
+}
+
 
 fn get_builtin_type_bit_width(p: &syn::PathSegment) -> syn::Result<Option<usize>> {
     match p.ident.to_string().as_str() {
@@ -166,7 +236,7 @@ fn get_field_mid_positioning(field: &syn::Field) -> syn::Result<FieldMidPosition
         _ => { return Err(syn::Error::new(field.ty.span(), "Unsupported type")); }
     };
 
-    let field_attributes = PackFieldAttribute::parse_all(&parse_sub_attributes(&field.attrs, "packed_field", "packed_struct")?);
+    let field_attributes = PackFieldAttribute::parse_all(&parse_sub_attributes_as_string(&field.attrs, "packed_field", "packed_struct")?);
 
     let bits_position = field_attributes.iter().filter_map(|a| match a {
         &PackFieldAttribute::BitPosition(b) | &PackFieldAttribute::BytePosition(b) => Some(b),
@@ -242,7 +312,7 @@ fn parse_reg_field(field: &syn::Field, ty: &syn::Type, bit_range: &Range<usize>,
     let bit_width = (bit_range.end - bit_range.start) + 1;
     
     let ty_str = tokens_to_string(ty);
-    let field_attributes = PackFieldAttribute::parse_all(&parse_sub_attributes(&field.attrs, "packed_field", "packed_struct")?);
+    let field_attributes = PackFieldAttribute::parse_all(&parse_sub_attributes_as_string(&field.attrs, "packed_field", "packed_struct")?);
 
 
     let is_enum_ty = field_attributes.iter().filter_map(|a| match *a {
@@ -349,8 +419,6 @@ pub fn parse_num(s: &str) -> Result<usize, String> {
     }
 }
 
-
-
 pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
     let attributes = PackStructAttribute::parse_all(&parse_sub_attributes(&ast.attrs, "packed_struct", "packed_field")?);
 
@@ -425,7 +493,7 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
         }
     }
 
-    let num_bits: usize = {
+    let mut num_bits: usize = {
         if let Some(struct_size_bytes) = struct_size_bytes {
             struct_size_bytes * 8
         } else {
@@ -437,6 +505,17 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
         }
     };
 
+    let mut prepend: Option<Prepend> = None;
+
+    attributes.iter().for_each(|a| {
+        if let PackStructAttribute::Prepend(prep) = a {
+            if let Prepend::Bytes(bytes) = prep {
+                num_bits += bytes.len() * 8;
+            }
+            prepend = Some(prep.to_owned());
+        }
+    });
+
     let num_bytes = (num_bits as f32 / 8.0).ceil() as usize;
 
     if first_field_is_auto_positioned && (num_bits % 8) != 0 && struct_size_bytes.is_none() {
@@ -477,6 +556,7 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
         data_struct,
         fields: fields_parsed,
         num_bytes,
-        num_bits
+        num_bits,
+        prepend,
     })
 }
diff --git a/packed_struct_codegen/src/pack_parse_attributes.rs b/packed_struct_codegen/src/pack_parse_attributes.rs
index f44bc82..c44dcdc 100644
--- a/packed_struct_codegen/src/pack_parse_attributes.rs
+++ b/packed_struct_codegen/src/pack_parse_attributes.rs
@@ -5,7 +5,9 @@ pub enum PackStructAttributeKind {
     SizeBytes,
     //SizeBits,
     DefaultIntEndianness,
-    BitNumbering
+    BitNumbering,
+    Prepend,
+    Append,
 }
 
 impl PackStructAttributeKind {
@@ -16,7 +18,9 @@ impl PackStructAttributeKind {
             SizeBytes => "size_bytes",
             //SizeBits => "size_bits",
             DefaultIntEndianness => "endian",
-            BitNumbering => "bit_numbering"
+            BitNumbering => "bit_numbering",
+            Prepend => "prepend",
+            Append => "append"
         }
     }
 }
@@ -25,26 +29,34 @@ pub enum PackStructAttribute {
     SizeBytes(usize),
     //SizeBits(usize),
     DefaultIntEndianness(IntegerEndianness),
-    BitNumbering(BitNumbering)
+    BitNumbering(BitNumbering),
+    Prepend(Prepend),
+    // Append(F, usize),
 }
 
 impl PackStructAttribute {
-    pub fn parse(name: &str, val: &str) -> Result<Self, String> {
+    pub fn parse(name: &str, val: &syn::Expr) -> Result<Self, String> {
         if name == PackStructAttributeKind::DefaultIntEndianness.get_attr_name() {
+            let val = &get_string_from_expr(val).unwrap_or_default();
             let v = IntegerEndianness::from_str(val).ok_or_else(|| format!("Invalid default int endian value: {}", val))?;
             return Ok(PackStructAttribute::DefaultIntEndianness(v));
         }
 
         if name == PackStructAttributeKind::BitNumbering.get_attr_name() {
-            let b = BitNumbering::from_str(val).expect("Invalid bit numbering attribute value");
+            let b = BitNumbering::from_str(&get_string_from_expr(val).unwrap_or_default()).expect("Invalid bit numbering attribute value");
             return Ok(PackStructAttribute::BitNumbering(b));
         }
 
         if name == PackStructAttributeKind::SizeBytes.get_attr_name() {
-            let b = parse_num(val)?;
+            let b = parse_num(&get_string_from_expr(val).unwrap_or_default())?;
             return Ok(PackStructAttribute::SizeBytes(b));
         }
 
+        if name == PackStructAttributeKind::Prepend.get_attr_name() {
+            let b = Prepend::from_expr(val).expect("Invalid prepend value");
+            return Ok(PackStructAttribute::Prepend(b));
+        }
+
         /*
         if name == PackStructAttributeKind::SizeBits.get_attr_name() {
             let b = parse_num(val);
@@ -52,10 +64,11 @@ impl PackStructAttribute {
         }
         */
 
+        let val = &get_string_from_expr(val).unwrap_or_default();
         Err(format!("Unknown struct attribute: {}, value {}", name, val))
     }
 
-    pub fn parse_all(attributes: &[(String, String)]) -> Vec<Self> {
+    pub fn parse_all(attributes: &[(String, syn::Expr)]) -> Vec<Self> {
         let mut r = vec![];
         for (name, val) in attributes {
             if let Ok(attr) = Self::parse(name, val) {

From 6a291162259c08ec617a4be48ebe4648619e135d Mon Sep 17 00:00:00 2001
From: "Jomer.Dev" <Jomer.Dev@posteo.de>
Date: Fri, 13 Oct 2023 14:29:43 +0200
Subject: [PATCH 2/7] Remove prepend attribute Add header and footer attributes
 Add header and footer traits Add optional validation through header and
 footer

---
 packed_struct/src/packing.rs                  |  34 ++++-
 packed_struct_codegen/src/pack.rs             |   3 +-
 packed_struct_codegen/src/pack_codegen.rs     | 122 +++++++++++++-----
 packed_struct_codegen/src/pack_parse.rs       | 122 +++++++++++++-----
 .../src/pack_parse_attributes.rs              |  37 ++++--
 5 files changed, 238 insertions(+), 80 deletions(-)

diff --git a/packed_struct/src/packing.rs b/packed_struct/src/packing.rs
index f38ffa6..6a5fa96 100644
--- a/packed_struct/src/packing.rs
+++ b/packed_struct/src/packing.rs
@@ -19,6 +19,30 @@ pub trait PackedStruct where Self: Sized {
     fn unpack(src: &Self::ByteArray) -> PackingResult<Self>;
 }
 
+pub trait PackedStructHeader where Self: PackedStruct + Sized {
+    /// The appropriately sized byte array into which this structure will be packed, for example [u8; 2]. 
+    type HeaderByteArray : ByteArray;
+    
+    /// Returns the header data to attach it to the front of the packed data
+    fn get_data(&self, data: &[u8]) -> PackingResult<Self::HeaderByteArray>;
+    /// Validates the structure/footer from a byte array when unpacking.
+    fn validate_data(_src: &[u8]) -> PackingResult<()> {
+        Ok(())
+    }
+}
+
+pub trait PackedStructFooter where Self: PackedStruct + Sized {
+    /// The appropriately sized byte array into which this structure will be packed, for example [u8; 2]. 
+    type FooterByteArray : ByteArray;
+    
+    /// Returns the footer data to attach it to the end of the packed data
+    fn get_data(&self, data: &[u8]) -> PackingResult<Self::FooterByteArray>;
+    /// Validates the structure/footer from a byte array when unpacking.
+    fn validate_data(_src: &[u8]) -> PackingResult<()> {
+        Ok(())
+    }
+}
+
 /// Infos about a particular type that can be packaged.
 pub trait PackedStructInfo {
     /// Number of bits that this structure occupies when being packed.
@@ -44,7 +68,7 @@ pub trait PackedStructSlice where Self: Sized {
 }
 
 #[cfg_attr(feature = "use_serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 /// Packing errors that might occur during packing or unpacking
 pub enum PackingError {
     InvalidValue,
@@ -56,7 +80,8 @@ pub enum PackingError {
     BufferSizeMismatch { expected: usize, actual: usize },
     BufferModMismatch { actual_size: usize, modulo_required: usize },
     SliceIndexingError { slice_len: usize },
-    InternalError
+    InternalError,
+    UserError(String)
 }
 
 impl crate::Display for PackingError {
@@ -68,7 +93,7 @@ impl crate::Display for PackingError {
 #[cfg(feature="std")]
 impl ::std::error::Error for PackingError {
     fn description(&self) -> &str {
-        match *self {
+        match self {
             PackingError::InvalidValue => "Invalid value",
             PackingError::BitsError => "Bits error",
             PackingError::BufferTooSmall => "Buffer too small",            
@@ -78,7 +103,8 @@ impl ::std::error::Error for PackingError {
             PackingError::BufferModMismatch { .. } => "The structure's size is not a multiple of the item's size",
             PackingError::SliceIndexingError { .. } => "Failed to index into a slice",
             PackingError::MoreThanOneDynamicType => "Only one dynamically sized type is supported in the tuple",
-            PackingError::InternalError => "Internal error"
+            PackingError::InternalError => "Internal error",
+            PackingError::UserError(err) => &err
         }
     }
 }
diff --git a/packed_struct_codegen/src/pack.rs b/packed_struct_codegen/src/pack.rs
index 3612bf5..71aff07 100644
--- a/packed_struct_codegen/src/pack.rs
+++ b/packed_struct_codegen/src/pack.rs
@@ -50,7 +50,8 @@ pub struct PackStruct<'a> {
     pub num_bits: usize,
     pub data_struct: &'a syn::DataStruct,
     pub derive_input: &'a syn::DeriveInput,
-    pub prepend: Option<Prepend>,
+    pub header: Option<Header>,
+    pub footer: Option<Footer>,
 }
 
 
diff --git a/packed_struct_codegen/src/pack_codegen.rs b/packed_struct_codegen/src/pack_codegen.rs
index 0380d63..2082459 100644
--- a/packed_struct_codegen/src/pack_codegen.rs
+++ b/packed_struct_codegen/src/pack_codegen.rs
@@ -4,7 +4,8 @@ extern crate syn;
 use crate::pack::*;
 use crate::pack_codegen_docs::*;
 use crate::common::*;
-use crate::pack_parse::Prepend;
+use crate::pack_parse::Footer;
+use crate::pack_parse::Header;
 use syn::spanned::Spanned;
 use crate::utils::*;
 
@@ -19,16 +20,91 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
     let num_bytes = parsed.num_bytes;
     let num_bits = parsed.num_bits;
 
-    let prepend = &parsed.prepend;
     
-
     let mut pack_fields = vec![];
     let mut unpack_fields = vec![];
     let mut unpack_struct_set = vec![];
+    
+    let header = &parsed.header;
+    let mut header_offset = 0;
+    let mut header_trait_token_get_data = quote!{};
+    let mut header_trait_token_validate = quote!{};
+
+    if let Some(pre) = header {
+        match pre {
+            Header::Trait(size) => {
+                header_offset = *size;
+                header_trait_token_get_data = quote! {
+                    {
+                        let bytes = Self::get_data(&self, &target)?;
+                        assert!(#num_bytes >= bytes.len(), "Packed bytes array is smaller than header array even though we added the header length!"); 
+                        assert!(#size == bytes.len(), "Header size set with attribute is not equal to header array size returned by PackedStructHeader trait!"); 
+                        target[0..bytes.len()].copy_from_slice(&bytes);
+                    }
+                };
+                header_trait_token_validate = quote! {
+                    {
+                        Self::validate_data(src)?;
+                    }
+                };
+            },
+            Header::Bytes(bytes) => {
+                header_offset = bytes.len();
+                pack_fields.push(quote! {
+                    {
+                        let byt = vec![#(#bytes),*];
+                        assert!(#num_bytes >= byt.len(), "Packed bytes array is smaller than header array even though we added the header length!"); 
+                        target[0..byt.len()].copy_from_slice(&byt);
+                    }
+                });
+                // We don't need to generate something for unpack here, since we pass an offset to pack_bits unpack ignores any header or footer data
+            },
+        }
+    }
+
+    let footer = &parsed.footer;
+    let mut footer_trait_token_get_data = quote!{};
+    let mut footer_trait_token_validate = quote!{};
+
+    if let Some(app) = footer {
+        match app {
+            Footer::Trait(size) => {
+                let footer_offset = num_bytes - *size;
+                footer_trait_token_get_data = quote! {
+                    {
+                        let bytes = Self::get_data(&self, &target)?;
+                        assert!(#num_bytes >= bytes.len(), "Packed bytes array is smaller than footer array even though we added the footer length!"); 
+                        assert!(#size == bytes.len(), "Footer size set with attribute is not equal to footer array size returned by PackedStructFooter trait!"); 
+                        target[#footer_offset..].copy_from_slice(&bytes);
+                    }
+                };
+                footer_trait_token_validate = quote! {
+                    {
+                        Self::validate_data(src)?;
+                    }
+                };
+            },
+            Footer::Bytes(bytes) => {
+                let footer_offset = num_bytes - bytes.len();
+                pack_fields.push(quote! {
+                    {
+                        let byt = vec![#(#bytes),*];
+                        assert!(#num_bytes >= byt.len(), "Packed bytes array is smaller than footer array even though we added the footer length!"); 
+                        target[#footer_offset..].copy_from_slice(&byt);
+                    }
+                });
+                // We don't need to generate something for unpack here, since we pass an offset to pack_bits unpack ignores any header or footer data
+            },
+        }
+    }
 
     {
+        // We want the validation for header and footer to happen before we unpack the rest of the fields, since there might be broken data if a validation fails
+        unpack_fields.push(header_trait_token_validate);
+        unpack_fields.push(footer_trait_token_validate);
+
         let mut reg  = |src: &dyn quote::ToTokens, target: &dyn quote::ToTokens, field: &FieldRegular| -> syn::Result<()> {
-            let bits = pack_bits(field);
+            let bits = pack_bits(field, header_offset);
 
             let pack = pack_field(src, field);
             let unpack = unpack_field(field)?;
@@ -82,30 +158,8 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
             }        
         }
 
-        //TODO: Move prepend check to before the reg. Either make target be a slice into target after the header or pass an offset into pack_bits to make sure headers don't get overwritten
-        //      Call teh trait method if the enum is set to that. Add the trait. 
-        //      Do the same stuff for append
-        //      The trait should return a result, in case we want to verify that the header is correct before unpacking fore example. Or if we want to check the xor appended at the end  
-        //      In case we just have the bytes array, we do need to remove the header in unpack!
-
-        if let Some(pre) = prepend {
-            match pre {
-                Prepend::Trait => {
-                    // pack_fields.push(quote! {
-                    //     {
-                    //         let packed = { #pack };
-                    //         #pack_bits
-                    //     }
-                    // });
-                },
-                Prepend::Bytes(bytes) => {
-                    pack_fields.push(quote! {
-                        assert!(#num_bytes >= bytes.len(), "Packed bytes array is smaller than prepend array even though we added the prepend length!"); 
-                        std::ptr::copy_nonoverlapping(target, bytes, bytes.len());
-                    });
-                },
-            }
-        }
+        pack_fields.push(header_trait_token_get_data);
+        pack_fields.push(footer_trait_token_get_data);
 
     }
 
@@ -139,7 +193,7 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
             #[allow(unused_imports, unused_parens)]
             fn pack(&self) -> ::packed_struct::PackingResult<Self::ByteArray> {
                 use ::packed_struct::*;
-
+                
                 let mut target = [0 as u8; #num_bytes];
 
                 #(#pack_fields)*
@@ -180,13 +234,13 @@ struct PackBitsCopy {
     unpack: proc_macro2::TokenStream
 }
 
-fn pack_bits(field: &FieldRegular) -> PackBitsCopy {
+fn pack_bits(field: &FieldRegular, header_offset: usize) -> PackBitsCopy {
     // memcpy
     if (field.bit_range_rust.start % 8) == 0 && (field.bit_range_rust.end % 8) == 0 &&
        (field.bit_range_rust.len() % 8) == 0 && field.bit_range_rust.len() >= 8 
     {
-        let start = field.bit_range_rust.start / 8;
-        let end = field.bit_range_rust.end / 8;
+        let start = field.bit_range_rust.start / 8 + header_offset;
+        let end = field.bit_range_rust.end / 8 + header_offset;
         
         PackBitsCopy {
             pack: quote! {
@@ -200,8 +254,8 @@ fn pack_bits(field: &FieldRegular) -> PackBitsCopy {
         }
     } else {
         let packed_field_len = (field.bit_width as f32 / 8.0).ceil() as usize; 
-        let start_byte = (field.bit_range_rust.start as f32 / 8.0).floor() as usize;
-        let shift = ((packed_field_len as isize*8) - (field.bit_width as isize)) - (field.bit_range_rust.start as isize - (start_byte as isize * 8));
+        let start_byte = (field.bit_range_rust.start as f32 / 8.0).floor() as usize + header_offset;
+        let shift = ((packed_field_len as isize*8) - (field.bit_width as isize)) - (field.bit_range_rust.start as isize - ((start_byte - header_offset) as isize * 8));
 
         let emit_shift = |s: isize| {
             match s {
diff --git a/packed_struct_codegen/src/pack_parse.rs b/packed_struct_codegen/src/pack_parse.rs
index d1fb99a..3c5a47f 100644
--- a/packed_struct_codegen/src/pack_parse.rs
+++ b/packed_struct_codegen/src/pack_parse.rs
@@ -4,7 +4,6 @@ extern crate syn;
 use crate::pack::*;
 use crate::pack_parse_attributes::*;
 
-use proc_macro2::Span;
 use syn::Meta;
 use syn::Token;
 use syn::punctuated::Punctuated;
@@ -32,12 +31,7 @@ pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str,
             };
             for meta in nested {
                 match meta {            
-                    syn::Meta::Path(path) => {
-                        if let Some(key) = path.get_ident() {
-                            // Not the nicest of hacks, but I did not want to make the syn::Expr in the vec an option as well
-                            r.push((key.to_string(), syn::Expr::Lit(syn::ExprLit{ attrs: vec![],lit: syn::Lit::Bool(syn::LitBool { value: true, span: Span::call_site()})})));
-                        }
-                    },
+                    syn::Meta::Path(_) => {},
                     syn::Meta::List(_) => (),
                     syn::Meta::NameValue(nv) => {
                         if let (Some(key), lit) = (nv.path.get_ident(), &nv.value) {
@@ -110,14 +104,8 @@ impl IntegerEndianness {
     }
 }
 
-#[derive(Clone, Debug)]
-/// https://en.wikipedia.org/wiki/Bit_numbering
-pub enum Prepend{
-    Bytes(Vec<u8>),
-    Trait,
-}
 
-fn get_bytes_from_expr_lit(bytes: &mut Vec<u8>, use_trait: &mut bool, expr_lit: &syn::ExprLit) {
+fn get_bytes_from_expr_lit(bytes: &mut Vec<u8>, expr_lit: &syn::ExprLit) {
     match &expr_lit.lit {
         syn::Lit::Byte( byte) => bytes.push(byte.value()),
         syn::Lit::ByteStr(st) => bytes.append(&mut st.value()),
@@ -126,36 +114,92 @@ fn get_bytes_from_expr_lit(bytes: &mut Vec<u8>, use_trait: &mut bool, expr_lit:
                 bytes.push(val);
             }
         },
-        syn::Lit::Bool(bl) => *use_trait = bl.value(),
         _ => ()
     }
 }
 
-fn get_bytes_from_expr(bytes: &mut Vec<u8>, use_trait: &mut bool, expr: &syn::Expr) {
+fn get_bytes_from_expr(bytes: &mut Vec<u8>, expr: &syn::Expr) {
     match expr {
-        syn::Expr::Lit(lit) => get_bytes_from_expr_lit(bytes, use_trait, lit),
+        syn::Expr::Lit(lit) => get_bytes_from_expr_lit(bytes, lit),
         syn::Expr::Array(arr) => {
-            arr.elems.iter().for_each(|expr| get_bytes_from_expr(bytes, use_trait, &expr) )
+            arr.elems.iter().for_each(|expr| get_bytes_from_expr(bytes, &expr) )
         },
         _ => (),
     }
 }
 
-impl Prepend {
+#[derive(Clone, Debug)]
+pub enum Header{
+    Bytes(Vec<u8>),
+    Trait(usize),
+}
+
+impl Header {
     pub fn from_expr(expr: &syn::Expr) -> Option<Self> {
         let mut bytes = vec![];
-        let mut use_trait = false;
-        get_bytes_from_expr(&mut bytes, &mut use_trait, expr);
-        if use_trait {
-            Some(Prepend::Trait)
-        } else if bytes.len() > 0 {
-            Some(Prepend::Bytes(bytes))
+        get_bytes_from_expr(&mut bytes,  expr);if bytes.len() > 0 {
+            Some(Header::Bytes(bytes))
+        } else {
+            None
+        }
+    }
+
+    pub fn from_trait_expr(expr: &syn::Expr) -> Option<Self> {
+        let mut len: usize = 0;
+        match expr {
+            syn::Expr::Lit(lit) => {
+                if let syn::Lit::Int(int) = &lit.lit {
+                    if let Ok(val) = int.base10_parse::<usize>() {
+                        len = val;
+                    }
+                }
+            },
+            _ => ()
+        }
+        if len > 0 {
+            Some(Header::Trait(len))
         } else {
             None
         }
     }
 }
 
+#[derive(Clone, Debug)]
+pub enum Footer{
+    Bytes(Vec<u8>),
+    Trait(usize),
+}
+
+impl Footer {
+    pub fn from_expr(expr: &syn::Expr) -> Option<Self> {
+        let mut bytes = vec![];
+        get_bytes_from_expr(&mut bytes,  expr);
+        if bytes.len() > 0 {
+            Some(Footer::Bytes(bytes))
+        } else {
+            None
+        }
+    }
+
+    pub fn from_trait_expr(expr: &syn::Expr) -> Option<Self> {
+        let mut len: usize = 0;
+        match expr {
+            syn::Expr::Lit(lit) => {
+                if let syn::Lit::Int(int) = &lit.lit {
+                    if let Ok(val) = int.base10_parse::<usize>() {
+                        len = val;
+                    }
+                }
+            },
+            _ => ()
+        }
+        if len > 0 {
+            Some(Footer::Trait(len))
+        } else {
+            None
+        }
+    }
+}
 
 fn get_builtin_type_bit_width(p: &syn::PathSegment) -> syn::Result<Option<usize>> {
     match p.ident.to_string().as_str() {
@@ -505,14 +549,27 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
         }
     };
 
-    let mut prepend: Option<Prepend> = None;
+    let mut header: Option<Header> = None;
 
     attributes.iter().for_each(|a| {
-        if let PackStructAttribute::Prepend(prep) = a {
-            if let Prepend::Bytes(bytes) = prep {
-                num_bits += bytes.len() * 8;
-            }
-            prepend = Some(prep.to_owned());
+        if let PackStructAttribute::Header(prep) = a {
+            num_bits += 8 * match prep {
+                Header::Bytes(bytes) => bytes.len(),
+                Header::Trait(size) => *size,
+            };
+            header = Some(prep.to_owned());
+        }
+    });
+
+    let mut footer: Option<Footer> = None;
+
+    attributes.iter().for_each(|a| {
+        if let PackStructAttribute::Footer(app) = a {
+            num_bits += 8 * match app {
+                Footer::Bytes(bytes) => bytes.len(),
+                Footer::Trait(size) => *size,
+            };
+            footer = Some(app.to_owned());
         }
     });
 
@@ -557,6 +614,7 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
         fields: fields_parsed,
         num_bytes,
         num_bits,
-        prepend,
+        header,
+        footer
     })
 }
diff --git a/packed_struct_codegen/src/pack_parse_attributes.rs b/packed_struct_codegen/src/pack_parse_attributes.rs
index c44dcdc..907987e 100644
--- a/packed_struct_codegen/src/pack_parse_attributes.rs
+++ b/packed_struct_codegen/src/pack_parse_attributes.rs
@@ -6,8 +6,10 @@ pub enum PackStructAttributeKind {
     //SizeBits,
     DefaultIntEndianness,
     BitNumbering,
-    Prepend,
-    Append,
+    Header,
+    HeaderWithTrait,
+    Footer,
+    FooterWithTrait,
 }
 
 impl PackStructAttributeKind {
@@ -19,8 +21,10 @@ impl PackStructAttributeKind {
             //SizeBits => "size_bits",
             DefaultIntEndianness => "endian",
             BitNumbering => "bit_numbering",
-            Prepend => "prepend",
-            Append => "append"
+            Header => "header",
+            HeaderWithTrait => "header_size",
+            Footer => "footer",
+            FooterWithTrait => "footer_size"
         }
     }
 }
@@ -30,8 +34,8 @@ pub enum PackStructAttribute {
     //SizeBits(usize),
     DefaultIntEndianness(IntegerEndianness),
     BitNumbering(BitNumbering),
-    Prepend(Prepend),
-    // Append(F, usize),
+    Header(Header),
+    Footer(Footer),
 }
 
 impl PackStructAttribute {
@@ -52,9 +56,24 @@ impl PackStructAttribute {
             return Ok(PackStructAttribute::SizeBytes(b));
         }
 
-        if name == PackStructAttributeKind::Prepend.get_attr_name() {
-            let b = Prepend::from_expr(val).expect("Invalid prepend value");
-            return Ok(PackStructAttribute::Prepend(b));
+        if name == PackStructAttributeKind::Header.get_attr_name() {
+            let b = Header::from_expr(val).expect("Invalid prepend value");
+            return Ok(PackStructAttribute::Header(b));
+        }
+
+        if name == PackStructAttributeKind::Footer.get_attr_name() {
+            let b = Footer::from_expr(val).expect("Invalid append value");
+            return Ok(PackStructAttribute::Footer(b));
+        }
+
+        if name == PackStructAttributeKind::HeaderWithTrait.get_attr_name() {
+            let b = Header::from_trait_expr(val).expect("Invalid prepend value");
+            return Ok(PackStructAttribute::Header(b));
+        }
+
+        if name == PackStructAttributeKind::FooterWithTrait.get_attr_name() {
+            let b = Footer::from_trait_expr(val).expect("Invalid append value");
+            return Ok(PackStructAttribute::Footer(b));
         }
 
         /*

From 0a5394efedded82064aa0b7ca4db13fbc2244057 Mon Sep 17 00:00:00 2001
From: "Jomer.Dev" <Jomer.Dev@posteo.de>
Date: Fri, 13 Oct 2023 15:29:51 +0200
Subject: [PATCH 3/7] Add examples, fix trait naming

---
 packed_struct/src/packing.rs              |   8 +-
 packed_struct_codegen/src/pack_codegen.rs |   8 +-
 packed_struct_examples/src/example2.rs    | 129 ++++++++++++++++++++++
 packed_struct_examples/src/lib.rs         |   1 +
 4 files changed, 138 insertions(+), 8 deletions(-)
 create mode 100644 packed_struct_examples/src/example2.rs

diff --git a/packed_struct/src/packing.rs b/packed_struct/src/packing.rs
index 6a5fa96..53aa031 100644
--- a/packed_struct/src/packing.rs
+++ b/packed_struct/src/packing.rs
@@ -24,9 +24,9 @@ pub trait PackedStructHeader where Self: PackedStruct + Sized {
     type HeaderByteArray : ByteArray;
     
     /// Returns the header data to attach it to the front of the packed data
-    fn get_data(&self, data: &[u8]) -> PackingResult<Self::HeaderByteArray>;
+    fn get_header(&self, data: &[u8]) -> PackingResult<Self::HeaderByteArray>;
     /// Validates the structure/footer from a byte array when unpacking.
-    fn validate_data(_src: &[u8]) -> PackingResult<()> {
+    fn validate_header(_src: &[u8]) -> PackingResult<()> {
         Ok(())
     }
 }
@@ -36,9 +36,9 @@ pub trait PackedStructFooter where Self: PackedStruct + Sized {
     type FooterByteArray : ByteArray;
     
     /// Returns the footer data to attach it to the end of the packed data
-    fn get_data(&self, data: &[u8]) -> PackingResult<Self::FooterByteArray>;
+    fn get_footer(&self, data: &[u8]) -> PackingResult<Self::FooterByteArray>;
     /// Validates the structure/footer from a byte array when unpacking.
-    fn validate_data(_src: &[u8]) -> PackingResult<()> {
+    fn validate_footer(_src: &[u8]) -> PackingResult<()> {
         Ok(())
     }
 }
diff --git a/packed_struct_codegen/src/pack_codegen.rs b/packed_struct_codegen/src/pack_codegen.rs
index 2082459..7645c53 100644
--- a/packed_struct_codegen/src/pack_codegen.rs
+++ b/packed_struct_codegen/src/pack_codegen.rs
@@ -36,7 +36,7 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
                 header_offset = *size;
                 header_trait_token_get_data = quote! {
                     {
-                        let bytes = Self::get_data(&self, &target)?;
+                        let bytes = Self::get_header(&self, &target)?;
                         assert!(#num_bytes >= bytes.len(), "Packed bytes array is smaller than header array even though we added the header length!"); 
                         assert!(#size == bytes.len(), "Header size set with attribute is not equal to header array size returned by PackedStructHeader trait!"); 
                         target[0..bytes.len()].copy_from_slice(&bytes);
@@ -44,7 +44,7 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
                 };
                 header_trait_token_validate = quote! {
                     {
-                        Self::validate_data(src)?;
+                        Self::validate_header(src)?;
                     }
                 };
             },
@@ -72,7 +72,7 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
                 let footer_offset = num_bytes - *size;
                 footer_trait_token_get_data = quote! {
                     {
-                        let bytes = Self::get_data(&self, &target)?;
+                        let bytes = Self::get_footer(&self, &target)?;
                         assert!(#num_bytes >= bytes.len(), "Packed bytes array is smaller than footer array even though we added the footer length!"); 
                         assert!(#size == bytes.len(), "Footer size set with attribute is not equal to footer array size returned by PackedStructFooter trait!"); 
                         target[#footer_offset..].copy_from_slice(&bytes);
@@ -80,7 +80,7 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
                 };
                 footer_trait_token_validate = quote! {
                     {
-                        Self::validate_data(src)?;
+                        Self::validate_footer(src)?;
                     }
                 };
             },
diff --git a/packed_struct_examples/src/example2.rs b/packed_struct_examples/src/example2.rs
new file mode 100644
index 0000000..d73afa7
--- /dev/null
+++ b/packed_struct_examples/src/example2.rs
@@ -0,0 +1,129 @@
+//! Documentation example for the header and footer attributes and traits
+
+use packed_struct::{prelude::*, PackedStructHeader, PackedStructFooter};
+
+// Sometimes you want a static header or footer on a packed struckt. For example when you want to send the packed struct as a command via serial and you need the command to have a header
+#[derive(PackedStruct, Debug, Copy, Clone, PartialEq)]
+#[packed_struct(bit_numbering = "msb0", endian = "msb", header = [0x80, 0x60], footer = 0x16)]
+pub struct FunctionCommand {
+    #[packed_field(bytes = "0..=1")]
+    pub address: u16,
+    #[packed_field(bits = "16")]
+    pub f1: bool,
+    #[packed_field(bits = "17")]
+    pub f2: bool,
+    #[packed_field(bits = "18")]
+    pub f3: bool,
+    #[packed_field(bits = "19")]
+    pub f4: bool,
+    #[packed_field(bits = "20")]
+    pub f5: bool,
+    #[packed_field(bits = "21")]
+    pub f6: bool,
+    #[packed_field(bits = "22")]
+    pub f7: bool,
+    #[packed_field(bits = "23")]
+    pub f8: bool,
+}
+
+#[test]
+fn test_static_header_and_footer() {
+    let fun = FunctionCommand {
+        address: 1,
+        f1: true,
+        f2: false,
+        f3: true,
+        f4: false,
+        f5: false,
+        f6: true,
+        f7: false,
+        f8: true
+    };
+
+    let packed = fun.pack().unwrap();
+    assert_eq!(&packed, &[0x80 as u8, 0x60, 0x00, 0x01, 0b10100101, 0x16]);
+
+    let _unpacked = FunctionCommand::unpack(&[0x80 as u8, 0x60, 0x00, 0x01, 0b10100101, 0x00]).unwrap();
+
+    println!("{}", fun);
+}
+
+// Other times you might need to specify the header dynamically, for example if the header is different if all fields are false. You might also want to make sure your struct gets received correctly put an xor value in the footer
+#[derive(PackedStruct, Debug, Clone, PartialEq)]
+#[packed_struct(bit_numbering = "msb0", endian = "msb", header_size = 1, footer_size = 1)]
+pub struct DynamicCommand {
+    #[packed_field(bits = "0")]
+    pub f1: bool,
+    #[packed_field(bits = "1")]
+    pub f2: bool,
+    #[packed_field(bits = "2")]
+    pub f3: bool,
+    #[packed_field(bits = "3")]
+    pub f4: bool,
+    #[packed_field(bits = "4")]
+    pub f5: bool,
+    #[packed_field(bits = "5")]
+    pub f6: bool,
+    #[packed_field(bits = "6")]
+    pub f7: bool,
+    #[packed_field(bits = "7")]
+    pub f8: bool,
+}
+
+impl PackedStructHeader for DynamicCommand {
+    type HeaderByteArray = [u8; 1];
+
+    fn get_header(&self, data: &[u8]) -> packed_struct::PackingResult<Self::HeaderByteArray> {
+        let header = if data[1] == 0 {
+            [0x00]
+        } else {
+            [0x80]
+        };
+        Ok(header)
+    }
+}
+
+impl PackedStructFooter for DynamicCommand {
+    type FooterByteArray = [u8; 1];
+
+    fn get_footer(&self, data: &[u8]) -> packed_struct::PackingResult<Self::FooterByteArray> {
+        // Note that the header is already part of the data at this point
+        let mut xor: u8 = 0;
+        data.into_iter().for_each(|value| xor ^= value);
+        Ok([xor])
+    }
+
+    fn validate_footer(src: &[u8]) -> packed_struct::PackingResult<()> {
+        let mut xor: u8 = 0;
+        src[0..src.len()].into_iter().for_each(|value| xor ^= value);
+        if src.ends_with(&[xor]) {
+            Ok(())
+        } else {
+            Err(PackingError::UserError(format!("Invalid xor: {} to {:?}", xor, src.last().unwrap())))
+        }
+    }
+}
+
+#[test]
+fn test_dynamic_header_and_footer() {
+    let dy = DynamicCommand {
+        f1: true,
+        f2: false,
+        f3: true,
+        f4: false,
+        f5: false,
+        f6: true,
+        f7: false,
+        f8: true
+    };
+
+    let packed = dy.pack().unwrap();
+    assert_eq!(&packed, &[0x80 as u8,0b10100101, 0x25]);
+
+    // We've set the footer to zero so it will fail to unpack
+    let unpacked_result = DynamicCommand::unpack(&[0x80 as u8, 0b10100101, 0x00]);
+
+    assert_eq!(unpacked_result, Err(PackingError::UserError("Invalid xor: 37 to 0".to_owned())));
+
+    println!("{}", dy);
+}
\ No newline at end of file
diff --git a/packed_struct_examples/src/lib.rs b/packed_struct_examples/src/lib.rs
index a324a22..17baa4b 100644
--- a/packed_struct_examples/src/lib.rs
+++ b/packed_struct_examples/src/lib.rs
@@ -4,6 +4,7 @@ extern crate packed_struct;
 use packed_struct::prelude::*;
 
 pub mod example1;
+pub mod example2;
 
 
 /// MultiWii status structure

From d76288a97c3ff90cb6ed25bdbc250bf4cca4b30c Mon Sep 17 00:00:00 2001
From: "Jomer.Dev" <Jomer.Dev@posteo.de>
Date: Fri, 13 Oct 2023 16:12:51 +0200
Subject: [PATCH 4/7] Fix build errors

---
 packed_struct_codegen/src/pack_parse.rs | 39 +++++++++++--------------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/packed_struct_codegen/src/pack_parse.rs b/packed_struct_codegen/src/pack_parse.rs
index 3c5a47f..2a56d50 100644
--- a/packed_struct_codegen/src/pack_parse.rs
+++ b/packed_struct_codegen/src/pack_parse.rs
@@ -47,10 +47,10 @@ pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str,
 }
 
 pub fn parse_sub_attributes_as_string(attributes: &[syn::Attribute], main_attribute: &str, wrong_attribute: &str) -> syn::Result<Vec<(String, String)>> {
-    parse_sub_attributes(attributes, main_attribute, wrong_attribute).and_then(|vec| {
-        Ok(vec.into_iter().map(|(key, expr)| {
+    parse_sub_attributes(attributes, main_attribute, wrong_attribute).map(|vec| {
+        vec.into_iter().map(|(key, expr)| {
             (key, get_string_from_expr(&expr).unwrap_or_default())
-        }).collect())
+        }).collect()
     })
 }
 
@@ -122,7 +122,7 @@ fn get_bytes_from_expr(bytes: &mut Vec<u8>, expr: &syn::Expr) {
     match expr {
         syn::Expr::Lit(lit) => get_bytes_from_expr_lit(bytes, lit),
         syn::Expr::Array(arr) => {
-            arr.elems.iter().for_each(|expr| get_bytes_from_expr(bytes, &expr) )
+            arr.elems.iter().for_each(|expr| get_bytes_from_expr(bytes, expr) )
         },
         _ => (),
     }
@@ -137,7 +137,8 @@ pub enum Header{
 impl Header {
     pub fn from_expr(expr: &syn::Expr) -> Option<Self> {
         let mut bytes = vec![];
-        get_bytes_from_expr(&mut bytes,  expr);if bytes.len() > 0 {
+        get_bytes_from_expr(&mut bytes,  expr);
+        if !bytes.is_empty() {
             Some(Header::Bytes(bytes))
         } else {
             None
@@ -146,15 +147,12 @@ impl Header {
 
     pub fn from_trait_expr(expr: &syn::Expr) -> Option<Self> {
         let mut len: usize = 0;
-        match expr {
-            syn::Expr::Lit(lit) => {
-                if let syn::Lit::Int(int) = &lit.lit {
-                    if let Ok(val) = int.base10_parse::<usize>() {
-                        len = val;
-                    }
+        if let syn::Expr::Lit(lit) = expr {
+            if let syn::Lit::Int(int) = &lit.lit {
+                if let Ok(val) = int.base10_parse::<usize>() {
+                    len = val;
                 }
-            },
-            _ => ()
+            }
         }
         if len > 0 {
             Some(Header::Trait(len))
@@ -174,7 +172,7 @@ impl Footer {
     pub fn from_expr(expr: &syn::Expr) -> Option<Self> {
         let mut bytes = vec![];
         get_bytes_from_expr(&mut bytes,  expr);
-        if bytes.len() > 0 {
+        if !bytes.is_empty() {
             Some(Footer::Bytes(bytes))
         } else {
             None
@@ -183,15 +181,12 @@ impl Footer {
 
     pub fn from_trait_expr(expr: &syn::Expr) -> Option<Self> {
         let mut len: usize = 0;
-        match expr {
-            syn::Expr::Lit(lit) => {
-                if let syn::Lit::Int(int) = &lit.lit {
-                    if let Ok(val) = int.base10_parse::<usize>() {
-                        len = val;
-                    }
+        if let syn::Expr::Lit(lit) = expr {
+            if let syn::Lit::Int(int) = &lit.lit {
+                if let Ok(val) = int.base10_parse::<usize>() {
+                    len = val;
                 }
-            },
-            _ => ()
+            }
         }
         if len > 0 {
             Some(Footer::Trait(len))

From 689f45b3bb9fb3a30d0ac3bbc1b4ae50b326638b Mon Sep 17 00:00:00 2001
From: "Jomer.Dev" <Jomer.Dev@posteo.de>
Date: Fri, 13 Oct 2023 16:25:22 +0200
Subject: [PATCH 5/7] Fix error message

---
 packed_struct/src/packing.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packed_struct/src/packing.rs b/packed_struct/src/packing.rs
index 53aa031..3569443 100644
--- a/packed_struct/src/packing.rs
+++ b/packed_struct/src/packing.rs
@@ -104,7 +104,7 @@ impl ::std::error::Error for PackingError {
             PackingError::SliceIndexingError { .. } => "Failed to index into a slice",
             PackingError::MoreThanOneDynamicType => "Only one dynamically sized type is supported in the tuple",
             PackingError::InternalError => "Internal error",
-            PackingError::UserError(err) => &err
+            PackingError::UserError(err) => err
         }
     }
 }

From 41a9ff109f2a690330ccdf2189808c589b80fe60 Mon Sep 17 00:00:00 2001
From: "Jomer.Dev" <Jomer.Dev@posteo.de>
Date: Sat, 14 Oct 2023 15:50:01 +0200
Subject: [PATCH 6/7] Add UserError only with feature std

---
 packed_struct/src/packing.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packed_struct/src/packing.rs b/packed_struct/src/packing.rs
index 3569443..be0b902 100644
--- a/packed_struct/src/packing.rs
+++ b/packed_struct/src/packing.rs
@@ -81,6 +81,7 @@ pub enum PackingError {
     BufferModMismatch { actual_size: usize, modulo_required: usize },
     SliceIndexingError { slice_len: usize },
     InternalError,
+    #[cfg(feature = "std")]
     UserError(String)
 }
 
@@ -104,6 +105,7 @@ impl ::std::error::Error for PackingError {
             PackingError::SliceIndexingError { .. } => "Failed to index into a slice",
             PackingError::MoreThanOneDynamicType => "Only one dynamically sized type is supported in the tuple",
             PackingError::InternalError => "Internal error",
+            #[cfg(feature = "std")]
             PackingError::UserError(err) => err
         }
     }

From d05e39b3f948ead41aaa50c29b9b737ab7a68126 Mon Sep 17 00:00:00 2001
From: "Jomer.Dev" <Jomer.Dev@posteo.de>
Date: Mon, 13 Nov 2023 21:51:31 +0100
Subject: [PATCH 7/7] Support empty structs with header or footer set

---
 packed_struct_codegen/src/pack_parse.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/packed_struct_codegen/src/pack_parse.rs b/packed_struct_codegen/src/pack_parse.rs
index 2a56d50..d44f4aa 100644
--- a/packed_struct_codegen/src/pack_parse.rs
+++ b/packed_struct_codegen/src/pack_parse.rs
@@ -539,7 +539,7 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
             let last_bit = fields_parsed.iter().map(|f| match f {
                 FieldKind::Regular { ref field, .. } => field.bit_range_rust.end,
                 FieldKind::Array { ref elements, .. } => elements.last().unwrap().bit_range_rust.end
-            }).max().unwrap();
+            }).max().unwrap_or(0);
             last_bit
         }
     };
@@ -570,6 +570,10 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
 
     let num_bytes = (num_bits as f32 / 8.0).ceil() as usize;
 
+    if num_bits == 0 {
+        return Err(syn::Error::new(ast.span(), "Empty Structures without header or footer are not supported"));
+    }
+
     if first_field_is_auto_positioned && (num_bits % 8) != 0 && struct_size_bytes.is_none() {
         return Err(syn::Error::new(fields[0].span(), "Please explicitly position the bits of the first field of this structure, as the alignment isn't obvious to the end user."));
     }