Struct gluon_vm::stack::StackFrame

pub struct StackFrame<'b, S = State> where
    S: StackState,  {
    pub stack: &'b mut Stack,
    pub frame: Frame<S>,
}

Fields

stack: &'b mut Stack

frame: Frame<S>

Methods

impl<'a: 'b, 'b> StackFrame<'b, State>

pub fn from_state<T>(self) -> StackFrame<'b, T> where
    T: StackState, 

pub fn frame(
    stack: &'b mut Stack,
    args: VmIndex,
    state: State
) -> StackFrame<'b>

impl<'a: 'b, 'b> StackFrame<'b, ExternState>

pub fn into_lock(self) -> Lock

Lock the stack below the current offset

impl<'a: 'b, 'b, S> StackFrame<'b, S> where
    S: StackState, 

pub fn take_stack(self) -> &'b mut Stack where
    S: Copy, 

pub fn len(&self) -> VmIndex

pub fn push<T>(&mut self, v: T) where
    T: StackPrimitive, 

pub fn top(&self) -> &Value

pub fn pop(&mut self) -> Value

pub fn pop_many(&mut self, count: VmIndex)

pub fn clear(&mut self)

pub fn slide(&mut self, count: VmIndex)

pub fn get_variant(&self, index: VmIndex) -> Option<Variants>

pub fn get_value<'vm, 'value, T>(
    &'value self,
    thread: &'vm Thread,
    index: VmIndex
) -> Option<T> where
    T: Getable<'vm, 'value>, 

pub fn insert_slice(&mut self, index: VmIndex, values: &[Value])

pub fn remove_range(&mut self, from: VmIndex, to: VmIndex)

pub fn excess_args(&self) -> Option<GcPtr<DataStruct>>

pub fn store_frame(&mut self) where
    S: StackState + Copy, 

impl<'b> StackFrame<'b, ClosureState>

pub fn get_upvar(&self, index: VmIndex) -> &Value

Trait Implementations

impl<'b, 'c, T, S> Extend<&'c T> for StackFrame<'b, S> where
    T: StackPrimitive + 'c,
    S: StackState, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'c T>, 

Extends a collection with the contents of an iterator.

impl<'b, S> Drop for StackFrame<'b, S> where
    S: StackState, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'b, S> DerefMut for StackFrame<'b, S> where
    S: StackState, 

fn deref_mut(&mut self) -> &mut [Value]

Mutably dereferences the value.

impl<'b, S> Deref for StackFrame<'b, S> where
    S: StackState, 

type Target = [Value]

The resulting type after dereferencing.

fn deref(&self) -> &[Value]

Dereferences the value.

impl<'b, S> Index<u32> for StackFrame<'b, S> where
    S: StackState, 

type Output = Value

The returned type after indexing.

fn index(&self, index: VmIndex) -> &Value

Performs the indexing (container[index]) operation.

impl<'b, S> Index<RangeFull> for StackFrame<'b, S> where
    S: StackState, 

type Output = [Value]

The returned type after indexing.

fn index(&self, _: RangeFull) -> &[Value]

Performs the indexing (container[index]) operation.

impl<'b, S> Index<Range<u32>> for StackFrame<'b, S> where
    S: StackState, 

type Output = [Value]

The returned type after indexing.

fn index(&self, range: Range<VmIndex>) -> &[Value]

Performs the indexing (container[index]) operation.

impl<'b, S> Index<RangeTo<u32>> for StackFrame<'b, S> where
    S: StackState, 

type Output = [Value]

The returned type after indexing.

fn index(&self, range: RangeTo<VmIndex>) -> &[Value]

Performs the indexing (container[index]) operation.

impl<'b, S> Index<RangeFrom<u32>> for StackFrame<'b, S> where
    S: StackState, 

type Output = [Value]

The returned type after indexing.

fn index(&self, range: RangeFrom<VmIndex>) -> &[Value]

Performs the indexing (container[index]) operation.

impl<'b, S> IndexMut<u32> for StackFrame<'b, S> where
    S: StackState, 

fn index_mut(&mut self, index: VmIndex) -> &mut Value

Performs the mutable indexing (container[index]) operation.

impl<'b, S> IndexMut<RangeFull> for StackFrame<'b, S> where
    S: StackState, 

fn index_mut(&mut self, _: RangeFull) -> &mut [Value]

Performs the mutable indexing (container[index]) operation.

impl<'b, S> IndexMut<Range<u32>> for StackFrame<'b, S> where
    S: StackState, 

fn index_mut(&mut self, range: Range<VmIndex>) -> &mut [Value]

Performs the mutable indexing (container[index]) operation.

impl<'b, S> IndexMut<RangeTo<u32>> for StackFrame<'b, S> where
    S: StackState, 

fn index_mut(&mut self, range: RangeTo<VmIndex>) -> &mut [Value]

Performs the mutable indexing (container[index]) operation.

impl<'b, S> IndexMut<RangeFrom<u32>> for StackFrame<'b, S> where
    S: StackState, 

fn index_mut(&mut self, range: RangeFrom<VmIndex>) -> &mut [Value]

Performs the mutable indexing (container[index]) operation.

impl<'b, S> Debug for StackFrame<'b, S> where
    S: Debug + StackState, 

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

Formats the value using the given formatter.