Struct Stack

pub struct Stack { /* private fields */ }

The stack of the virtual machine, where all values are stored.

Implementations

impl Stack

pub fn at(&self, addr: InstAddress) -> &Value

Access the value at the given frame offset.

Examples

use rune::vm_try;
use rune::Module;
use rune::runtime::{Output, Stack, VmResult, InstAddress};

fn add_one(stack: &mut Stack, addr: InstAddress, args: usize, out: Output) -> VmResult<()> {
    let value = vm_try!(stack.at(addr).as_integer::<i64>());
    out.store(stack, value + 1);
    VmResult::Ok(())
}

pub fn at_mut(&mut self, addr: InstAddress) -> Result<&mut Value, StackError>

Get a value mutable at the given index from the stack bottom.

Examples

use rune::vm_try;
use rune::Module;
use rune::runtime::{Output, Stack, VmResult, InstAddress};

fn add_one(stack: &mut Stack, addr: InstAddress, args: usize, out: Output) -> VmResult<()> {
    let mut value = vm_try!(stack.at_mut(addr));
    let number = vm_try!(value.as_integer::<i64>());
    *value = vm_try!(rune::to_value(number + 1));
    out.store(stack, ());
    VmResult::Ok(())
}

pub fn slice_at( &self, addr: InstAddress, len: usize, ) -> Result<&[Value], SliceError>

Get the slice at the given address with the given length.

Examples

use rune::vm_try;
use rune::Module;
use rune::runtime::{Output, Stack, ToValue, VmResult, InstAddress};

fn sum(stack: &mut Stack, addr: InstAddress, args: usize, out: Output) -> VmResult<()> {
    let mut number = 0;

    for value in vm_try!(stack.slice_at(addr, args)) {
        number += vm_try!(value.as_integer::<i64>());
    }

    out.store(stack, number);
    VmResult::Ok(())
}

pub fn slice_at_mut( &mut self, addr: InstAddress, len: usize, ) -> Result<&mut [Value], SliceError>

Get the mutable slice at the given address with the given length.

Examples

use rune::vm_try;
use rune::Module;
use rune::runtime::{Output, Stack, VmResult, InstAddress};

fn sum(stack: &mut Stack, addr: InstAddress, args: usize, out: Output) -> VmResult<()> {
    for value in vm_try!(stack.slice_at_mut(addr, args)) {
        let number = vm_try!(value.as_integer::<i64>());
        *value = vm_try!(rune::to_value(number + 1));
    }

    out.store(stack, ());
    VmResult::Ok(())
}

Trait Implementations

impl Debug for Stack

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

Formats the value using the given formatter.

impl Default for Stack

fn default() -> Stack

Returns the “default value” for a type.

impl From<Vec<Value>> for Stack

fn from(stack: Vec<Value>) -> Self

Converts to this type from the input type.

impl Memory for Stack

fn slice_at( &self, addr: InstAddress, len: usize, ) -> Result<&[Value], SliceError>

Get the slice at the given address with the given length.

fn slice_at_mut( &mut self, addr: InstAddress, len: usize, ) -> Result<&mut [Value], SliceError>

Access the given slice mutably.

fn at_mut(&mut self, addr: InstAddress) -> Result<&mut Value, StackError>

Get a value mutable at the given index from the stack bottom.

fn array_at<const N: usize>( &self, addr: InstAddress, ) -> Result<[&Value; N], SliceError>

where Self: Sized,

Get the slice at the given address with the given static length.

impl TryClone for Stack

fn try_clone(&self) -> Result<Self>

Try to clone the current value, raising an allocation error if it’s unsuccessful.

fn try_clone_from(&mut self, source: &Self) -> Result<(), Error>

Performs copy-assignment from source.

impl TryFromIteratorIn<Value, Global> for Stack

fn try_from_iter_in<T: IntoIterator<Item = Value>>( iter: T, alloc: Global, ) -> Result<Self>

Creates a value from an iterator within an allocator.