Struct passerine::vm::stack::Stack

pub struct Stack {
    pub frames: Vec<usize>,
    pub stack: Vec<Tagged>,
}

A stack of Tagged Data. Note that in general the stack is expected to follow the following pattern:

FV...V...F V...T... ...

Or in other words, a frame followed by a block of n values that are locals followed by n temporaries, ad infinitum.

Fields

frames: Vec<usize>

stack: Vec<Tagged>

Implementations

impl Stack

pub fn init() -> Stack

Create a new Stack with a single frame.

pub fn push_data(&mut self, data: Data)

Pushes some Data onto the Stack, tagging it along the way

pub fn push_tagged(&mut self, tagged: Tagged)

Pushes some Tagged Data onto the Stack without unwrapping it.

pub fn pop_data(&mut self) -> Data

Pops some Data of the Stack, panicking if what it pops is not Data. Note that this will never return a Heaped value, rather cloning the value inside.

pub fn pop_frame(&mut self) -> Suspend

Pops a stack frame from the Stack, restoring the previous frame. Panics if there are no frames left on the stack.

pub fn push_frame(&mut self, suspend: Suspend)

Pushes a new stack frame onto the Stack. Takes the old suspended closure / ip, and stores that on the stack.

pub fn push_not_init(&mut self)

Shorcut for pushing a Tagged(Slot::NotInit) on top of the stack.

pub fn declare(&mut self, decls: usize)

Shortcut for calling push_not_init N times.

pub fn heapify(&mut self, index: usize)

Wraps the top data value on the stack in Data::Heaped, data must not already be on the heap

pub fn unwind_frame(&mut self) -> bool

Truncates the stack to the last frame. Returns true if the stack can not be unwound further.

pub fn local_slot(&mut self, index: usize) -> Slot

returns a copy of the Slot of a local variable on the stack.

pub fn local_data(&mut self, index: usize) -> Data

Returns a copy of the Data stored in a local variable on the stack.

pub fn set_local(&mut self, index: usize)

Sets a local - note that this function doesn’t do much. It’s a simple swap-and-drop. If a new local is being declared, it’s literally a bounds-check and no-op.

Trait Implementations

impl Debug for Stack

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

Formats the value using the given formatter.