Struct ExportEntry 

pub struct ExportEntry { /* private fields */ }

Export entry.

Implementations

impl ExportEntry

pub fn new(field: String, internal: Internal) -> Self

New export entry

pub fn field(&self) -> &str

Public name

Examples found in repository

examples/info.rs (line 25)

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()); 
            },
            _ => {},
        }
    }
}

examples/exports.rs (line 72)

fn main() {

    // Example executable takes one argument which must
    // refernce the existing file with a valid wasm module
    let args: Vec<_> = args().collect();
    if args.len() < 2 {
        println!("Prints export function names with and their types");
        println!("Usage: {} <wasm file>", 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("File to be deserialized");

    // Query the export section from the loaded module. Note that not every
    // wasm module obliged to contain export section. So in case there is no
    // any export section, we panic with the corresponding error.
    let export_section = module.export_section().expect("No export section found");

    // Process all exports, leaving only those which reference the internal function
    // of the wasm module
    let exports: Vec<String> = export_section.entries().iter()
        .filter_map(|entry|
            // This is match on export variant, which can be function, global,table or memory
            // We are interested only in functions for an example
            match *entry.internal() {
                // Return function export name (return by field() function and it's index)
                Internal::Function(index) => Some((entry.field(), index as usize)),
                _ => None
            })
        // Another map to resolve function signature index given it's internal index and return
        // the printable string of the export
        .map(|(field, index)| format!("{:}: {:?}", field, type_by_index(&module, index).params())).collect();

    // Print the result
    for export in exports {
        println!("{:}", export);
    }
}

examples/invoke.rs (line 35)

fn main() {
    let args: Vec<_> = args().collect();
    if args.len() < 3 {
        println!("Usage: {} <wasm file> <exported func> [<arg>...]", args[0]);
        return;
    }
    let func_name = &args[2];
    let (_, program_args) = args.split_at(3);

    // Intrepreter initialization.
    let program = sophon_wasm::ProgramInstance::new();

    let module = sophon_wasm::deserialize_file(&args[1]).expect("File to be deserialized");

    // Extracts call arguments from command-line arguments
    let execution_params = {
        // Export section has an entry with a func_name with an index inside a module
        let export_section = module.export_section().expect("No export section found");
        // It's a section with function declarations (which are references to the type section entries)
        let function_section = module.function_section().expect("No function section found");
        // Type section stores function types which are referenced by function_section entries
        let type_section = module.type_section().expect("No type section found");

        // Given function name used to find export section entry which contains
        // an `internal` field which points to the index in the function index space
        let found_entry = export_section.entries().iter()
            .find(|entry| func_name == entry.field()).expect(&format!("No export with name {} found", func_name));

        // Function index in the function index space (internally-defined + imported)
        let function_index: usize = match found_entry.internal() {
            &Internal::Function(index) => index as usize,
            _ => panic!("Founded export is not a function"),
        };

        // We need to count import section entries (functions only!) to subtract it from function_index
        // and obtain the index within the function section
        let import_section_len: usize = match module.import_section() {
            Some(import) =>
                import.entries().iter().filter(|entry| match entry.external() {
                    &External::Function(_) => true,
                    _ => false,
                    }).count(),
            None => 0,
        };

        // Calculates a function index within module's function section
        let function_index_in_section = function_index - import_section_len;

        // Getting a type reference from a function section entry
        let func_type_ref: usize = function_section.entries()[function_index_in_section].type_ref() as usize;

        // Use the reference to get an actual function type
        let function_type: &FunctionType = match &type_section.types()[func_type_ref] {
            &Type::Function(ref func_type) => func_type,
        };

        // Parses arguments and constructs runtime values in correspondence of their types
        let args: Vec<RuntimeValue> = function_type.params().iter().enumerate().map(|(i, value)| match value {
            &ValueType::I32 => RuntimeValue::I32(program_args[i].parse::<i32>().expect(&format!("Can't parse arg #{} as i32", program_args[i]))),
            &ValueType::I64 => RuntimeValue::I64(program_args[i].parse::<i64>().expect(&format!("Can't parse arg #{} as i64", program_args[i]))),
            &ValueType::F32 => RuntimeValue::F32(program_args[i].parse::<f32>().expect(&format!("Can't parse arg #{} as f32", program_args[i]))),
            &ValueType::F64 => RuntimeValue::F64(program_args[i].parse::<f64>().expect(&format!("Can't parse arg #{} as f64", program_args[i]))),
        }).collect();

        interpreter::ExecutionParams::from(args)
    };

    // Intialize deserialized module. It adds module into It expects 3 parameters:
    // - a name for the module
    // - a module declaration
    // - "main" module doesn't import native module(s) this is why we don't need to provide external native modules here
    // This test shows how to implement native module https://github.com/NikVolf/sophon-wasm/blob/master/src/interpreter/tests/basics.rs#L197
    let module = program.add_module("main", module, None).expect("Failed to initialize module");

    println!("Result: {:?}", module.execute_export(func_name, execution_params).expect(""));
}

pub fn field_mut(&mut self) -> &mut String

Public name (mutable)

pub fn internal(&self) -> &Internal

Internal reference of the export entry.

Examples found in repository

examples/exports.rs (line 70)

fn main() {

    // Example executable takes one argument which must
    // refernce the existing file with a valid wasm module
    let args: Vec<_> = args().collect();
    if args.len() < 2 {
        println!("Prints export function names with and their types");
        println!("Usage: {} <wasm file>", 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("File to be deserialized");

    // Query the export section from the loaded module. Note that not every
    // wasm module obliged to contain export section. So in case there is no
    // any export section, we panic with the corresponding error.
    let export_section = module.export_section().expect("No export section found");

    // Process all exports, leaving only those which reference the internal function
    // of the wasm module
    let exports: Vec<String> = export_section.entries().iter()
        .filter_map(|entry|
            // This is match on export variant, which can be function, global,table or memory
            // We are interested only in functions for an example
            match *entry.internal() {
                // Return function export name (return by field() function and it's index)
                Internal::Function(index) => Some((entry.field(), index as usize)),
                _ => None
            })
        // Another map to resolve function signature index given it's internal index and return
        // the printable string of the export
        .map(|(field, index)| format!("{:}: {:?}", field, type_by_index(&module, index).params())).collect();

    // Print the result
    for export in exports {
        println!("{:}", export);
    }
}

examples/invoke.rs (line 38)

fn main() {
    let args: Vec<_> = args().collect();
    if args.len() < 3 {
        println!("Usage: {} <wasm file> <exported func> [<arg>...]", args[0]);
        return;
    }
    let func_name = &args[2];
    let (_, program_args) = args.split_at(3);

    // Intrepreter initialization.
    let program = sophon_wasm::ProgramInstance::new();

    let module = sophon_wasm::deserialize_file(&args[1]).expect("File to be deserialized");

    // Extracts call arguments from command-line arguments
    let execution_params = {
        // Export section has an entry with a func_name with an index inside a module
        let export_section = module.export_section().expect("No export section found");
        // It's a section with function declarations (which are references to the type section entries)
        let function_section = module.function_section().expect("No function section found");
        // Type section stores function types which are referenced by function_section entries
        let type_section = module.type_section().expect("No type section found");

        // Given function name used to find export section entry which contains
        // an `internal` field which points to the index in the function index space
        let found_entry = export_section.entries().iter()
            .find(|entry| func_name == entry.field()).expect(&format!("No export with name {} found", func_name));

        // Function index in the function index space (internally-defined + imported)
        let function_index: usize = match found_entry.internal() {
            &Internal::Function(index) => index as usize,
            _ => panic!("Founded export is not a function"),
        };

        // We need to count import section entries (functions only!) to subtract it from function_index
        // and obtain the index within the function section
        let import_section_len: usize = match module.import_section() {
            Some(import) =>
                import.entries().iter().filter(|entry| match entry.external() {
                    &External::Function(_) => true,
                    _ => false,
                    }).count(),
            None => 0,
        };

        // Calculates a function index within module's function section
        let function_index_in_section = function_index - import_section_len;

        // Getting a type reference from a function section entry
        let func_type_ref: usize = function_section.entries()[function_index_in_section].type_ref() as usize;

        // Use the reference to get an actual function type
        let function_type: &FunctionType = match &type_section.types()[func_type_ref] {
            &Type::Function(ref func_type) => func_type,
        };

        // Parses arguments and constructs runtime values in correspondence of their types
        let args: Vec<RuntimeValue> = function_type.params().iter().enumerate().map(|(i, value)| match value {
            &ValueType::I32 => RuntimeValue::I32(program_args[i].parse::<i32>().expect(&format!("Can't parse arg #{} as i32", program_args[i]))),
            &ValueType::I64 => RuntimeValue::I64(program_args[i].parse::<i64>().expect(&format!("Can't parse arg #{} as i64", program_args[i]))),
            &ValueType::F32 => RuntimeValue::F32(program_args[i].parse::<f32>().expect(&format!("Can't parse arg #{} as f32", program_args[i]))),
            &ValueType::F64 => RuntimeValue::F64(program_args[i].parse::<f64>().expect(&format!("Can't parse arg #{} as f64", program_args[i]))),
        }).collect();

        interpreter::ExecutionParams::from(args)
    };

    // Intialize deserialized module. It adds module into It expects 3 parameters:
    // - a name for the module
    // - a module declaration
    // - "main" module doesn't import native module(s) this is why we don't need to provide external native modules here
    // This test shows how to implement native module https://github.com/NikVolf/sophon-wasm/blob/master/src/interpreter/tests/basics.rs#L197
    let module = program.add_module("main", module, None).expect("Failed to initialize module");

    println!("Result: {:?}", module.execute_export(func_name, execution_params).expect(""));
}

pub fn internal_mut(&mut self) -> &mut Internal

Internal reference of the export entry (mutable).

Trait Implementations

impl Clone for ExportEntry

fn clone(&self) -> ExportEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExportEntry

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

Formats the value using the given formatter.

impl Deserialize for ExportEntry

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 ExportEntry

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