#![cfg_attr(not(feature = "std"), no_std)]
#[cfg(feature = "alloc")]
extern crate alloc;
#[cfg(feature = "alloc")]
use alloc::{format, vec::Vec};
use bitvec::prelude::*;
pub use deku_derive::*;
pub mod attributes;
pub mod error;
pub mod prelude;
use crate::error::DekuError;
pub trait BitsReader {
fn read(
input: &BitSlice<Msb0, u8>,
input_is_le: bool,
bit_size: Option<usize>,
count: Option<usize>,
) -> Result<(&BitSlice<Msb0, u8>, Self), DekuError>
where
Self: Sized;
}
pub trait BitsWriter {
fn write(
&self,
output_is_le: bool,
bit_size: Option<usize>,
) -> Result<BitVec<Msb0, u8>, DekuError>;
}
macro_rules! ImplDekuTraits {
($typ:ty) => {
impl BitsReader for $typ {
fn read(
input: &BitSlice<Msb0, u8>,
input_is_le: bool,
bit_size: Option<usize>,
count: Option<usize>,
) -> Result<(&BitSlice<Msb0, u8>, Self), DekuError> {
assert!(count.is_none(), "Dev error: `count` should always be None");
let max_type_bits: usize = core::mem::size_of::<$typ>() * 8;
let bit_size = match bit_size {
None => max_type_bits,
Some(s) if s > max_type_bits => {
return Err(DekuError::Parse(format!(
"too much data: container of {} cannot hold {}",
max_type_bits, s
)))
}
Some(s) => s,
};
if input.len() < bit_size {
return Err(DekuError::Parse(format!(
"not enough data: expected {} got {}",
bit_size,
input.len()
)));
}
let (bit_slice, rest) = input.split_at(bit_size);
let mut bits: BitVec<Msb0, u8> = BitVec::new();
for b in bit_slice {
bits.push(*b);
}
let value = if input_is_le {
bits.load_le()
} else {
bits.load_be()
};
Ok((rest, value))
}
}
impl BitsWriter for $typ {
fn write(
&self,
output_is_le: bool,
bit_size: Option<usize>,
) -> Result<BitVec<Msb0, u8>, DekuError> {
let input = if output_is_le {
self.to_le_bytes()
} else {
self.to_be_bytes()
};
let input_bits: BitVec<Msb0, u8> = input.to_vec().into();
let res_bits: BitVec<Msb0, u8> = {
if let Some(bit_size) = bit_size {
if bit_size > input_bits.len() {
return Err(DekuError::InvalidParam(format!(
"bit size {} is larger then input {}",
bit_size,
input_bits.len()
)));
}
if output_is_le {
let mut res_bits = BitVec::<Msb0, u8>::with_capacity(bit_size);
let mut remaining_bits = bit_size;
for chunk in input_bits.chunks(8) {
if chunk.len() > remaining_bits {
let bits = &chunk[chunk.len() - remaining_bits..];
for b in bits {
res_bits.push(*b);
}
break;
} else {
for b in chunk {
res_bits.push(*b);
}
}
remaining_bits -= chunk.len();
}
res_bits
} else {
input_bits[input_bits.len() - bit_size..].into()
}
} else {
input_bits
}
};
Ok(res_bits)
}
}
};
}
impl<T: BitsReader> BitsReader for Vec<T> {
fn read(
input: &BitSlice<Msb0, u8>,
input_is_le: bool,
bit_size: Option<usize>,
count: Option<usize>,
) -> Result<(&BitSlice<Msb0, u8>, Self), DekuError>
where
Self: Sized,
{
let count = count.expect("Dev error: `count` should always be Some");
let mut res = Vec::with_capacity(count);
let mut rest = input;
for _i in 0..count {
let (new_rest, val) = <T>::read(rest, input_is_le, bit_size, None)?;
res.push(val);
rest = new_rest;
}
Ok((rest, res))
}
}
impl<T: BitsWriter> BitsWriter for Vec<T> {
fn write(
&self,
output_is_le: bool,
bit_size: Option<usize>,
) -> Result<BitVec<Msb0, u8>, DekuError> {
let mut acc = BitVec::new();
for v in self {
let r = v.write(output_is_le, bit_size)?;
acc.extend(r);
}
Ok(acc)
}
}
ImplDekuTraits!(u8);
ImplDekuTraits!(u16);
ImplDekuTraits!(u32);
ImplDekuTraits!(u64);
ImplDekuTraits!(usize);
#[cfg(test)]
mod tests {
use super::*;
use rstest::rstest;
#[cfg(target_endian = "little")]
static IS_LE: bool = true;
#[cfg(target_endian = "big")]
static IS_LE: bool = false;
#[rstest(input,input_is_le,bit_size,count,expected,expected_rest,
case::normal([0xDD, 0xCC, 0xBB, 0xAA].as_ref(), IS_LE, Some(32), None, 0xAABB_CCDD, bits![Msb0, u8;]),
case::normal_offset([0b1001_0110, 0b1110_0000, 0xCC, 0xDD ].as_ref(), IS_LE, Some(12), None, 0b1110_1001_0110, bits![Msb0, u8; 0,0,0,0, 1,1,0,0,1,1,0,0, 1,1,0,1,1,1,0,1]),
#[should_panic(expected="Parse(\"not enough data: expected 32 got 0\")")]
case::not_enough_data([].as_ref(), IS_LE, Some(32), None, 0xFF, bits![Msb0, u8;]),
#[should_panic(expected="Parse(\"not enough data: expected 32 got 16\")")]
case::not_enough_data([0xAA, 0xBB].as_ref(), IS_LE, Some(32), None, 0xFF, bits![Msb0, u8;]),
#[should_panic(expected="Parse(\"too much data: container of 32 cannot hold 64\")")]
case::too_much_data([0xAA, 0xBB, 0xCC, 0xDD, 0xAA, 0xBB, 0xCC, 0xDD].as_ref(), IS_LE, Some(64), None, 0xFF, bits![Msb0, u8;]),
#[should_panic(expected="Dev error: `count` should always be None")]
case::dev_err_count_some([].as_ref(), IS_LE, Some(64), Some(1), 0xFF, bits![Msb0, u8;]),
)]
fn test_bit_read(
input: &[u8],
input_is_le: bool,
bit_size: Option<usize>,
count: Option<usize>,
expected: u32,
expected_rest: &BitSlice<Msb0, u8>,
) {
let bit_slice = input.bits::<Msb0>();
let (rest, res_read) = u32::read(bit_slice, input_is_le, bit_size, count).unwrap();
assert_eq!(expected, res_read);
assert_eq!(expected_rest, rest);
}
#[rstest(input,output_is_le,bit_size,expected,
case::normal_le(0xDDCC_BBAA, IS_LE, None, vec![0xAA, 0xBB, 0xCC, 0xDD]),
case::normal_be(0xDDCC_BBAA, !IS_LE, None, vec![0xDD, 0xCC, 0xBB, 0xAA]),
case::bit_size_le_smaller(0x03AB, IS_LE, Some(10), vec![0xAB, 0b11_000000]),
case::bit_size_be_smaller(0x03AB, !IS_LE, Some(10), vec![0b11, 0xAB]),
#[should_panic(expected = "InvalidParam(\"bit size 100 is larger then input 32\")")]
case::bit_size_le_bigger(0x03AB, IS_LE, Some(100), vec![0xAB, 0b11_000000]),
)]
fn test_bit_write(input: u32, output_is_le: bool, bit_size: Option<usize>, expected: Vec<u8>) {
let res_write = input.write(output_is_le, bit_size).unwrap().into_vec();
assert_eq!(expected, res_write);
}
#[rstest(input,is_le,bit_size,expected,expected_rest,expected_write,
case::normal([0xDD, 0xCC, 0xBB, 0xAA].as_ref(), IS_LE, Some(32), 0xAABB_CCDD, bits![Msb0, u8;], vec![0xDD, 0xCC, 0xBB, 0xAA]),
)]
fn test_bit_read_write(
input: &[u8],
is_le: bool,
bit_size: Option<usize>,
expected: u32,
expected_rest: &BitSlice<Msb0, u8>,
expected_write: Vec<u8>,
) {
let bit_slice = input.bits::<Msb0>();
let (rest, res_read) = u32::read(bit_slice, is_le, bit_size, None).unwrap();
assert_eq!(expected, res_read);
assert_eq!(expected_rest, rest);
let res_write = res_read.write(is_le, bit_size).unwrap().into_vec();
assert_eq!(expected_write, res_write);
assert_eq!(input[..expected_write.len()].to_vec(), expected_write);
}
#[rstest(input,input_is_le,bit_size,count,expected,expected_rest,
case::count_0([0xAA].as_ref(), IS_LE, Some(8), Some(0), vec![], bits![Msb0, u8; 1,0,1,0,1,0,1,0]),
case::count_1([0xAA, 0xBB].as_ref(), IS_LE, Some(8), Some(1), vec![0xAA], bits![Msb0, u8; 1,0,1,1,1,0,1,1]),
case::count_2([0xAA, 0xBB, 0xCC].as_ref(), IS_LE, Some(8), Some(2), vec![0xAA, 0xBB], bits![Msb0, u8; 1,1,0,0,1,1,0,0]),
case::bits_6([0b0110_1001, 0b1110_1001].as_ref(), IS_LE, Some(6), Some(2), vec![0b00_011010, 0b00_011110], bits![Msb0, u8; 1,0,0,1]),
#[should_panic(expected="Parse(\"too much data: container of 8 cannot hold 9\")")]
case::not_enough_data([].as_ref(), IS_LE, Some(9), Some(1), vec![], bits![Msb0, u8;]),
#[should_panic(expected="Parse(\"too much data: container of 8 cannot hold 9\")")]
case::not_enough_data([0xAA].as_ref(), IS_LE, Some(9), Some(1), vec![], bits![Msb0, u8;]),
#[should_panic(expected="Parse(\"not enough data: expected 8 got 0\")")]
case::not_enough_data([0xAA].as_ref(), IS_LE, Some(8), Some(2), vec![], bits![Msb0, u8;]),
#[should_panic(expected="Parse(\"too much data: container of 8 cannot hold 9\")")]
case::too_much_data([0xAA, 0xBB].as_ref(), IS_LE, Some(9), Some(1), vec![], bits![Msb0, u8;]),
#[should_panic(expected="Dev error: `count` should always be Some")]
case::dev_err_count_none([].as_ref(), IS_LE, Some(0), None, vec![], bits![Msb0, u8;]),
)]
fn test_vec_read(
input: &[u8],
input_is_le: bool,
bit_size: Option<usize>,
count: Option<usize>,
expected: Vec<u8>,
expected_rest: &BitSlice<Msb0, u8>,
) {
let bit_slice = input.bits::<Msb0>();
let (rest, res_read) = Vec::<u8>::read(bit_slice, input_is_le, bit_size, count).unwrap();
assert_eq!(expected, res_read);
assert_eq!(expected_rest, rest);
}
#[rstest(input,output_is_le,bit_size,expected,
case::normal(vec![0xAABB, 0xCCDD], IS_LE, None, vec![0xBB, 0xAA, 0xDD, 0xCC]),
)]
fn test_vec_write(
input: Vec<u16>,
output_is_le: bool,
bit_size: Option<usize>,
expected: Vec<u8>,
) {
let res_write = input.write(output_is_le, bit_size).unwrap().into_vec();
assert_eq!(expected, res_write);
}
#[rstest(input,is_le,bit_size,count,expected,expected_rest,expected_write,
case::normal_le([0xAA, 0xBB, 0xCC, 0xDD].as_ref(), IS_LE, Some(16), Some(2), vec![0xBBAA, 0xDDCC], bits![Msb0, u8;], vec![0xAA, 0xBB, 0xCC, 0xDD]),
case::normal_be([0xAA, 0xBB, 0xCC, 0xDD].as_ref(), !IS_LE, Some(16), Some(2), vec![0xAABB, 0xCCDD], bits![Msb0, u8;], vec![0xAA, 0xBB, 0xCC, 0xDD]),
)]
fn test_vec_read_write(
input: &[u8],
is_le: bool,
bit_size: Option<usize>,
count: Option<usize>,
expected: Vec<u16>,
expected_rest: &BitSlice<Msb0, u8>,
expected_write: Vec<u8>,
) {
let bit_slice = input.bits::<Msb0>();
let (rest, res_read) = Vec::<u16>::read(bit_slice, is_le, bit_size, count).unwrap();
assert_eq!(expected, res_read);
assert_eq!(expected_rest, rest);
let res_write: Vec<u8> = res_read.write(is_le, bit_size).unwrap().into_vec();
assert_eq!(expected_write, res_write);
assert_eq!(input[..expected_write.len()].to_vec(), expected_write);
}
}