┏┓

┃┃╱╲ in this
┃╱╱╲╲  house
╱╱╭╮╲╲  we
▔▏┗┛▕▔    run
╱▔▔▔▔▔▔▔▔▔▔╲
  cargo fmt
╱╱┏┳┓╭╮┏┳┓ ╲╲
▔▏┗┻┛┃┃┗┻┛▕▔

1 files changed, 61 insertions, 41 deletions

diff --git a/src/main.rs b/src/main.rs
index 97ec7e8..d194a50 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,52 +10,58 @@ use std::io::Read;
 fn main() {
     let _ = include_str!("../Cargo.toml");
     let app = app_from_crate!()
-        .arg(Arg::with_name("arch")
-             .short("a")
-             .long("--architecture")
-             .takes_value(true)
-             .possible_values(&["x86_64", "x86:32", "armv7", "armv8", "avr", "mips", "msp430", "pic17", "pic18", "m16c"])
-             .help("architecture to disassemble input as."))
-        .arg(Arg::with_name("file")
-             .short("f")
-             .long("file")
-             .takes_value(true)
-             .help("file of bytes to decode"))
-        .arg(Arg::with_name("verbose")
-             .short("v")
-             .long("--verbose")
-             .help("increased detail when decoding instructions"))
-        .arg(Arg::with_name("data")
-             .help("hex bytes to decode by the selected architecture. for example, try -a x86_64 33c0c3"));
+        .arg(
+            Arg::with_name("arch")
+                .short("a")
+                .long("--architecture")
+                .takes_value(true)
+                .possible_values(&[
+                    "x86_64", "x86:32", "armv7", "armv8", "avr", "mips", "msp430", "pic17",
+                    "pic18", "m16c",
+                ])
+                .help("architecture to disassemble input as."),
+        )
+        .arg(
+            Arg::with_name("file")
+                .short("f")
+                .long("file")
+                .takes_value(true)
+                .help("file of bytes to decode"),
+        )
+        .arg(
+            Arg::with_name("verbose")
+                .short("v")
+                .long("--verbose")
+                .help("increased detail when decoding instructions"),
+        )
+        .arg(Arg::with_name("data").help(
+            "hex bytes to decode by the selected architecture. for example, try -a x86_64 33c0c3",
+        ));
 
     let matches = app.get_matches();
 
     let arch_str = matches.value_of("arch").unwrap_or("x86_64");
     let buf: Vec<u8> = match matches.value_of("data") {
-        Some(data) => {
-            match hex::decode(data) {
-                Ok(buf) => buf,
-                Err(e) => {
-                    eprintln!("Invalid input, {}. Expected a sequence of bytes as hex", e);
-                    return;
-                }
+        Some(data) => match hex::decode(data) {
+            Ok(buf) => buf,
+            Err(e) => {
+                eprintln!("Invalid input, {}. Expected a sequence of bytes as hex", e);
+                return;
             }
-        }
+        },
         None => {
             let mut v = Vec::new();
             match matches.value_of("file") {
-                Some(name) => {
-                    match File::open(name) {
-                        Ok(mut f) => {
-                            f.read_to_end(&mut v).expect("can read the file");
-                            v
-                        }
-                        Err(e) => {
-                            eprintln!("error opening {}: {}", name, e);
-                            return;
-                        }
+                Some(name) => match File::open(name) {
+                    Ok(mut f) => {
+                        f.read_to_end(&mut v).expect("can read the file");
+                        v
                     }
-                }
+                    Err(e) => {
+                        eprintln!("error opening {}: {}", name, e);
+                        return;
+                    }
+                },
                 None => {
                     eprintln!("data must be provided by either an argument consisting of hex bytes, or by the --file argument.");
                     return;
@@ -76,21 +82,32 @@ fn main() {
         "pic17" => decode_input::<yaxpeax_pic17::PIC17>(&buf, verbose),
         "pic18" => decode_input::<yaxpeax_pic18::PIC18>(&buf, verbose),
         "m16c" => decode_input::<yaxpeax_m16c::M16C>(&buf, verbose),
-//        "pic24" => decode_input::<yaxpeax_pic24::PIC24>(buf),
+        //        "pic24" => decode_input::<yaxpeax_pic24::PIC24>(buf),
         other => {
             println!("unsupported architecture: {}", other);
         }
     }
 }
 
-fn decode_input<A: Arch>(buf: &[u8], verbose: bool) where A::Instruction: fmt::Display {
+fn decode_input<A: Arch>(buf: &[u8], verbose: bool)
+where
+    A::Instruction: fmt::Display,
+{
     let decoder = A::Decoder::default();
     let start = A::Address::zero();
     let mut addr = start;
     loop {
         match decoder.decode(buf[addr.to_linear()..].iter().cloned()) {
             Ok(inst) => {
-                println!("{:#010x}: {:14}: {}", addr.to_linear(), hex::encode(&buf[addr.to_linear()..][..A::Address::zero().wrapping_offset(inst.len()).to_linear()]), inst);
+                println!(
+                    "{:#010x}: {:14}: {}",
+                    addr.to_linear(),
+                    hex::encode(
+                        &buf[addr.to_linear()..]
+                            [..A::Address::zero().wrapping_offset(inst.len()).to_linear()]
+                    ),
+                    inst
+                );
                 if verbose {
                     println!("  {:?}", inst);
                     if !inst.well_defined() {
@@ -98,8 +115,11 @@ fn decode_input<A: Arch>(buf: &[u8], verbose: bool) where A::Instruction: fmt::D
                     }
                 }
                 addr += inst.len();
-            },
-            Err(e) => { println!("{:#010x}: {}", addr.to_linear(), e); addr += A::Instruction::min_size(); },
+            }
+            Err(e) => {
+                println!("{:#010x}: {}", addr.to_linear(), e);
+                addr += A::Instruction::min_size();
+            }
         }
         if addr.to_linear() >= buf.len() {
             break;