Add EXEC command.

Lets you execute a script as if the user had typed those bytes into the console.

Author: thejpster

src/commands/fs.rs

@@ -1,7 +1,5 @@
 //! File Systems related commands for Neotron OS
 
-use embedded_sdmmc::VolumeIdx;
-
 use crate::{bios, osprint, osprintln, Ctx};
 
 pub static DIR_ITEM: menu::Item<Ctx> = menu::Item {
@@ -25,6 +23,18 @@ pub static LOAD_ITEM: menu::Item<Ctx> = menu::Item {
     help: Some("Load a file into the application area"),
 };
 
+pub static EXEC_ITEM: menu::Item<Ctx> = menu::Item {
+    item_type: menu::ItemType::Callback {
+        function: exec,
+        parameters: &[menu::Parameter::Mandatory {
+            parameter_name: "file",
+            help: Some("The shell script to run"),
+        }],
+    },
+    command: "exec",
+    help: Some("Execute a shell script"),
+};
+
 pub static TYPE_ITEM: menu::Item<Ctx> = menu::Item {
     item_type: menu::ItemType::Callback {
         function: typefn,
@@ -45,7 +55,7 @@ fn dir(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, _args: &[&str], _ctx: &
         let time = crate::fs::BiosTime();
         let mut mgr = embedded_sdmmc::VolumeManager::new(bios_block, time);
         // Open the first partition
-        let volume = mgr.open_volume(VolumeIdx(0))?;
+        let volume = mgr.open_volume(embedded_sdmmc::VolumeIdx(0))?;
         let root_dir = mgr.open_root_dir(volume)?;
         let mut total_bytes = 0u64;
         let mut num_files = 0;
@@ -112,14 +122,49 @@ fn load(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], ctx: &m
     }
 }
 
+/// Called when the "exec" command is executed.
+fn exec(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], ctx: &mut Ctx) {
+    fn work(ctx: &mut Ctx, filename: &str) -> Result<(), embedded_sdmmc::Error<bios::Error>> {
+        let bios_block = crate::fs::BiosBlock();
+        let time = crate::fs::BiosTime();
+        let mut mgr = embedded_sdmmc::VolumeManager::new(bios_block, time);
+        // Open the first partition
+        let volume = mgr.open_volume(embedded_sdmmc::VolumeIdx(0))?;
+        let root_dir = mgr.open_root_dir(volume)?;
+        let file = mgr.open_file_in_dir(root_dir, filename, embedded_sdmmc::Mode::ReadOnly)?;
+        let buffer = ctx.tpa.as_slice_u8();
+        let count = mgr.read(file, buffer)?;
+        if count != mgr.file_length(file)? as usize {
+            osprintln!("File too large! Max {} bytes allowed.", buffer.len());
+            return Ok(());
+        }
+        let Ok(s) = core::str::from_utf8(&buffer[0..count]) else {
+            osprintln!("File is not valid UTF-8");
+            return Ok(());
+        };
+        // tell the main loop to run from these bytes next
+        ctx.exec_tpa = Some(s.len());
+        Ok(())
+    }
+
+    // index can't panic - we always have enough args
+    let r = work(ctx, args[0]);
+    match r {
+        Ok(_) => {}
+        Err(e) => {
+            osprintln!("Error: {:?}", e);
+        }
+    }
+}
+
 /// Called when the "type" command is executed.
 fn typefn(_menu: &menu::Menu<Ctx>, _item: &menu::Item<Ctx>, args: &[&str], ctx: &mut Ctx) {
     fn work(ctx: &mut Ctx, filename: &str) -> Result<(), embedded_sdmmc::Error<bios::Error>> {
         let bios_block = crate::fs::BiosBlock();
         let time = crate::fs::BiosTime();
         let mut mgr = embedded_sdmmc::VolumeManager::new(bios_block, time);
         // Open the first partition
-        let volume = mgr.open_volume(VolumeIdx(0))?;
+        let volume = mgr.open_volume(embedded_sdmmc::VolumeIdx(0))?;
         let root_dir = mgr.open_root_dir(volume)?;
         let file = mgr.open_file_in_dir(root_dir, filename, embedded_sdmmc::Mode::ReadOnly)?;
         let buffer = ctx.tpa.as_slice_u8();

src/commands/mod.rs

@@ -27,6 +27,7 @@ pub static OS_MENU: menu::Menu<Ctx> = menu::Menu {
         &ram::RUN_ITEM,
         &ram::LOAD_ITEM,
         &fs::LOAD_ITEM,
+        &fs::EXEC_ITEM,
         &fs::TYPE_ITEM,
         &screen::CLS_ITEM,
         &screen::MODE_ITEM,

src/lib.rs

@@ -325,6 +325,9 @@ impl StdInput {
 pub struct Ctx {
     config: config::Config,
     tpa: program::TransientProgramArea,
+    /// This flag is set if the "run" command is entered. It tells us
+    /// to take our input bytes from the TPA.
+    exec_tpa: Option<usize>,
 }
 
 impl core::fmt::Write for Ctx {
@@ -441,6 +444,7 @@ pub extern "C" fn os_main(api: &bios::Api) -> ! {
             // We have to trust the values given to us by the BIOS. If it lies, we will crash.
             program::TransientProgramArea::new(tpa_start, tpa_size)
         },
+        exec_tpa: None,
     };
 
     osprintln!(
@@ -461,6 +465,35 @@ pub extern "C" fn os_main(api: &bios::Api) -> ! {
         for b in &buffer[0..count] {
             menu.input_byte(*b);
         }
+        // TODO: Consider recursively executing scripts, so that scripts can
+        // call scripts.
+        if let Some(n) = menu.context.exec_tpa {
+            menu.context.exec_tpa = None;
+            let ptr = menu.context.tpa.steal_top(n);
+            osprintln!("\rExecuting TPA...");
+            let mut has_chars = false;
+            let slice = unsafe { core::slice::from_raw_parts(ptr, n) };
+            // TODO: Give the user some way to break out of the loop.
+            for b in slice {
+                // Files contain `\n` or `\r\n` line endings.
+                // menu wants `\r` line endings.
+                if *b == b'\n' {
+                    if has_chars {
+                        // Execute this line
+                        menu.input_byte(b'\r');
+                        has_chars = false;
+                    }
+                } else if *b == b'\r' {
+                    // Drop carriage returns
+                } else {
+                    menu.input_byte(*b);
+                    has_chars = true;
+                }
+            }
+            unsafe {
+                menu.context.tpa.restore_top(n);
+            }
+        }
         (api.power_idle)();
     }
 }

src/program.rs

@@ -177,25 +177,24 @@ impl TransientProgramArea {
 
     /// Borrow the TPA region as a slice of words
     pub fn as_slice_u32(&mut self) -> &mut [u32] {
-        unsafe {
-            core::slice::from_raw_parts_mut(
-                self.memory_bottom,
-                self.memory_top.offset_from(self.memory_bottom) as usize,
-            )
-        }
+        unsafe { core::slice::from_raw_parts_mut(self.memory_bottom, self.size_words()) }
     }
 
     /// Borrow the TPA region as a slice of bytes
     pub fn as_slice_u8(&mut self) -> &mut [u8] {
         unsafe {
             core::slice::from_raw_parts_mut(
                 self.memory_bottom as *mut u8,
-                (self.memory_top.offset_from(self.memory_bottom) as usize)
-                    * core::mem::size_of::<u32>(),
+                self.size_words() * core::mem::size_of::<u32>(),
             )
         }
     }
 
+    /// Size of the TPA in 32-bit words
+    fn size_words(&self) -> usize {
+        unsafe { self.memory_top.offset_from(self.memory_bottom) as usize }
+    }
+
     /// Loads a program from disk into the Transient Program Area.
     ///
     /// The program must be in the Neotron Executable format.
@@ -270,6 +269,38 @@ impl TransientProgramArea {
         self.last_entry = 0;
         Ok(result)
     }
+
+    /// Move data to the top of TPA and make TPA shorter.
+    ///
+    /// Moves `size` bytes to the top of the TPA, and then pretends the TPA is
+    /// `size` bytes shorter than it was.
+    ///
+    /// `size` will be rounded up to a multiple of 4.
+    ///
+    /// Panics if `n` is too big to fit in the TPA.
+    ///
+    /// Returns a pointer to the data that now sits outside of the TPA. There
+    /// will be `size` bytes at this address but you must manage the lifetimes
+    /// yourself.
+    pub fn steal_top(&mut self, size: usize) -> *const u8 {
+        let stolen_words = (size + 3) / 4;
+        if stolen_words >= self.size_words() {
+            panic!("Stole too much from TPA!");
+        }
+        unsafe {
+            // Top goes down to free memory above it
+            let new_top = self.memory_top.sub(stolen_words);
+            // Copy the data from the bottom to above the newly reduced TPA
+            core::ptr::copy(self.memory_bottom, new_top, stolen_words);
+            new_top as *mut u8
+        }
+    }
+
+    /// Restore the TPA back where it was.
+    pub unsafe fn restore_top(&mut self, size: usize) {
+        let restored_words = (size + 3) / 4;
+        self.memory_top = self.memory_top.add(restored_words);
+    }
 }
 
 /// Application API to print things to the console.