Add hexdump demo.

Author: thejpster

samples/Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "fault",
     "hello",
+    "hexdump",
     "input-test",
     "panic",
 ]

samples/build.sh

@@ -32,7 +32,7 @@ pushd asmhello
 ./build.sh ${TARGET}
 popd
 
-for program in panic hello fault input-test; do
+for program in panic hello fault input-test hexdump; do
     cp ./target/${TARGET}/release/${program} ./release/${program}.elf
 done
 cp ./asmhello/asmhello.elf ./release

samples/hexdump/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "hexdump"
+version = "0.1.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+authors = ["Jonathan 'theJPster' Pallant <[email protected]>"]
+description = "Prints information about files"
+
+[dependencies]
+neotron-sdk = { path = "../.." }
+
+# See workspace for profile settings

samples/hexdump/README.md

@@ -0,0 +1,20 @@
+# Hexdump
+
+A basic file printing tool for Neotron systems. This program takes an argument
+which is assumed to be a filename. That file is opened, and printed out as hex.
+The output is similar to the UNIX command `hexdump -C`.
+
+See the general sample application [README](../README.md) for compilation instructions.
+
+## Licence
+
+Copyright (c) The Neotron Developers, 2024
+
+Licensed under either [MIT](../../LICENSE-MIT) or [Apache-2.0](../../LICENSE-APACHE) at
+your option.
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you shall be licensed as above, without any
+additional terms or conditions.

samples/hexdump/src/main.rs

@@ -0,0 +1,72 @@
+#![cfg_attr(target_os = "none", no_std)]
+#![cfg_attr(target_os = "none", no_main)]
+
+use core::fmt::Write;
+
+#[cfg(not(target_os = "none"))]
+fn main() {
+    neotron_sdk::init();
+}
+
+#[no_mangle]
+extern "C" fn neotron_main() -> i32 {
+    if let Err(e) = real_main() {
+        let mut stdout = neotron_sdk::stdout();
+        let _ = writeln!(stdout, "Error: {:?}", e);
+        1
+    } else {
+        0
+    }
+}
+
+fn real_main() -> Result<(), neotron_sdk::Error> {
+    let mut stdout = neotron_sdk::stdout();
+    let Some(filename) = neotron_sdk::arg(0) else {
+        return Err(neotron_sdk::Error::InvalidArg);
+    };
+    let _ = writeln!(stdout, "Dumping {:?}...", filename);
+    let path = neotron_sdk::path::Path::new(&filename)?;
+    let f = neotron_sdk::File::open(path, neotron_sdk::Flags::empty())?;
+    let stat = f.stat()?;
+    let mut bytes_remaining = stat.file_size;
+    let _ = writeln!(stdout, "File is {} bytes", bytes_remaining);
+
+    let mut lines_remaining = 24;
+    let mut buffer = [0u8; 16];
+    let mut addr = 0;
+    while bytes_remaining > 0 {
+        let this_time = f.read(&mut buffer)?;
+        let valid = &buffer[0..this_time];
+        // print address
+        let _ = write!(stdout, "{:08x}: ", addr);
+        // print bytes (with padding)
+        for b in valid {
+            let _ = write!(stdout, "{:02x} ", b);
+        }
+        for _padding in 0..(buffer.len() - valid.len()) {
+            let _ = write!(stdout, ".. ");
+        }
+        let _ = write!(stdout, "| ");
+        // print ascii (with padding)
+        for b in valid {
+            let ch = *b as char;
+            let _ = write!(stdout, "{}", if !ch.is_control() { ch } else { '?' });
+        }
+        for _padding in 0..(buffer.len() - valid.len()) {
+            let _ = write!(stdout, ".");
+        }
+        let _ = writeln!(stdout, "|");
+        addr += this_time;
+        bytes_remaining = bytes_remaining.saturating_sub(this_time as u64);
+        if lines_remaining == 0 {
+            if neotron_sdk::wait_for_key() == neotron_sdk::WaitForKey::Quit {
+                break;
+            }
+            lines_remaining = 25;
+        } else {
+            lines_remaining -= 1;
+        }
+    }
+
+    Ok(())
+}

src/lib.rs

@@ -12,7 +12,7 @@ use core::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
 
 pub use neotron_ffi::{FfiBuffer, FfiByteSlice, FfiString};
 
-pub use neotron_api::{path, Api, Error};
+pub use neotron_api::{file::Flags, path, Api, Error};
 
 use neotron_api as api;
 
@@ -216,7 +216,7 @@ impl Drop for File {
             // don't close
         } else {
             // close it
-        let _ = (api.close)(self.0);
+            let _ = (api.close)(self.0);
         }
     }
 }
@@ -372,6 +372,49 @@ pub fn delay(period: core::time::Duration) {
     std::thread::sleep(period);
 }
 
+/// The result of a *Wait for Key* operation.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum WaitForKey {
+    /// User wants more data
+    More,
+    /// User wants to quit
+    Quit,
+}
+
+/// Wait for a key
+pub fn wait_for_key() -> WaitForKey {
+    use core::fmt::Write;
+    let mut ticker = "|/-\\".chars().cycle();
+    let stdin = stdin();
+    let mut stdout = stdout();
+    let result = loop {
+        let _ = write!(
+            stdout,
+            "\rPress Space for more, 'q' to quit... {}",
+            ticker.next().unwrap()
+        );
+        let mut buffer = [0u8; 1];
+        match stdin.read(&mut buffer) {
+            Ok(0) => {
+                // No data
+            }
+            Ok(_n) => {
+                if buffer[0] == b' ' {
+                    break WaitForKey::More;
+                } else if buffer[0] == b'q' || buffer[0] == b'Q' {
+                    break WaitForKey::Quit;
+                }
+            }
+            Err(e) => {
+                let _ = writeln!(stdout, "Error {:?}", e);
+                break WaitForKey::Quit;
+            }
+        }
+    };
+    let _ = write!(stdout, "\r                                         \r");
+    result
+}
+
 static RAND_STATE: core::sync::atomic::AtomicU16 = core::sync::atomic::AtomicU16::new(0);
 
 /// Seed the 16-bit psuedorandom number generator