Struct DataSection 

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

Data entries definitions.

Implementations

impl DataSection

pub fn with_entries(entries: Vec<DataSegment>) -> Self

New data section

pub fn entries(&self) -> &[DataSegment]

List of all data entries in the section

Examples found in repository

examples/data.rs (line 28)

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;
    }
}

examples/info.rs (line 36)

fn main() {
    let args = env::args().collect::<Vec<_>>();
    if args.len() != 2 {
        println!("Usage: {} somefile.wasm", args[0]);
        return;
    }

    let module = sophon_wasm::deserialize_file(&args[1]).expect("Failed to load module");

    println!("Module sections: {}", module.sections().len());

    for section in module.sections() {
        match *section {
            Section::Import(ref import_section) => {
                println!("  Imports: {}", import_section.entries().len());
                import_section.entries().iter().map(|e| println!("    {}.{}", e.module(), e.field())).count();
            },
            Section::Export(ref exports_section) => {
                println!("  Exports: {}", exports_section.entries().len());
                exports_section.entries().iter().map(|e| println!("    {}", e.field())).count();
            },            
            Section::Function(ref function_section) => {
                println!("  Functions: {}", function_section.entries().len());
            },
            Section::Type(ref type_section) => {
                println!("  Types: {}", type_section.types().len());
            },
            Section::Global(ref globals_section) => {
                println!("  Globals: {}", globals_section.entries().len());                
            },
            Section::Data(ref data_section) if data_section.entries().len() > 0 => {
                let data = &data_section.entries()[0];
                println!("  Data size: {}", data.value().len()); 
            },
            _ => {},
        }
    }
}

pub fn entries_mut(&mut self) -> &mut Vec<DataSegment>

List of all data entries in the section (mutable)

Trait Implementations

impl Clone for DataSection

fn clone(&self) -> DataSection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for DataSection

fn default() -> DataSection

Returns the “default value” for a type.

impl Deserialize for DataSection

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 DataSection

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