Struct Loadable 

pub struct Loadable<I, M: Composite> { /* private fields */ }

A program image and the composite that executes its borrowed instructions.

Construct the image explicitly before pairing it with a machine. Only Image is supported; the image remains unchanged throughout an invocation. Ordinary outer structs can own several loadables with different instruction sets. Section selection and image construction remain caller responsibilities.

Implementations

impl<Inst, V, Ty, Info, M: Composite> Loadable<Image<Inst, V, Ty, Info>, M>

pub fn image(&self) -> &Image<Inst, V, Ty, Info>

Inspect the paired image without changing an invocation’s program data.

pub fn machine(&self) -> &M

Inspect the execution machine and its devices.

pub fn machine_mut(&mut self) -> &mut M

Configure the execution machine or its devices.

Direct changes to execution state can affect whether an invocation can resume. The caller is responsible for keeping those changes consistent with the paired image.

pub fn into_parts(self) -> (Image<Inst, V, Ty, Info>, M)

Consume the owner, returning its image and machine without resetting them.

impl<Inst, V, Ty, Info, M> Loadable<Image<Inst, V, Ty, Info>, M>

where M: Composite + HasProgram<Program = ExecutionState>,

pub fn new(image: Image<Inst, V, Ty, Info>, machine: M) -> Self

Pair an image with a machine, resetting its previous invocation state.

Device state is retained. No parsing, lowering, or image validation is performed here; construction of a valid image is the caller’s job.

pub fn replace_image(&mut self, image: Image<Inst, V, Ty, Info>) -> Result<()>

Install an already constructed image and reset execution state.

Device state is retained. Image construction happens before this call; mutations made by the caller while constructing it are not rolled back.

Errors

Rejects replacement while an invocation is active, including one that could resume after an execution error. Call Self::reset to abandon that invocation first. Rejection leaves the current image and execution state unchanged.

pub fn reset(&mut self)

Abandon the invocation, retaining the image and all device state.

impl<Inst, V, Ty, Info, M> Loadable<Image<Inst, V, Ty, Info>, M>

where M: HasProgram<Program = ExecutionState> + Dispatch<LocalModule<Inst, V, Ty, Info>, Instruction = Inst>,

pub fn execute(&mut self, arguments: &[Word]) -> Result<()>

Start at the program entrypoint with the supplied arguments.

Instructions and metadata borrow the image while dispatch mutates the separate machine. No instruction cloning is required.

Errors

Returns the runner’s entry or execution errors. Earlier machine mutations are retained; reset or resume according to the invocation’s state.

pub fn resume(&mut self) -> Result<()>

Continue the existing invocation against the same paired image.

Errors

Returns the runner’s state, instruction-fetch, or dispatch errors without rolling back machine mutations. A halted invocation remains halted.

Trait Implementations

impl<I: Debug, M: Debug + Composite> Debug for Loadable<I, M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.