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: Address) -> &Value

Access the value at the given frame offset.

Examples

use rune::vm_try;
use rune::Module;
use rune::runtime::{Output, Stack, VmError, Address};

fn add_one(memory: &mut Stack, addr: Address, args: usize, out: Output) -> Result<(), VmError> {
    let value = memory.at(addr).as_integer::<i64>()?;
    memory.store(out, value + 1);
    Ok(())
}

pub fn at_mut(&mut self, addr: Address) -> 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, VmError, Address};

fn add_one(memory: &mut Stack, addr: Address, args: usize, out: Output) -> Result<(), VmError> {
    let mut value = memory.at_mut(addr)?;
    let number = value.as_integer::<i64>()?;
    *value = rune::to_value(number + 1)?;
    memory.store(out, ())?;
    Ok(())
}

pub fn slice_at( &self, addr: Address, 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, VmError, Address};

fn sum(memory: &mut Stack, addr: Address, args: usize, out: Output) -> Result<(), VmError> {
    let mut number = 0;

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

    memory.store(out, number)?;
    Ok(())
}

pub fn slice_at_mut( &mut self, addr: Address, 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, Memory, VmError, Address};

fn sum(memory: &mut dyn Memory, addr: Address, args: usize, out: Output) -> Result<(), VmError> {
    for value in memory.slice_at_mut(addr, args)? {
        let number = value.as_integer::<i64>()?;
        *value = rune::to_value(number + 1)?;
    }

    memory.store(out, ())?;
    Ok(())
}

pub fn store<O>( &mut self, out: Output, o: O, ) -> Result<(), StoreError<O::Error>>

where O: IntoOutput,

Write output using the provided IntoOutput implementation onto the stack.

The IntoOutput trait primarily allows for deferring a computation since it’s implemented by FnOnce. However, you must take care that any side effects calling a function may have are executed outside of the call to store. Like if the function would error.

Examples

use rune::runtime::{Output, Memory, ToValue, VmError, Address};
use rune::vm_try;

fn sum(memory: &mut dyn Memory, addr: Address, args: usize, out: Output) -> Result<(), VmError> {
    let mut number = 0;

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

    memory.store(out, number)?;
    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 Dismantle for Stack

A stack holds the values a machine is working over, so a machine which is suspended - a generator or a stream - holds a graph of values through it.

fn dismantle(&mut self, out: &mut Handover<'_>)

Hand over every value this is made of, leaving nothing behind which is itself made of values.

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: Address, len: usize) -> Result<&[Value], SliceError>

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

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

Access the given slice mutably.

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

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

fn array_at<const N: usize>( &self, addr: Address, ) -> 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.