From 6a623932edf8c0cccd9f26390f62cd44beaf1657 Mon Sep 17 00:00:00 2001 From: Jason Travis Smith Date: Sat, 2 Jan 2016 14:54:03 -0500 Subject: [PATCH] This is trying to remove the num_bytes argument from usize/isize methods. If num_bytes can be removed then a generic to_bytes and from_bytes trait can be created that will help with serializing structures and generic data. --- .gitignore | 19 +++++++++++-- Cargo.lock | 12 ++++++++ src/endian.rs | 67 ++++++++++++++++++++++++--------------------- src/transmutable.rs | 39 ++++++++++++++++++-------- 4 files changed, 92 insertions(+), 45 deletions(-) create mode 100644 Cargo.lock diff --git a/.gitignore b/.gitignore index a9d37c5..48f68fb 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,17 @@ -target -Cargo.lock +# Ignore swap files from text editors. +*.swp + +# Ignore compiled files. +*.o +*.so +*.rlib +*.dll +*.exe + +# Ignore files/directories generated by Cargo. +/target/ + +# Remove Cargo.lock from gitignore if creating an executable, +# leave it for libraries. +# More information here: http://doc.crates.io/guide.html#cargotoml-vs-cargolock +#Cargo.lock diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..bd7e84f --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,12 @@ +[root] +name = "alchemy" +version = "0.1.0" +dependencies = [ + "sigils 0.1.0 (git+https://gitlab.com/CyberMages/sigils.git)", +] + +[[package]] +name = "sigils" +version = "0.1.0" +source = "git+https://gitlab.com/CyberMages/sigils.git#a618fb27f7ceaaa3f75b334dd8ec716ff795273a" + diff --git a/src/endian.rs b/src/endian.rs index fbeae5d..35f9267 100644 --- a/src/endian.rs +++ b/src/endian.rs @@ -32,14 +32,14 @@ pub type PlatformEndian = LittleEndian; /// and turning them into the requested type. macro_rules! read_bytes { - ($buffer: expr, $return_type: ident, $convert_func: ident) => + ($buffer: expr, $returnType: ident, $convertFunc: ident) => ({ - use std::$return_type; + use std::$returnType; - assert!($return_type::BYTES <= $buffer.len()); + assert!($returnType::BYTES <= $buffer.len()); unsafe { - (*($buffer.as_ptr() as *const $return_type)).$convert_func() + (*($buffer.as_ptr() as *const $returnType)).$convertFunc() } }) } @@ -48,21 +48,23 @@ macro_rules! read_bytes /// and writing them to a buffer. macro_rules! write_bytes { - ($buffer: expr, $value_type: ident, $num: expr, $convert_func: ident) => + ($buffer: expr, $valueType: ident, $num: expr, $convertFunc: ident) => ({ - use std::$value_type; + use std::$valueType; - assert!($value_type::BYTES <= $buffer.len()); + assert!($valueType::BYTES <= $buffer.len()); unsafe { let size: usize; - let bytes: [u8; $value_type::BYTES]; + let bytes: [u8; $valueType::BYTES]; - size = $value_type::BYTES as usize; + size = $valueType::BYTES as usize; bytes = - mem::transmute::<_,[u8; $value_type::BYTES]>($num.$convert_func()); - copy_nonoverlapping((&bytes).as_ptr(), $buffer.as_mut_ptr(), size); + mem::transmute::<_,[u8; $valueType::BYTES]>($num.$convertFunc()); + copy_nonoverlapping::((&bytes).as_ptr(), + $buffer.as_mut_ptr(), + size); } }) } @@ -86,21 +88,20 @@ impl Transmutable for BigEndian read_bytes!(buffer, u64, to_be) } - fn bytes_to_usize(buffer: &[u8], num_bytes: u8) -> usize + fn bytes_to_usize(buffer: &[u8]) -> usize { let mut out: [u8; 8]; let ptr_out: *mut u8; - assert!(1 <= num_bytes && num_bytes <= 8); - assert!(num_bytes as usize <= buffer.len()); + assert!(1 <= buffer.len() && buffer.len() <= 8); out = [0u8; 8]; ptr_out = out.as_mut_ptr(); unsafe { - copy_nonoverlapping(buffer.as_ptr(), - ptr_out.offset((8 - num_bytes) as isize), - num_bytes as usize); + copy_nonoverlapping::(buffer.as_ptr(), + ptr_out.offset((8 - buffer.len()) as isize), + buffer.len()); (*(ptr_out as *const u64)).to_be() as usize } @@ -122,18 +123,21 @@ impl Transmutable for BigEndian write_bytes!(buffer, u64, num, to_be); } - fn usize_to_bytes(buffer: &mut [u8], num: usize, num_bytes: u8) + fn usize_to_bytes(buffer: &mut [u8], num: usize) { let bytes: [u8; 8]; + let num_bytes: u8; + + num_bytes = buffer.len() as u8; assert!(determine_size(num as u64) <= num_bytes && num_bytes <= 8); - assert!(num_bytes as usize <= buffer.len()); + unsafe { - bytes = mem::transmute::(num.to_be()); - copy_nonoverlapping(bytes.as_ptr().offset((8 - num_bytes) as isize), - buffer.as_mut_ptr(), num_bytes as usize); + copy_nonoverlapping::( + bytes.as_ptr().offset((8 - num_bytes) as isize), + buffer.as_mut_ptr(), num_bytes as usize); } } } @@ -155,19 +159,18 @@ impl Transmutable for LittleEndian read_bytes!(buffer, u64, to_le) } - fn bytes_to_usize(buffer: &[u8], num_bytes: u8) -> usize + fn bytes_to_usize(buffer: &[u8]) -> usize { let mut out: [u8; 8]; let ptr_out: *mut u8; - assert!(1 <= num_bytes && num_bytes <= 8); - assert!(num_bytes as usize <= buffer.len()); + assert!(1 <= buffer.len() && buffer.len() <= 8); out = [0u8; 8]; ptr_out = out.as_mut_ptr(); unsafe { - copy_nonoverlapping(buffer.as_ptr(), ptr_out, num_bytes as usize); + copy_nonoverlapping::(buffer.as_ptr(), ptr_out, buffer.len()); (*(ptr_out as *const u64)).to_le() as usize } } @@ -188,18 +191,20 @@ impl Transmutable for LittleEndian write_bytes!(buffer, u64, num, to_le); } - fn usize_to_bytes(buffer: &mut [u8], num: usize, num_bytes: u8) + fn usize_to_bytes(buffer: &mut [u8], num: usize) { let bytes: [u8; 8]; + let num_bytes: u8; + + num_bytes = buffer.len() as u8; assert!(determine_size(num as u64) <= num_bytes && num_bytes <= 8); - assert!(num_bytes as usize <= buffer.len()); + unsafe { - bytes = mem::transmute::(num.to_le()); - copy_nonoverlapping(bytes.as_ptr(), buffer.as_mut_ptr(), - num_bytes as usize); + copy_nonoverlapping::(bytes.as_ptr(), buffer.as_mut_ptr(), + num_bytes as usize); } } } diff --git a/src/transmutable.rs b/src/transmutable.rs index e3ac467..b21c0fd 100644 --- a/src/transmutable.rs +++ b/src/transmutable.rs @@ -45,15 +45,14 @@ pub trait Transmutable /// /// This will panic if the number of bytes /// passed in is less than one or more than eight. - fn bytes_to_isize(buffer: &[u8], num_bytes: u8) -> isize + fn bytes_to_isize(buffer: &[u8]) -> isize { let temp_num: u64; - assert!(num_bytes > 1 && num_bytes < 8); - assert!(buffer.len() < (num_bytes as usize)); + assert!(buffer.len() > 1 && buffer.len() < 8); - temp_num = Self::bytes_to_usize(buffer, num_bytes) as u64; - add_sign(temp_num, num_bytes) as isize + temp_num = Self::bytes_to_usize(buffer) as u64; + add_sign(temp_num, buffer.len() as u8) as isize } /// Converts an array of bytes to a 32-bit floating point number. @@ -126,15 +125,14 @@ pub trait Transmutable /// This will panic if the number of bytes /// passed in is less than the byte size of the given number /// or more than eight. - fn isize_to_bytes(buffer: &mut [u8], num: isize, num_bytes: u8) + fn isize_to_bytes(buffer: &mut [u8], num: isize) { let temp_num: usize; - assert!(num_bytes > 1 && num_bytes < 8); - assert!(buffer.len() < (num_bytes as usize)); + assert!(buffer.len() > 1 && buffer.len() < 8); - temp_num = remove_sign(num as i64, num_bytes) as usize; - Self::usize_to_bytes(buffer, temp_num, num_bytes) + temp_num = remove_sign(num as i64, buffer.len() as u8) as usize; + Self::usize_to_bytes(buffer, temp_num) } /// Converts a 32-bit floating point number to bytes @@ -196,7 +194,7 @@ pub trait Transmutable /// /// This will panic if the number of bytes /// passed in is less than one or more than eight. - fn bytes_to_usize(buffer: &[u8], num_bytes: u8) -> usize; + fn bytes_to_usize(buffer: &[u8]) -> usize; /// Converts an unsigned 16-bit integer to bytes @@ -233,7 +231,7 @@ pub trait Transmutable /// This will panic if the number of bytes /// passed in is less than the byte size of the given number /// or more than eight. - fn usize_to_bytes(buffer: &mut [u8], num: usize, num_bytes: u8); + fn usize_to_bytes(buffer: &mut [u8], num: usize); } @@ -258,3 +256,20 @@ fn remove_sign(val: i64, num_bytes: u8) -> u64 shift = (8 - num_bytes) * 8; (val << shift) as u64 >> shift } + + + + +pub enum Endianess +{ + BIG, + LITTLE, + PLATFORM +} + +pub trait fff +{ + fn to_bytes(&self, buffer: &mut [u8]); + + fn from_bytes(buffer: &[u8]) -> Self; +}