/// The file was too large for RAM.

ProgramTooLarge,

/// A filesystem error occurred

Filesystem(crate::fs::Error),

/// An ELF error occurred

Elf(neotron_loader::Error<crate::fs::Error>),

/// Tried to run when nothing was loaded

NothingLoaded,

fn from(value: crate::fs::Error) -> Self {

Error::Filesystem(value)

}

fn from(value: neotron_loader::Error<crate::fs::Error>) -> Self {

Error::Elf(value)

}

file: crate::fs::File,

buffer: core::cell::RefCell<[u8; Self::BUFFER_LEN]>,

offset_cached: core::cell::Cell<Option<u32>>,

const BUFFER_LEN: usize = 128;

fn new(file: crate::fs::File) -> FileSource {

FileSource {

file,

buffer: core::cell::RefCell::new([0u8; 128]),

offset_cached: core::cell::Cell::new(None),

}

}

fn uncached_read(&self, offset: u32, out_buffer: &mut [u8]) -> Result<(), crate::fs::Error> {

osprintln!("Reading from {}", offset);

self.file.seek_from_start(offset)?;

self.file.read(out_buffer)?;

Ok(())

}

for chunk in out_buffer.chunks_mut(FileSource::BUFFER_LEN) {

if let Some(offset_cached) = self.offset_cached.get() {

let cached_range = offset_cached..offset_cached + FileSource::BUFFER_LEN as u32;

if cached_range.contains(&offset)

&& cached_range.contains(&(offset + chunk.len() as u32 - 1))

{

// Do a fast copy from the cache

let start = (offset - offset_cached) as usize;

let end = start + chunk.len();

chunk.copy_from_slice(&self.buffer.borrow()[start..end]);

return Ok(());

}

}

osprintln!("Reading from {}", offset);

self.file.seek_from_start(offset)?;

self.file.read(self.buffer.borrow_mut().as_mut_slice())?;

self.offset_cached.set(Some(offset));

chunk.copy_from_slice(&self.buffer.borrow()[0..chunk.len()]);

offset += chunk.len() as u32;

}

Ok(())

memory_bottom: *mut u32,

memory_top: *mut u32,

last_entry: u32,

/// Construct a new [`TransientProgramArea`].

pub unsafe fn new(start: *mut u32, length_in_bytes: usize) -> TransientProgramArea {

let mut tpa = TransientProgramArea {

memory_bottom: start,

memory_top: start.add(length_in_bytes / core::mem::size_of::<u32>()),

last_entry: 0,

};

// You have to take the address of a linker symbol to find out where

// points to, as the linker can only invent symbols pointing at

// addresses; it cannot actually put values in RAM.

#[cfg(all(target_os = "none", target_arch = "arm"))]

let official_tpa_start: Option<*mut u32> = Some((&mut _tpa_start) as *mut u32);

#[cfg(not(all(target_os = "none", target_arch = "arm")))]

let official_tpa_start: Option<*mut u32> = None;

if let Some(tpa_start) = official_tpa_start {

let range = tpa.as_slice_u32().as_ptr_range();

if !range.contains(&(tpa_start as *const u32)) {

panic!("TPA doesn't contain system start address");

}

let offset = tpa_start.offset_from(tpa.memory_bottom);

tpa.memory_bottom = tpa.memory_bottom.offset(offset);

}

tpa

}

/// 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.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.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.

pub fn load_program(&mut self, file_name: &str) -> Result<(), Error> {

osprintln!("Loading /{} from Block Device 0", file_name);

let file = FILESYSTEM.open_file(file_name, embedded_sdmmc::Mode::ReadOnly)?;

let source = FileSource::new(file);

let loader = neotron_loader::Loader::new(&source)?;

let mut iter = loader.iter_program_headers();

while let Some(Ok(ph)) = iter.next() {

if ph.p_vaddr() as *mut u32 >= self.memory_bottom

&& ph.p_type() == neotron_loader::ProgramHeader::PT_LOAD

{

osprintln!("Loading {} bytes to 0x{:08x}", ph.p_memsz(), ph.p_vaddr());

let ram = unsafe {

core::slice::from_raw_parts_mut(ph.p_vaddr() as *mut u8, ph.p_memsz() as usize)

};

// Zero all of it.

for b in ram.iter_mut() {

*b = 0;

}

// Replace some of those zeros with bytes from disk.

if ph.p_filesz() != 0 {

source.uncached_read(ph.p_offset(), &mut ram[0..ph.p_filesz() as usize])?;

}

}

}

self.last_entry = loader.e_entry();

Ok(())

}

