From 283a29fd2c993eb108dcaee50e0f6da4d5e8f5ad Mon Sep 17 00:00:00 2001 From: Wim Hueskes Date: Sun, 21 Aug 2016 02:03:48 +0200 Subject: [PATCH] od: refactor IntWriter, do not require parameters use macros to define a function for each format so byte_size and print_width do not have to be provided by the caller. --- src/od/formatteriteminfo.rs | 2 +- src/od/od.rs | 2 +- src/od/prn_char.rs | 22 ++-- src/od/prn_int.rs | 247 +++++++++++++++++++----------------- 4 files changed, 146 insertions(+), 127 deletions(-) diff --git a/src/od/formatteriteminfo.rs b/src/od/formatteriteminfo.rs index 034eece53..5118571fe 100644 --- a/src/od/formatteriteminfo.rs +++ b/src/od/formatteriteminfo.rs @@ -2,7 +2,7 @@ use std::fmt; #[derive(Copy, Eq)] pub enum FormatWriter { - IntWriter(fn(u64, usize, usize) -> String), + IntWriter(fn(u64) -> String), FloatWriter(fn(f64) -> String), MultibyteWriter(fn(&[u8]) -> String), } diff --git a/src/od/od.rs b/src/od/od.rs index 625ecef74..0b32b48cb 100644 --- a/src/od/od.rs +++ b/src/od/od.rs @@ -382,7 +382,7 @@ fn print_bytes(byte_order: ByteOrder, bytes: &[u8], length: usize, peekbytes: us } _ => { panic!("Invalid byte_size: {}", f.frm.formatter_item_info.byte_size); } }; - output_text.push_str(&func(p, f.frm.formatter_item_info.byte_size, f.frm.formatter_item_info.print_width)); + output_text.push_str(&func(p)); } FormatWriter::FloatWriter(func) => { let p: f64 = match f.frm.formatter_item_info.byte_size { diff --git a/src/od/prn_char.rs b/src/od/prn_char.rs index 9686c9160..381ec5ace 100644 --- a/src/od/prn_char.rs +++ b/src/od/prn_char.rs @@ -32,7 +32,7 @@ static A_CHRS : [&'static str; 128] = "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "del"]; -fn format_item_a(p: u64, _: usize, _: usize) -> String { +fn format_item_a(p: u64) -> String { // itembytes == 1 let b = (p & 0x7f) as u8; format!("{:>4}", A_CHRS.get(b as usize).unwrap_or(&"??") @@ -119,17 +119,17 @@ pub fn format_ascii_dump(bytes: &[u8]) -> String { #[test] fn test_format_item_a() { - assert_eq!(" nul", format_item_a(0x00, 1, 4)); - assert_eq!(" soh", format_item_a(0x01, 1, 4)); - assert_eq!(" sp", format_item_a(0x20, 1, 4)); - assert_eq!(" A", format_item_a(0x41, 1, 4)); - assert_eq!(" ~", format_item_a(0x7e, 1, 4)); - assert_eq!(" del", format_item_a(0x7f, 1, 4)); + assert_eq!(" nul", format_item_a(0x00)); + assert_eq!(" soh", format_item_a(0x01)); + assert_eq!(" sp", format_item_a(0x20)); + assert_eq!(" A", format_item_a(0x41)); + assert_eq!(" ~", format_item_a(0x7e)); + assert_eq!(" del", format_item_a(0x7f)); - assert_eq!(" nul", format_item_a(0x80, 1, 4)); - assert_eq!(" A", format_item_a(0xc1, 1, 4)); - assert_eq!(" ~", format_item_a(0xfe, 1, 4)); - assert_eq!(" del", format_item_a(0xff, 1, 4)); + assert_eq!(" nul", format_item_a(0x80)); + assert_eq!(" A", format_item_a(0xc1)); + assert_eq!(" ~", format_item_a(0xfe)); + assert_eq!(" del", format_item_a(0xff)); } #[test] diff --git a/src/od/prn_int.rs b/src/od/prn_int.rs index da3fb1fb3..9dd1fe58c 100644 --- a/src/od/prn_int.rs +++ b/src/od/prn_int.rs @@ -1,132 +1,151 @@ use formatteriteminfo::*; -pub static FORMAT_ITEM_OCT8: FormatterItemInfo = FormatterItemInfo { - byte_size: 1, - print_width: 4, // max: 377 - formatter: FormatWriter::IntWriter(format_item_oct), -}; +/// format string to print octal using `int_writer_unsigned` +macro_rules! OCT { () => { " {:0width$o}" }} +/// format string to print hexadecimal using `int_writer_unsigned` +macro_rules! HEX { () => { " {:0width$x}" }} +/// format string to print decimal using `int_writer_unsigned` or `int_writer_signed` +macro_rules! DEC { () => { " {:width$}" }} -pub static FORMAT_ITEM_OCT16: FormatterItemInfo = FormatterItemInfo { - byte_size: 2, - print_width: 7, // max: 177777 - formatter: FormatWriter::IntWriter(format_item_oct), -}; +/// defines a static struct of type `FormatterItemInfo` called `$NAME` +/// +/// Used to format unsigned integer types with help of a function called `$function` +/// `$byte_size` is the size of the type, `$print_width` is the maximum width in +/// human-readable format. `$format_str` is one of OCT, HEX or DEC +macro_rules! int_writer_unsigned { + ($NAME:ident, $byte_size:expr, $print_width:expr, $function:ident, $format_str:expr) => { + fn $function(p: u64) -> String { + format!($format_str, + p, + width = $print_width - 1) + } -pub static FORMAT_ITEM_OCT32: FormatterItemInfo = FormatterItemInfo { - byte_size: 4, - print_width: 12, // max: 37777777777 - formatter: FormatWriter::IntWriter(format_item_oct), -}; - -pub static FORMAT_ITEM_OCT64: FormatterItemInfo = FormatterItemInfo { - byte_size: 8, - print_width: 23, // max: 1777777777777777777777 - formatter: FormatWriter::IntWriter(format_item_oct), -}; - -pub static FORMAT_ITEM_HEX8: FormatterItemInfo = FormatterItemInfo { - byte_size: 1, - print_width: 3, // max: ff - formatter: FormatWriter::IntWriter(format_item_hex), -}; - -pub static FORMAT_ITEM_HEX16: FormatterItemInfo = FormatterItemInfo { - byte_size: 2, - print_width: 5, // max: ffff - formatter: FormatWriter::IntWriter(format_item_hex), -}; - -pub static FORMAT_ITEM_HEX32: FormatterItemInfo = FormatterItemInfo { - byte_size: 4, - print_width: 9, // max: ffffffff - formatter: FormatWriter::IntWriter(format_item_hex), -}; - -pub static FORMAT_ITEM_HEX64: FormatterItemInfo = FormatterItemInfo { - byte_size: 8, - print_width: 17, // max: ffffffffffffffff - formatter: FormatWriter::IntWriter(format_item_hex), -}; - - -pub static FORMAT_ITEM_DEC8U: FormatterItemInfo = FormatterItemInfo { - byte_size: 1, - print_width: 4, // max: 255 - formatter: FormatWriter::IntWriter(format_item_dec_u), -}; - -pub static FORMAT_ITEM_DEC16U: FormatterItemInfo = FormatterItemInfo { - byte_size: 2, - print_width: 6, // max: 65535 - formatter: FormatWriter::IntWriter(format_item_dec_u), -}; - -pub static FORMAT_ITEM_DEC32U: FormatterItemInfo = FormatterItemInfo { - byte_size: 4, - print_width: 11, // max: 4294967295 - formatter: FormatWriter::IntWriter(format_item_dec_u), -}; - -pub static FORMAT_ITEM_DEC64U: FormatterItemInfo = FormatterItemInfo { - byte_size: 8, - print_width: 21, // max: 18446744073709551615 - formatter: FormatWriter::IntWriter(format_item_dec_u), -}; - - -pub static FORMAT_ITEM_DEC8S: FormatterItemInfo = FormatterItemInfo { - byte_size: 1, - print_width: 5, // max: -128 - formatter: FormatWriter::IntWriter(format_item_dec_s), -}; - -pub static FORMAT_ITEM_DEC16S: FormatterItemInfo = FormatterItemInfo { - byte_size: 2, - print_width: 7, // max: -32768 - formatter: FormatWriter::IntWriter(format_item_dec_s), -}; - -pub static FORMAT_ITEM_DEC32S: FormatterItemInfo = FormatterItemInfo { - byte_size: 4, - print_width: 12, // max: -2147483648 - formatter: FormatWriter::IntWriter(format_item_dec_s), -}; - -pub static FORMAT_ITEM_DEC64S: FormatterItemInfo = FormatterItemInfo { - byte_size: 8, - print_width: 21, // max: -9223372036854775808 - formatter: FormatWriter::IntWriter(format_item_dec_s), -}; - - -// TODO: use some sort of byte iterator, instead of passing bytes in u64 -pub fn format_item_oct(p: u64, _: usize, print_width: usize) -> String { - - format!(" {:0width$o}", - p, - width = print_width - 1) + pub static $NAME: FormatterItemInfo = FormatterItemInfo { + byte_size: $byte_size, + print_width: $print_width, + formatter: FormatWriter::IntWriter($function), + }; + } } -pub fn format_item_hex(p: u64, _: usize, print_width: usize) -> String { +/// defines a static struct of type `FormatterItemInfo` called `$NAME` +/// +/// Used to format signed integer types with help of a function called `$function` +/// `$byte_size` is the size of the type, `$print_width` is the maximum width in +/// human-readable format. `$format_str` should be DEC +macro_rules! int_writer_signed { + ($NAME:ident, $byte_size:expr, $print_width:expr, $function:ident, $format_str:expr) => { + fn $function(p: u64) -> String { + let s = sign_extend(p, $byte_size); + format!($format_str, + s, + width = $print_width - 1) + } - format!(" {:0width$x}", - p, - width = print_width - 1) + pub static $NAME: FormatterItemInfo = FormatterItemInfo { + byte_size: $byte_size, + print_width: $print_width, + formatter: FormatWriter::IntWriter($function), + }; + } } - +/// Extends a signed number in `item` of `itembytes` bytes into a (signed) i64 fn sign_extend(item: u64, itembytes: usize) -> i64{ let shift = 64 - itembytes * 8; (item << shift) as i64 >> shift } -pub fn format_item_dec_s(p: u64, itembytes: usize, print_width: usize) -> String { - // sign extend - let s = sign_extend(p, itembytes); - format!("{:width$}", s, width = print_width) +int_writer_unsigned!(FORMAT_ITEM_OCT8, 1, 4, format_item_oct8, OCT!()); // max: 377 +int_writer_unsigned!(FORMAT_ITEM_OCT16, 2, 7, format_item_oct16, OCT!()); // max: 177777 +int_writer_unsigned!(FORMAT_ITEM_OCT32, 4, 12, format_item_oct32, OCT!()); // max: 37777777777 +int_writer_unsigned!(FORMAT_ITEM_OCT64, 8, 23, format_item_oct64, OCT!()); // max: 1777777777777777777777 + +int_writer_unsigned!(FORMAT_ITEM_HEX8, 1, 3, format_item_hex8, HEX!()); // max: ff +int_writer_unsigned!(FORMAT_ITEM_HEX16, 2, 5, format_item_hex16, HEX!()); // max: ffff +int_writer_unsigned!(FORMAT_ITEM_HEX32, 4, 9, format_item_hex32, HEX!()); // max: ffffffff +int_writer_unsigned!(FORMAT_ITEM_HEX64, 8, 17, format_item_hex64, HEX!()); // max: ffffffffffffffff + +int_writer_unsigned!(FORMAT_ITEM_DEC8U, 1, 4, format_item_dec_u8, DEC!()); // max: 255 +int_writer_unsigned!(FORMAT_ITEM_DEC16U, 2, 6, format_item_dec_u16, DEC!()); // max: 65535 +int_writer_unsigned!(FORMAT_ITEM_DEC32U, 4, 11, format_item_dec_u32, DEC!()); // max: 4294967295 +int_writer_unsigned!(FORMAT_ITEM_DEC64U, 8, 21, format_item_dec_u64, DEC!()); // max: 18446744073709551615 + +int_writer_signed!(FORMAT_ITEM_DEC8S, 1, 5, format_item_dec_s8, DEC!()); // max: -128 +int_writer_signed!(FORMAT_ITEM_DEC16S, 2, 7, format_item_dec_s16, DEC!()); // max: -32768 +int_writer_signed!(FORMAT_ITEM_DEC32S, 4, 12, format_item_dec_s32, DEC!()); // max: -2147483648 +int_writer_signed!(FORMAT_ITEM_DEC64S, 8, 21, format_item_dec_s64, DEC!()); // max: -9223372036854775808 + +#[test] +fn test_sign_extend() { + assert_eq!(0xffffffffffffff80u64 as i64, sign_extend(0x0000000000000080, 1)); + assert_eq!(0xffffffffffff8000u64 as i64, sign_extend(0x0000000000008000, 2)); + assert_eq!(0xffffffffff800000u64 as i64, sign_extend(0x0000000000800000, 3)); + assert_eq!(0xffffffff80000000u64 as i64, sign_extend(0x0000000080000000, 4)); + assert_eq!(0xffffff8000000000u64 as i64, sign_extend(0x0000008000000000, 5)); + assert_eq!(0xffff800000000000u64 as i64, sign_extend(0x0000800000000000, 6)); + assert_eq!(0xff80000000000000u64 as i64, sign_extend(0x0080000000000000, 7)); + assert_eq!(0x8000000000000000u64 as i64, sign_extend(0x8000000000000000, 8)); + + assert_eq!(0x000000000000007f, sign_extend(0x000000000000007f, 1)); + assert_eq!(0x0000000000007fff, sign_extend(0x0000000000007fff, 2)); + assert_eq!(0x00000000007fffff, sign_extend(0x00000000007fffff, 3)); + assert_eq!(0x000000007fffffff, sign_extend(0x000000007fffffff, 4)); + assert_eq!(0x0000007fffffffff, sign_extend(0x0000007fffffffff, 5)); + assert_eq!(0x00007fffffffffff, sign_extend(0x00007fffffffffff, 6)); + assert_eq!(0x007fffffffffffff, sign_extend(0x007fffffffffffff, 7)); + assert_eq!(0x7fffffffffffffff, sign_extend(0x7fffffffffffffff, 8)); } -pub fn format_item_dec_u(p: u64, _: usize, print_width: usize) -> String { - format!("{:width$}", p, width = print_width) +#[test] +fn test_format_item_oct() { + assert_eq!(" 000", format_item_oct8(0)); + assert_eq!(" 377", format_item_oct8(0xff)); + assert_eq!(" 000000", format_item_oct16(0)); + assert_eq!(" 177777", format_item_oct16(0xffff)); + assert_eq!(" 00000000000", format_item_oct32(0)); + assert_eq!(" 37777777777", format_item_oct32(0xffffffff)); + assert_eq!(" 0000000000000000000000", format_item_oct64(0)); + assert_eq!(" 1777777777777777777777", format_item_oct64(0xffffffffffffffff)); +} + +#[test] +fn test_format_item_hex() { + assert_eq!(" 00", format_item_hex8(0)); + assert_eq!(" ff", format_item_hex8(0xff)); + assert_eq!(" 0000", format_item_hex16(0)); + assert_eq!(" ffff", format_item_hex16(0xffff)); + assert_eq!(" 00000000", format_item_hex32(0)); + assert_eq!(" ffffffff", format_item_hex32(0xffffffff)); + assert_eq!(" 0000000000000000", format_item_hex64(0)); + assert_eq!(" ffffffffffffffff", format_item_hex64(0xffffffffffffffff)); +} + +#[test] +fn test_format_item_dec_u() { + assert_eq!(" 0", format_item_dec_u8(0)); + assert_eq!(" 255", format_item_dec_u8(0xff)); + assert_eq!(" 0", format_item_dec_u16(0)); + assert_eq!(" 65535", format_item_dec_u16(0xffff)); + assert_eq!(" 0", format_item_dec_u32(0)); + assert_eq!(" 4294967295", format_item_dec_u32(0xffffffff)); + assert_eq!(" 0", format_item_dec_u64(0)); + assert_eq!(" 18446744073709551615", format_item_dec_u64(0xffffffffffffffff)); +} + +#[test] +fn test_format_item_dec_s() { + assert_eq!(" 0", format_item_dec_s8(0)); + assert_eq!(" 127", format_item_dec_s8(0x7f)); + assert_eq!(" -128", format_item_dec_s8(0x80)); + assert_eq!(" 0", format_item_dec_s16(0)); + assert_eq!(" 32767", format_item_dec_s16(0x7fff)); + assert_eq!(" -32768", format_item_dec_s16(0x8000)); + assert_eq!(" 0", format_item_dec_s32(0)); + assert_eq!(" 2147483647", format_item_dec_s32(0x7fffffff)); + assert_eq!(" -2147483648", format_item_dec_s32(0x80000000)); + assert_eq!(" 0", format_item_dec_s64(0)); + assert_eq!(" 9223372036854775807", format_item_dec_s64(0x7fffffffffffffff)); + assert_eq!(" -9223372036854775808", format_item_dec_s64(0x8000000000000000)); }