From aadf35e9cbb9eb0677eb9a617dec3b7263e3475a Mon Sep 17 00:00:00 2001 From: Marrub Date: Thu, 14 Feb 2019 00:19:36 -0500 Subject: [PATCH] clippy saves the world --- clippy.toml | 1 + src/durandal/cenum.rs | 4 +- src/durandal/crc.rs | 8 +- src/durandal/fx32.rs | 4 +- src/durandal/image.rs | 26 ++-- src/durandal/text.rs | 20 ++- src/main.rs | 28 ++-- src/marathon/machdr.rs | 4 +- src/marathon/pict.rs | 301 +++++++++++++++++++++++------------------ src/marathon/shp.rs | 4 +- src/marathon/term.rs | 2 +- src/marathon/wad.rs | 4 +- 12 files changed, 224 insertions(+), 182 deletions(-) create mode 100644 clippy.toml diff --git a/clippy.toml b/clippy.toml new file mode 100644 index 0000000..c21b1f1 --- /dev/null +++ b/clippy.toml @@ -0,0 +1 @@ +single-char-binding-names-threshold = 10 diff --git a/src/durandal/cenum.rs b/src/durandal/cenum.rs index 6d77614..bc0200d 100644 --- a/src/durandal/cenum.rs +++ b/src/durandal/cenum.rs @@ -7,13 +7,13 @@ macro_rules! c_enum { ( $(#[$outer:meta])* - pub enum $E:ident: $T:ty + $V:vis enum $E:ident: $T:ty { $($value:expr => $Enum:ident,)+ } ) => { $(#[$outer])* - pub enum $E + $V enum $E { $($Enum,)+ } diff --git a/src/durandal/crc.rs b/src/durandal/crc.rs index 12ae654..a03cccf 100644 --- a/src/durandal/crc.rs +++ b/src/durandal/crc.rs @@ -3,7 +3,7 @@ fn crc_accum(a: u32, _: u32) -> u32 { if a & 1 == 1 { - 0xedb88320 ^ a >> 1 + 0xEDB8_8320 ^ a >> 1 } else { a >> 1 } @@ -12,8 +12,8 @@ fn crc_accum(a: u32, _: u32) -> u32 fn crc_init() -> [u32; 256] { let mut t = [0; 256]; - for n in 0..256 { - t[n] = (0..8).fold(n as u32, crc_accum); + for (n, v) in t.iter_mut().enumerate() { + *v = (0..8).fold(n as u32, crc_accum); } t } @@ -22,7 +22,7 @@ pub fn crc32(b: &[u8], s: u32) -> u32 { let t = crc_init(); !b.iter() - .fold(s, |a, &o| a >> 8 ^ t[(a & 0xff ^ o as u32) as usize]) + .fold(s, |a, &o| a >> 8 ^ t[(a & 0xFF ^ u32::from(o)) as usize]) } #[test] diff --git a/src/durandal/fx32.rs b/src/durandal/fx32.rs index da49092..40ed70d 100644 --- a/src/durandal/fx32.rs +++ b/src/durandal/fx32.rs @@ -81,7 +81,7 @@ impl ops::Mul for Fx32 fn mul(self, o: Fx32) -> Fx32 { - Fx32((self.0 as i64 * o.0 as i64 / Fx32::ONE as i64) as i32) + Fx32((i64::from(self.0) * i64::from(o.0) / i64::from(Fx32::ONE)) as i32) } } @@ -91,7 +91,7 @@ impl ops::Div for Fx32 fn div(self, o: Fx32) -> Fx32 { - Fx32((self.0 as i64 * Fx32::ONE as i64 / o.0 as i64) as i32) + Fx32((i64::from(self.0) * i64::from(Fx32::ONE) / i64::from(o.0)) as i32) } } diff --git a/src/durandal/image.rs b/src/durandal/image.rs index 9d23315..bc7eb81 100644 --- a/src/durandal/image.rs +++ b/src/durandal/image.rs @@ -26,7 +26,7 @@ pub fn r5g5b5_to_rgb16(rgb: u16) -> Color16 /// Creates a RGB16 color from a RGB8 format color. pub fn rgb8_to_rgb16(r: u8, g: u8, b: u8) -> Color16 { - Color16::new(r as (u16) << 8, g as (u16) << 8, b as (u16) << 8) + Color16::new(u16::from(r) << 8, u16::from(g) << 8, u16::from(b) << 8) } /// Writes a PPM file from an image. @@ -40,7 +40,7 @@ pub fn write_ppm(out: &mut impl io::Write, im: &impl Image) -> ResultS<()> write!(out, "{} {} {} ", cr.r(), cr.g(), cr.b())?; } - out.write(b"\n")?; + out.write_all(b"\n")?; } Ok(()) @@ -49,21 +49,21 @@ pub fn write_ppm(out: &mut impl io::Write, im: &impl Image) -> ResultS<()> /// Writes a TGA file from an image. pub fn write_tga(out: &mut impl io::Write, im: &impl Image) -> ResultS<()> { - out.write(&[0, 0, 2])?; // id len, color map type, image type - out.write(&[0, 0, 0, 0, 0])?; // color map spec - out.write(&[0, 0])?; // x origin - out.write(&[0, 0])?; // y origin - out.write(&(im.w() as u16).to_le_bytes())?; // width - out.write(&(im.h() as u16).to_le_bytes())?; // height - out.write(&[32, 0])?; // depth, descriptor + out.write_all(&[0, 0, 2])?; // id len, color map type, image type + out.write_all(&[0, 0, 0, 0, 0])?; // color map spec + out.write_all(&[0, 0])?; // x origin + out.write_all(&[0, 0])?; // y origin + out.write_all(&(im.w() as u16).to_le_bytes())?; // width + out.write_all(&(im.h() as u16).to_le_bytes())?; // height + out.write_all(&[32, 0])?; // depth, descriptor for y in (0..im.h()).rev() { for x in 0..im.w() { let cr = im.index(x, y); - out.write(&[(cr.b() >> 8) as u8, - (cr.g() >> 8) as u8, - (cr.r() >> 8) as u8, - (cr.a() >> 8) as u8])?; + out.write_all(&[(cr.b() >> 8) as u8, + (cr.g() >> 8) as u8, + (cr.r() >> 8) as u8, + (cr.a() >> 8) as u8])?; } } diff --git a/src/durandal/text.rs b/src/durandal/text.rs index d219ae6..13ab409 100644 --- a/src/durandal/text.rs +++ b/src/durandal/text.rs @@ -71,7 +71,7 @@ pub fn fuck_string(s: &[u8]) -> Vec pub fn pascal_str(b: &[u8]) -> Option<&[u8]> { let s = *b.get(0)? as usize; - b.get(1..1 + s) + b.get(1..=s) } /// Converts input from Mac Roman to a Unicode string. @@ -79,16 +79,14 @@ pub fn mac_roman_conv(s: &[u8]) -> String { let mut v = String::with_capacity(s.len()); - for i in 0..s.len() { - if s[i] == 0 { - break; - } else if s[i] & 0x80 != 0 { - v.push(TR[s[i] as usize & 0x7f]); - } else if s[i] == b'\r' { - v.push('\n'); - } else { - v.push(s[i] as char); - } + for &c in s.iter() { + let c = match c { + 0 => break, + b'\r' => '\n', + c if c & 0x80 != 0 => TR[c as usize & 0x7F], + c => c as char, + }; + v.push(c); } v diff --git a/src/main.rs b/src/main.rs index 88b27e2..9a3af44 100644 --- a/src/main.rs +++ b/src/main.rs @@ -10,12 +10,12 @@ fn make_tga(fname: &str, im: &impl Image) -> ResultS<()> write_tga(&mut out, im) } -fn make_chunk(opt: &Options, cid: &Ident, cnk: &[u8], eid: u16) -> ResultS<()> +fn make_chunk(opt: &Options, cid: Ident, cnk: &[u8], eid: u16) -> ResultS<()> { - let cid = mac_roman_conv(cid); + let cid = mac_roman_conv(&cid); let fname = format!("{}/{:04}{}.bin", opt.out_dir, eid, cid); let mut out = io::BufWriter::new(fs::File::create(&fname)?); - out.write(cnk)?; + out.write_all(cnk)?; Ok(()) } @@ -26,51 +26,51 @@ fn make_yaml(data: &impl serde::Serialize) -> ResultS<()> Ok(()) } -fn dump_chunk(opt: &Options, cid: &Ident, cnk: &[u8], eid: u16) -> ResultS<()> +fn dump_chunk(opt: &Options, cid: Ident, cnk: &[u8], eid: u16) -> ResultS<()> { if opt.wad_all { make_chunk(opt, cid, cnk, eid)?; return Ok(()); } - match cid { + match &cid { b"PICT" => { - if opt.wad_chunks.contains(cid) { + if opt.wad_chunks.contains(&cid) { let im = pict::load_pict(cnk)?; make_tga(&format!("{}/pict_{}.tga", opt.out_dir, eid), &im)?; } } b"Minf" => { - if opt.wad_chunks.contains(cid) { + if opt.wad_chunks.contains(&cid) { make_yaml(&map::Minf::chunk(cnk)?)?; } } b"EPNT" => { - if opt.wad_chunks.contains(cid) { + if opt.wad_chunks.contains(&cid) { make_yaml(&map::Endpoint::chunk(cnk)?)?; } } b"PNTS" => { - if opt.wad_chunks.contains(cid) { + if opt.wad_chunks.contains(&cid) { make_yaml(&map::Point::chunk(cnk)?)?; } } b"LINS" => { - if opt.wad_chunks.contains(cid) { + if opt.wad_chunks.contains(&cid) { make_yaml(&map::Line::chunk(cnk)?)?; } } b"SIDS" => { - if opt.wad_chunks.contains(cid) { + if opt.wad_chunks.contains(&cid) { make_yaml(&map::Side::chunk(cnk)?)?; } } b"term" => { - if opt.wad_chunks.contains(cid) { + if opt.wad_chunks.contains(&cid) { make_yaml(&term::Terminal::chunk(cnk)?)?; } } - cid => { + &cid => { if opt.wad_unknown { make_chunk(opt, cid, cnk, eid)?; } @@ -90,7 +90,7 @@ fn process_wad(opt: &Options, b: &[u8]) -> ResultS<()> for (eid, ent) in wad.entries { for (cid, cnk) in ent.chunks { - dump_chunk(opt, &cid, cnk, eid)?; + dump_chunk(opt, cid, cnk, eid)?; } } diff --git a/src/marathon/machdr.rs b/src/marathon/machdr.rs index 6508b58..b1d67b9 100644 --- a/src/marathon/machdr.rs +++ b/src/marathon/machdr.rs @@ -38,9 +38,9 @@ pub fn check_macbin(b: &[u8]) -> Option let mut crc = 0; // check header crc - for i in 0..124 { + for &byte in b.iter().take(124) { for j in 8..16 { - let d = b[i] as (u16) << j; + let d = u16::from(byte) << j; if (d ^ crc) & 0x8000 != 0 { crc = crc << 1 ^ 0x1021; } else { diff --git a/src/marathon/pict.rs b/src/marathon/pict.rs index 3b30d48..085b8bf 100644 --- a/src/marathon/pict.rs +++ b/src/marathon/pict.rs @@ -3,43 +3,34 @@ use crate::durandal::{bin::*, err::*, image::*}; use generic_array::*; -const PACK_DEFAULT: u16 = 0; -const PACK_NONE: u16 = 1; -const PACK_NOPAD: u16 = 2; -const PACK_RLE16: u16 = 3; -const PACK_RLE32: u16 = 4; - -/// Process a CopyBits operation. -pub fn read_bitmap_area(mut im: Image8, - b: &[u8], - packed: bool, - clip: bool) - -> ResultS +/// Reads a PixMap header. +fn read_pm_header<'a>(b: &'a [u8], + pack: bool, + clip: bool, + im: &Image8) + -> ResultS<(&'a [u8], Header)> { - let mut p = if !packed {4} else {0}; + let pt_fl = c_u16b(b, 0)?; + let top = c_u16b(b, 2)? as usize; + let left = c_u16b(b, 4)? as usize; + let bottom = c_u16b(b, 6)? as usize; + let right = c_u16b(b, 8)? as usize; + let pack_t = c_u16b(b, 12)?; + let depth = c_u16b(b, 28)?; + let pack_t = PackType::from_repr(pack_t)?; - let (w, h) = (im.w(), im.h()); - - let pitch_fl = c_u16b(b, p)?; - let top = c_u16b(b, p + 2)? as usize; - let left = c_u16b(b, p + 4)? as usize; - let bottom = c_u16b(b, p + 6)? as usize; - let right = c_u16b(b, p + 8)? as usize; - let pack_typ = c_u16b(b, p + 12)?; - let depth = c_u16b(b, p + 28)?; - - if pitch_fl & 0x8000 == 0 { + if pt_fl & 0x8000 == 0 { bail!("PICT1 not supported"); } - if right - left != w || bottom - top != h { + if right - left != im.w() || bottom - top != im.h() { bail!("image bounds are incorrect"); } - p += 46; // size of header + let mut p = 46; // get CLUT if packed - let clut = if packed { + let clut = if pack { let (clut, sz) = get_clut(c_data(b, p..)?)?; p += sz; Some(clut) @@ -53,115 +44,148 @@ pub fn read_bitmap_area(mut im: Image8, p += c_u16b(b, p)? as usize; // maskRgn } - let rle = pack_typ == PACK_DEFAULT || - (pack_typ == PACK_RLE16 && depth == 16) || - (pack_typ == PACK_RLE32 && depth == 32); + let rle = pack_t == PackType::Default || + pack_t == PackType::Rle16 && depth == 16 || + pack_t == PackType::Rle32 && depth == 32; - let pitch = (pitch_fl & 0x3fff) as usize; + let pitch = (pt_fl & 0x3FFF) as usize; - match depth { - 1 | 2 | 4 | 8 => { - let clut = ok!(clut, "no CLUT in indexed mode")?; - if pitch < 8 && depth == 8 { - // uncompressed 8-bit colormap indices - for _ in 0..h { - for _ in 0..w { - let idx = c_byte(b, (p, p += 1).0)? as usize; - im.cr.push(ok!(clut.get(idx), "invalid index")?.clone()); - } - } + Ok((&b[p..], Header{pitch, pack_t, depth, clut, rle})) +} - Ok(im) - } else if rle { - // RLE compressed 1, 2, 4 or 8 bit colormap indices - for _ in 0..h { - let (d, pp) = read_rle(c_data(b, p..)?, pitch, false)?; - let d = if depth < 8 {expand_data(d, depth)?} else {d}; +/// Reads an indexed PixMap. +fn read_pm_ind(mut im: Image8, b: &[u8], hdr: Header) -> ResultS +{ + let clut = ok!(hdr.clut, "no CLUT in indexed mode")?; + let mut p = 0; - p += pp; - - for x in 0..w { - let idx = c_byte(&d, x)? as usize; - im.cr.push(ok!(clut.get(idx), "invalid index")?.clone()); - } - } - - Ok(im) - } else { - Err(err_msg("invalid configuration")) + if hdr.pitch < 8 && hdr.depth == 8 { + // uncompressed 8-bit colormap indices + for _ in 0..im.h() { + for _ in 0..im.w() { + let idx = c_byte(b, p)? as usize; + im.cr.push(ok!(clut.get(idx), "invalid index")?.clone()); + p += 1; } } - 16 => { - if pitch < 8 || pack_typ == PACK_NONE { - // uncompressed R5G5B5 - for _ in 0..h { - for _ in 0..w { - im.cr.push(r5g5b5_to_rgb8(c_u16b(b, (p, p += 2).0)?)); - } - } - Ok(im) - } else if rle { - // RLE compressed R5G5B5 - for _ in 0..h { - let (d, pp) = read_rle(c_data(b, p..)?, pitch, true)?; + Ok(im) + } else if hdr.rle { + // RLE compressed 1, 2, 4 or 8 bit colormap indices + for _ in 0..im.h() { + let (d, pp) = read_rle(c_data(b, p..)?, hdr.pitch, false)?; + let d = if hdr.depth < 8 {expand_data(d, hdr.depth)?} else {d}; - p += pp; + p += pp; - for x in 0..w { - im.cr.push(r5g5b5_to_rgb8(c_u16b(&d, x * 2)?)); - } - } - - Ok(im) - } else { - Err(err_msg("invalid configuration")) + for x in 0..im.w() { + let idx = c_byte(&d, x)? as usize; + im.cr.push(ok!(clut.get(idx), "invalid index")?.clone()); } } - 32 => { - if pitch < 8 || pack_typ == PACK_NONE || pack_typ == PACK_NOPAD { - // uncompressed RGB8 or XRGB8 - for _ in 0..h { - for _ in 0..w { - if pack_typ != PACK_NOPAD { - p += 1; - } - let r = c_byte(b, p)?; - let g = c_byte(b, p + 1)?; - let b = c_byte(b, p + 2)?; - p += 3; - im.cr.push(Color8::new(r, g, b)); - } - } - Ok(im) - } else if rle { - // RLE compressed RGB8 - let pitch = pitch - w; // remove padding byte from pitch - for _ in 0..h { - let (d, pp) = read_rle(c_data(b, p..)?, pitch, false)?; + Ok(im) + } else { + bail!("invalid configuration") + } +} - p += pp; +/// Reads a R5G5B5 PixMap. +fn read_pm_16(mut im: Image8, b: &[u8], hdr: Header) -> ResultS +{ + let mut p = 0; - for x in 0..w { - let r = c_byte(&d, x + w)?; - let g = c_byte(&d, x + w * 1)?; - let b = c_byte(&d, x + w * 2)?; - im.cr.push(Color8::new(r, g, b)); - } - } - - Ok(im) - } else { - Err(err_msg("invalid configuration")) + if hdr.pitch < 8 || hdr.pack_t == PackType::None { + // uncompressed R5G5B5 + for _ in 0..im.h() { + for _ in 0..im.w() { + im.cr.push(r5g5b5_to_rgb8(c_u16b(b, p)?)); + p += 2; } } - _ => Err(err_msg("invalid bit depth")), + + Ok(im) + } else if hdr.rle { + // RLE compressed R5G5B5 + for _ in 0..im.h() { + let (d, pp) = read_rle(c_data(b, p..)?, hdr.pitch, true)?; + + p += pp; + + for x in 0..im.w() { + im.cr.push(r5g5b5_to_rgb8(c_u16b(&d, x * 2)?)); + } + } + + Ok(im) + } else { + bail!("invalid configuration") + } +} + +/// Reads a RGB8 PixMap. +fn read_pm_32(mut im: Image8, b: &[u8], hdr: Header) -> ResultS +{ + let mut p = 0; + + if hdr.pitch < 8 || hdr.pack_t == PackType::None || hdr.pack_t == PackType::NoPad { + // uncompressed RGB8 or XRGB8 + for _ in 0..im.h() { + for _ in 0..im.w() { + if hdr.pack_t != PackType::NoPad { + p += 1; + } + let r = c_byte(b, p)?; + let g = c_byte(b, p + 1)?; + let b = c_byte(b, p + 2)?; + p += 3; + im.cr.push(Color8::new(r, g, b)); + } + } + + Ok(im) + } else if hdr.rle { + // RLE compressed RGB8 + let pitch = hdr.pitch - im.w(); // remove padding byte from pitch + for _ in 0..im.h() { + let (d, pp) = read_rle(c_data(b, p..)?, pitch, false)?; + + p += pp; + + for x in 0..im.w() { + let r = c_byte(&d, x + im.w())?; + let g = c_byte(&d, x + im.w() * 2)?; + let b = c_byte(&d, x + im.w() * 3)?; + im.cr.push(Color8::new(r, g, b)); + } + } + + Ok(im) + } else { + bail!("invalid configuration") + } +} + +/// Process a CopyBits operation. +fn read_pm_area(im: Image8, + b: &[u8], + pack: bool, + clip: bool) + -> ResultS +{ + let p = if pack {0} else {4}; + let (b, hdr) = read_pm_header(&b[p..], pack, clip, &im)?; + + match hdr.depth { + 1 | 2 | 4 | 8 => read_pm_ind(im, b, hdr), + 16 => read_pm_16(im, b, hdr), + 32 => read_pm_32(im, b, hdr), + _ => bail!("invalid bit depth"), } } /// Process a CompressedQuickTime operation. -pub fn read_quicktime_c(_im: Image8, _b: &[u8]) -> ResultS +fn read_quicktime_c(_im: Image8, _b: &[u8]) -> ResultS { unimplemented!() } @@ -176,24 +200,25 @@ pub fn load_pict(b: &[u8]) -> ResultS let mut p = 10; // size of header while p < b.len() { - let op = c_u16b(b, (p, p += 2).0)?; + let op = c_u16b(b, p)?; + p += 2; match op { 0x0098 => { // PackBitsRect - return read_bitmap_area(im, c_data(b, p..)?, true, false); + return read_pm_area(im, c_data(b, p..)?, true, false); } 0x0099 => { // PackBitsRgn - return read_bitmap_area(im, c_data(b, p..)?, true, true); + return read_pm_area(im, c_data(b, p..)?, true, true); } 0x009a => { // DirectBitsRect - return read_bitmap_area(im, c_data(b, p..)?, false, false); + return read_pm_area(im, c_data(b, p..)?, false, false); } 0x009b => { // DirectBitsRgn - return read_bitmap_area(im, c_data(b, p..)?, false, true); + return read_pm_area(im, c_data(b, p..)?, false, true); } 0x8200 => { // CompressedQuickTime @@ -223,8 +248,7 @@ pub fn load_pict(b: &[u8]) -> ResultS 0x0015 | // PnLocHFrac 0x0016 | // ChExtra 0x0023 | // ShortLineFrom - 0x00a0 | // ShortComment - 0x02ff => p += 2, // Version + 0x00a0 => p += 2, // ShortComment 0x0006 | // SpExtra 0x0007 | // PnSize 0x000b | // OvSize @@ -247,7 +271,6 @@ pub fn load_pict(b: &[u8]) -> ResultS 0x0033 | // InvertRect 0x0034 => p += 8, // FillRect 0x002d => p += 10, // LineJustify - 0x0c00 => p += 24, // HeaderOp 0x0001 => p += (c_u16b(b, p )? & !1) as usize, // Clip 0x00a1 => p += (c_u16b(b, p+2)? & !1) as usize + 2, // LongComment 0x100..= @@ -302,10 +325,11 @@ pub fn read_rle(b: &[u8], pitch: usize, ln: bool) -> ResultS<(Vec, usize)> }; while p < sz { - let szf = c_byte(b, (p, p += 1).0)?; + let szf = c_byte(b, p)?; let cmp = szf & 0x80 != 0; let len = if cmp {!szf + 2} else {szf + 1} as usize; + p += 1; o.reserve(len); if ln { @@ -356,9 +380,9 @@ pub fn expand_data(b: Vec, depth: u16) -> ResultS> for ch in b { match depth { - 4 => {for i in 1..=0 {o.push(ch >> i * 4 & 0xFu8);}} // 2 nibbles - 2 => {for i in 3..=0 {o.push(ch >> i * 2 & 0x3u8);}} // 4 dibits - 1 => {for i in 7..=0 {o.push(ch >> i * 1 & 0x1u8);}} // 8 bits + 4 => {for i in (0..=1).rev() {o.push(ch >> (i * 4) & 0xFu8);}} + 2 => {for i in (0..=3).rev() {o.push(ch >> (i * 2) & 0x3u8);}} + 1 => {for i in (0..=7).rev() {o.push(ch >> i & 0x1u8);}} _ => bail!("invalid bit depth"), } } @@ -366,4 +390,25 @@ pub fn expand_data(b: Vec, depth: u16) -> ResultS> Ok(o) } +struct Header +{ + pitch: usize, + pack_t: PackType, + depth: u16, + clut: Option>, + rle: bool, +} + +c_enum! { + #[derive(PartialEq)] + enum PackType: u16 + { + 0 => Default, + 1 => None, + 2 => NoPad, + 3 => Rle16, + 4 => Rle32, + } +} + // EOF diff --git a/src/marathon/shp.rs b/src/marathon/shp.rs index 5283b16..bea73c6 100644 --- a/src/marathon/shp.rs +++ b/src/marathon/shp.rs @@ -29,9 +29,7 @@ fn tab_coll(b: &[u8], let mut tabs = vec![vec![ColorShp::Translucent; clr_num]; tab_num]; let mut p = 0; - for i in 0..tab_num { - let clut = &mut tabs[i]; - + for clut in tabs.iter_mut().take(tab_num) { for _ in 0..clr_num { let (i, cr) = color(c_data(b, p..)?)?; diff --git a/src/marathon/term.rs b/src/marathon/term.rs index 8dc100b..474bed5 100644 --- a/src/marathon/term.rs +++ b/src/marathon/term.rs @@ -133,7 +133,7 @@ impl fmt::Debug for Group fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Group{{{:?} {} {}", self.ttype, self.pdata, self.lines)?; - if self.text.len() != 0 { + if !self.text.is_empty() { write!(f, ";\n{}", self.text)?; } write!(f, "}}") diff --git a/src/marathon/wad.rs b/src/marathon/wad.rs index 9885153..5c91412 100644 --- a/src/marathon/wad.rs +++ b/src/marathon/wad.rs @@ -119,10 +119,10 @@ impl fmt::Debug for Entry<'_> fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Entry{{ ")?; - for (iden, _) in &self.chunks { + for iden in self.chunks.keys() { write!(f, "{} ", mac_roman_conv(iden))?; } - if self.appdata.len() != 0 { + if !self.appdata.is_empty() { write!(f, "\nappdata: {:?} ", self.appdata)?; } write!(f, "}}")