Struct InitExpr 

pub struct InitExpr(/* private fields */);

Initialization expression.

Implementations

impl InitExpr

pub fn new(code: Vec<Opcode>) -> Self

New initialization expression from list of opcodes. code must end with the Opcode::End opcode!

pub fn empty() -> Self

Empty expression with only Opcode::End opcode

pub fn code(&self) -> &[Opcode]

List of opcodes used in the expression.

Examples found in repository

examples/data.rs (line 39)

fn main() {

    // Example executable takes one argument which must
    // refernce the existing file with a valid wasm module
    let args = env::args().collect::<Vec<_>>();
    if args.len() != 2 {
        println!("Usage: {} somefile.wasm", args[0]);
        return;
    }

    // Here we load module using dedicated for this purpose
    // `deserialize_file` function (which works only with modules)
    let module = sophon_wasm::deserialize_file(&args[1]).expect("Failed to load module");

    // We query module for data section. Note that not every valid
    // wasm module must contain a data section. So in case the provided
    // module does not contain data section, we panic with an error
    let data_section = module.data_section().expect("no data section in module");

    // Printing the total count of data segments
    println!("Data segments: {}", data_section.entries().len());

    let mut index = 0;
    for entry in data_section.entries() {
        // Printing the details info of each data segment
        // see `elements::DataSegment` for more properties
        // you can query
        println!("  Entry #{}", index);

        // This shows the initialization member of data segment
        // (expression which must resolve in the linear memory location).
        println!("    init: {}", entry.offset().code()[0]);

        // This shows the total length of the data segment in bytes.
        println!("    size: {}", entry.value().len());

        index += 1;
    }
}

pub fn code_mut(&mut self) -> &mut Vec<Opcode>

List of opcodes used in the expression.

Trait Implementations

impl Clone for InitExpr

fn clone(&self) -> InitExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InitExpr

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

Formats the value using the given formatter.

impl Deserialize for InitExpr

type Error = Error

Serialization error produced by deserialization routine.

fn deserialize<R: Read>(reader: &mut R) -> Result<Self, Self::Error>

Deserialize type from serial i/o

impl Serialize for InitExpr

type Error = Error

Serialization error produced by serialization routine.

fn serialize<W: Write>(self, writer: &mut W) -> Result<(), Self::Error>

Serialize type to serial i/o