src/Tools/readmap/src/dump/mod.rs

@@ -0,0 +1,32 @@
+use super::Error;
+use super::types::{MemoryMap, Symbol};
+use tool_helper::Output;
+
+pub fn write(mut out: Output, memory_map: &MemoryMap) -> Result<Output, Error> {
+    const NAME_WIDTH:usize = 64;
+    fn print_symbols(out: &mut Output, symbols: &Vec<Symbol>) -> Result<(), Error> {
+        for symbol in symbols {
+            let mut name = symbol.name.as_str();
+
+            if name.len() > NAME_WIDTH {
+                writeln!(out, "\t{}", name)?;
+                name = " ";
+            }
+
+            writeln!(out, "\t{:<width$} @0x{:X}", name, symbol.adr, width=NAME_WIDTH)?;
+        }
+
+        Ok(())
+    }
+
+    writeln!(out, "<GLOBAL>:")?;
+    print_symbols(&mut out, &memory_map.global)?;
+    for section in &memory_map.sections {
+        let section_end = section.adr + section.size as u64;
+
+        writeln!(out, "{}: @0x{:X} - 0x{:X}", section.name, section.adr, section_end)?;
+        print_symbols(&mut out, &section.symbols)?;
+    }
+
+    Ok(out)
+}

src/Tools/readmap/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod types;
+pub mod dump;
 
 use tool_helper::Error;
 use types::{MemoryMap, Section, Symbol};

src/Tools/readmap/src/main.rs

@@ -1,14 +1,31 @@
 use clap::Parser;
 use tool_helper::{Error, exit_with_error};
+use readmap::types::MemoryMap;
 use std::{io::{BufRead, BufReader}, path::PathBuf, process::{Child, Command, Stdio}};
 
 #[derive(Parser)]
 #[clap(about = "Opens and scans a MAP file to print extended information", long_about = None)]
 struct CommandLine {
     #[clap(value_parser, help="Input MAP file for scannning")]
-    input:          PathBuf,
+    input:   PathBuf,
     #[clap(long="wsl", default_value_t=false)]
-    use_wsl:        bool,
+    use_wsl: bool,
+    #[clap(short='o')]
+    output:  Option<PathBuf>
+}
+
+pub fn main() {
+    match CommandLine::try_parse() {
+        Ok(cmd_line) => {
+            match run_main(cmd_line) {
+                Ok(_)      => (),
+                Err(error) => exit_with_error(error)
+            }
+        },
+        Err(error) => {
+            println!("{}", error)
+        }
+    }
 }
 
 fn run_objdump(use_wsl: bool, input: PathBuf) -> Result<Child, Error> {
@@ -28,31 +45,24 @@ fn run_objdump(use_wsl: bool, input: PathBuf) -> Result<Child, Error> {
 }
 
 fn run_main(cmd: CommandLine) -> Result<(), Error> {
-    let mut child = run_objdump(cmd.use_wsl, cmd.input)?;
+    let output     = tool_helper::open_output(cmd.output)?;
+    let memory_map = generate_memory_map(cmd.use_wsl, cmd.input)?;
+
+    readmap::dump::write(output, &memory_map)?;
+    Ok(())
+}
+
+fn generate_memory_map(use_wsl: bool, input: PathBuf) -> Result<MemoryMap, Error> {
+    let mut child = run_objdump(use_wsl, input)?;
     if let Some(stdout) = &mut child.stdout {
         let mut line_iter = BufReader::new(stdout).lines().map(|l| l.unwrap()).into_iter();
         
         readmap::scan(|| {
             line_iter.next()
-        })?;
-        Ok(())
+        })
     }
 
     else {
         Err(Error::from_str("Failed opening \"stdout\" for objdump"))
-    }
+    }    
 }
-
-pub fn main() {
-    match CommandLine::try_parse() {
-        Ok(cmd_line) => {
-            match run_main(cmd_line) {
-                Ok(_)      => (),
-                Err(error) => exit_with_error(error)
-            }
-        },
-        Err(error) => {
-            println!("{}", error)
-        }
-    }
-}