/// Copy a program from memory into the Transient Program Area.

///

/// The program must be in the Neotron Executable format.

pub fn copy_program(&mut self, program: &[u8]) -> Result<(), Error> {

let application_ram = self.as_slice_u8();

if program.len() > application_ram.len() {

return Err(Error::ProgramTooLarge);

}

let application_ram = &mut application_ram[0..program.len()];

application_ram.copy_from_slice(program);

Ok(())

}

/// Execute a program.

///

/// If the program returns, you get `Ok(<exit_code>)`. The program returning

/// an exit code that is non-zero is not considered a failure from the point

/// of view of this API. You wanted to run a program, and the program was

/// run.

pub fn execute(&mut self) -> Result<i32, Error> {

if self.last_entry == 0 {

return Err(Error::NothingLoaded);

}

let result = unsafe {

let code: extern "C" fn(*const neotron_api::Api) -> i32 =

::core::mem::transmute(self.last_entry as *const ());

code(&CALLBACK_TABLE)

};

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);

}

let slice = unsafe { core::slice::from_raw_parts(data, len) };

if let Ok(s) = core::str::from_utf8(slice) {

osprint!("{}", s);

} else {

// Ignore App output - not UTF-8

}

_path: neotron_api::FfiString,

_flags: neotron_api::file::Flags,

) -> neotron_api::Result<neotron_api::file::Handle> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

fd: neotron_api::file::Handle,

buffer: neotron_api::FfiByteSlice,

) -> neotron_api::Result<()> {

if fd == neotron_api::file::Handle::new_stdout() {

let mut guard = crate::VGA_CONSOLE.lock();

if let Some(console) = guard.as_mut() {

console.write_bstr(buffer.as_slice());

}

let mut guard = crate::SERIAL_CONSOLE.lock();

if let Some(console) = guard.as_mut() {

// Ignore serial errors on stdout

let _ = console.write_bstr(buffer.as_slice());

}

neotron_api::Result::Ok(())

} else {

neotron_api::Result::Err(neotron_api::Error::BadHandle)

}

fd: neotron_api::file::Handle,

mut buffer: neotron_api::FfiBuffer,

) -> neotron_api::Result<usize> {

if fd == neotron_api::file::Handle::new_stdin() {

if let Some(buffer) = buffer.as_mut_slice() {

let count = { crate::STD_INPUT.lock().get_data(buffer) };

Ok(count).into()

} else {

neotron_api::Result::Err(neotron_api::Error::DeviceSpecific)

}

} else {

neotron_api::Result::Err(neotron_api::Error::BadHandle)

}

_fd: neotron_api::file::Handle,

_position: u64,

) -> neotron_api::Result<()> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

_fd: neotron_api::file::Handle,

_offset: i64,

) -> neotron_api::Result<u64> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

_old_path: neotron_api::FfiString,

_new_path: neotron_api::FfiString,

) -> neotron_api::Result<()> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

_fd: neotron_api::file::Handle,

_command: u64,

_value: u64,

) -> neotron_api::Result<u64> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

_path: neotron_api::FfiString,

) -> neotron_api::Result<neotron_api::dir::Handle> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

_dir: neotron_api::dir::Handle,

) -> neotron_api::Result<neotron_api::dir::Entry> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

_path: neotron_api::FfiString,

) -> neotron_api::Result<neotron_api::file::Stat> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

_fd: neotron_api::file::Handle,

) -> neotron_api::Result<neotron_api::file::Stat> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)

_size: usize,

_alignment: usize,

) -> neotron_api::Result<*mut core::ffi::c_void> {

neotron_api::Result::Err(neotron_api::Error::Unimplemented)