Struct Expression 

pub struct Expression { /* private fields */ }

Function bodies, initialization values for globals, and offsets of element or data segments are given as expressions, which are sequences of instructions terminated by an 𝖾𝗇𝖽 marker. In some places, validation restricts expressions to be constant, which limits the set of allowable instructions.

See https://webassembly.github.io/spec/core/syntax/instructions.html#expressions

Examples

Non-Empty

use wasm_ast::{Expression, ControlInstruction, NumericInstruction, Instruction};

let expression = Expression::new(vec![0i32.into(), ControlInstruction::Nop.into()]);

assert_eq!(
    expression,
    Expression::new(vec![
        Instruction::Numeric(NumericInstruction::I32Constant(0 as i32)),
        Instruction::Control(ControlInstruction::Nop),
    ])
);
assert_eq!(expression.instructions(), &[
    Instruction::Numeric(NumericInstruction::I32Constant(0)),
    Instruction::Control(ControlInstruction::Nop),
]);
assert_eq!(expression.len(), 2);
assert!(!expression.is_empty());
assert_eq!(
    expression,
    vec![
        Instruction::Numeric(NumericInstruction::I32Constant(0)),
        Instruction::Control(ControlInstruction::Nop),
    ].into()
);

Empty

use wasm_ast::Expression;

let expression = Expression::new(vec![]);

assert_eq!(expression, Expression::empty());
assert_eq!(expression, vec![].into());
assert_eq!(expression.instructions(), &[]);
assert_eq!(expression.len(), 0);
assert!(expression.is_empty());

Implementations

impl Expression

pub fn new(instructions: Vec<Instruction>) -> Self

Create a new expression from the given instructions.

pub fn empty() -> Self

Create a new empty expression.

pub fn instructions(&self) -> &[Instruction]

The instructions for this expression.

pub fn is_empty(&self) -> bool

Returns true if this Expression has a length of zero, false otherwise.

pub fn len(&self) -> usize

Returns the length of this Expression, in number of instructions.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl From<Vec<Instruction>> for Expression

fn from(instructions: Vec<Instruction>) -> Self

Converts to this type from the input type.

impl PartialEq for Expression

fn eq(&self, other: &Expression) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Expression