Struct Component

pub struct Component<'a> {

    pub modules: Vec<Module<'a>>,
    pub alias: Vec<ComponentAlias<'a>>,
    pub core_types: Vec<CoreType<'a>>,
    pub component_types: Vec<ComponentType<'a>>,
    pub imports: Vec<ComponentImport<'a>>,
    pub exports: Vec<ComponentExport<'a>>,
    pub instances: Vec<Instance<'a>>,
    pub component_instance: Vec<ComponentInstance<'a>>,
    pub canons: Vec<CanonicalFunction>,
    pub custom_sections: CustomSections<'a>,
    pub components: Vec<Component<'a>>,
    pub num_modules: usize,
    pub start_section: Vec<ComponentStartFunction>,
    pub sections: Vec<(u32, ComponentSection)>,
    /* private fields */
}

Intermediate Representation of a wasm component.

Fields

modules: Vec<Module<'a>>

Modules

alias: Vec<ComponentAlias<'a>>

Alias

core_types: Vec<CoreType<'a>>

Core Types

component_types: Vec<ComponentType<'a>>

Component Types

imports: Vec<ComponentImport<'a>>

Imports

exports: Vec<ComponentExport<'a>>

Exports

instances: Vec<Instance<'a>>

Core Instances

component_instance: Vec<ComponentInstance<'a>>

Component Instances

canons: Vec<CanonicalFunction>

Canons

custom_sections: CustomSections<'a>

Custom sections

components: Vec<Component<'a>>

Nested Components

num_modules: usize

Number of modules

start_section: Vec<ComponentStartFunction>

Component Start Section

sections: Vec<(u32, ComponentSection)>

Sections of the Component. Represented as (#num of occurrences of a section, type of section)

Implementations

impl<'a> Component<'a>

pub fn new() -> Self

Creates a new Empty Component

pub fn add_module(&mut self, module: Module<'a>)

Add a Module to this Component.

pub fn add_globals(&mut self, global: Global, module_idx: usize) -> GlobalID

Add a Global to this Component.

pub fn parse(wasm: &'a [u8], enable_multi_memory: bool) -> Result<Self, Error>

Parse a Component from a wasm binary.

Example

use orca_wasm::Component;

let file = "path_to_file";
let buff = wat::parse_file(file).expect("couldn't convert the input wat to Wasm");
let comp = Component::parse(&buff, false).unwrap();

pub fn encode(&mut self) -> Vec<u8>

Encode a Component to bytes..

Example

use orca_wasm::Component;

let file = "path_to_file";
let buff = wat::parse_file(file).expect("couldn't convert the input wat to Wasm");
let mut comp = Component::parse(&buff, false).unwrap();
let result = comp.encode();

pub fn print(&self)

Print a rudimentary textual representation of a Component

pub fn emit_wasm(&mut self, file_name: &str) -> Result<(), Error>

Emit the Component into a wasm binary file.

pub fn get_fid_by_name( &self, name: &str, module_idx: ModuleID, ) -> Option<FunctionID>

Get Local Function ID by name

Trait Implementations

impl<'a> Debug for Component<'a>

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

Formats the value using the given formatter.

impl Default for Component<'_>

fn default() -> Self

Returns the “default value” for a type.