lsbu64 type, byte positioning bug fix

Author: rudib

packed_struct/src/packing/types_ints.rs

@@ -390,6 +390,63 @@ impl Display for MsbU64 {
     }
 }
 
+/// The Least Significant Byte is the first one, unsigned.
+#[derive(Copy, Clone, Debug, Default, PartialEq)]
+pub struct LsbU64(pub u64);
+
+impl Deref for LsbU64 {
+    type Target = u64;
+    #[inline]
+    fn deref(&self) -> &u64 {
+        &self.0
+    }
+}
+
+impl PackedStruct<[u8; 8]> for LsbU64 {
+    #[inline]
+    fn pack(&self) -> [u8; 8] {
+        [
+            (self.0  & 0x00000000000000FF) as u8,
+            ((self.0 & 0x000000000000FF00) >> 8) as u8,
+            ((self.0 & 0x0000000000FF0000) >> 16) as u8,
+            ((self.0 & 0x00000000FF000000) >> 24) as u8,
+            ((self.0 & 0x000000FF00000000) >> 32) as u8,
+            ((self.0 & 0x0000FF0000000000) >> 40) as u8,
+            ((self.0 & 0x00FF000000000000) >> 48) as u8,
+            ((self.0 & 0xFF00000000000000) >> 56) as u8
+        ]
+    }
+
+    #[inline]
+    fn unpack(src: &[u8; 8]) -> Result<LsbU64, PackingError> {
+        Ok(LsbU64(
+            src[0] as u64 |
+            ((src[1] as u64) << 8) |
+            ((src[2] as u64) << 16) |
+            ((src[3] as u64) << 24) |
+            ((src[4] as u64) << 32) |
+            ((src[5] as u64) << 40) |
+            ((src[6] as u64) << 48) |
+            ((src[7] as u64) << 56)
+        ))
+    }
+}
+
+impl PackedStructInfo for LsbU64 {
+    #[inline]
+    fn packed_bits() -> usize {
+        64
+    }
+}
+
+packing_slice!(LsbU64; 8);
+
+#[cfg(any(feature="core_collections", feature="std"))]
+impl Display for LsbU64 {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
+        write!(f, "{}", self.0)
+    }
+}
 
 
 

packed_struct_codegen/src/pack_parse_attributes.rs

@@ -166,7 +166,11 @@ pub fn parse_position_val(v: &str, multiplier: usize) -> BitsPositionParsed {
         }
     } else {
         let start = parse_num(v);
-        return BitsPositionParsed::Range(start * multiplier, start * multiplier);
+        if multiplier > 1 {
+            return BitsPositionParsed::Range(start * multiplier, ((start+1) * multiplier)-1);
+        } else {
+            return BitsPositionParsed::Range(start * multiplier, start * multiplier);
+        }
     }
 
     panic!("invalid bits position")

packed_struct_tests/tests/packing_primitives.rs

@@ -28,3 +28,61 @@ fn test_packed_primitives() {
     let packed = i.pack();
     assert_eq!(&packed, &[0b00101010, 0b10101010, 0b10111010, 0b10101010, 0b10100000, 0]);
 }
+
+#[test]
+#[cfg(test)]
+fn test_packed_int_msb_endian() {
+
+    #[derive(Copy, Clone, Debug, Default, PartialEq, PackedStruct)]
+    #[packed_struct(endian="msb", bit_numbering="msb0")]
+    pub struct IntsMsb {
+        #[packed_field(bytes="0")]
+        pub a: u8,
+        #[packed_field(bytes="1")]
+        pub b: i8,
+        pub c: u16,
+        pub d: i16,
+        pub e: u32,
+        pub f: i32,
+        pub g: u64
+    }
+
+    let i = IntsMsb {
+        a: 85,
+        b: 85,
+        ..Default::default()
+    };
+
+    let packed = i.pack();
+    let unpacked = IntsMsb::unpack(&packed).unwrap();
+    assert_eq!(i, unpacked);
+}
+
+#[test]
+#[cfg(test)]
+fn test_packed_int_lsb_endian() {
+
+    #[derive(Copy, Clone, Debug, Default, PartialEq, PackedStruct)]
+    #[packed_struct(endian="lsb", bit_numbering="msb0")]
+    pub struct IntsLsb {
+        #[packed_field(bytes="0")]
+        pub a: u8,
+        #[packed_field(bytes="1")]
+        pub b: i8,
+        pub c: u16,
+        pub d: i16,
+        pub e: u32,
+        pub f: i32,
+        pub g: u64
+    }
+
+    let i = IntsLsb {
+        a: 85,
+        b: 85,
+        ..Default::default()
+    };
+
+    let packed = i.pack();
+    let unpacked = IntsLsb::unpack(&packed).unwrap();
+    assert_eq!(i, unpacked);
+}