Struct passerine::vm::stack::Stack

pub struct Stack {
    pub frames: Linked,
    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: Linked

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)

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)

Pushes a new stack frame onto the Stack.

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 local_data(&mut self, index: usize) -> Data

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

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

Formats the value using the given formatter.