Revision control
Copy as Markdown
Other Tools
use crate::{BinaryReader, ComponentExternalKind, ExternalKind, FromReader, Result};
/// Represents the kind of an outer alias in a WebAssembly component.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ComponentOuterAliasKind {
/// The alias is to a core module.
CoreModule,
/// The alias is to a core type.
CoreType,
/// The alias is to a component type.
Type,
/// The alias is to a component.
Component,
}
/// Represents an alias in a WebAssembly component.
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum ComponentAlias<'a> {
/// The alias is to an export of a component instance.
InstanceExport {
/// The alias kind.
kind: ComponentExternalKind,
/// The instance index.
instance_index: u32,
/// The export name.
name: &'a str,
},
/// The alias is to an export of a module instance.
CoreInstanceExport {
/// The alias kind.
kind: ExternalKind,
/// The instance index.
instance_index: u32,
/// The export name.
name: &'a str,
},
/// The alias is to an outer item.
Outer {
/// The alias kind.
kind: ComponentOuterAliasKind,
/// The outward count, starting at zero for the current component.
count: u32,
/// The index of the item within the outer component.
index: u32,
},
}
/// Section reader for the component alias section
pub type ComponentAliasSectionReader<'a> = crate::SectionLimited<'a, ComponentAlias<'a>>;
impl<'a> FromReader<'a> for ComponentAlias<'a> {
fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
// We don't know what type of alias it is yet, so just read the sort bytes
let offset = reader.original_position();
let byte1 = reader.read_u8()?;
let byte2 = if byte1 == 0x00 {
Some(reader.read_u8()?)
} else {
None
};
Ok(match reader.read_u8()? {
0x00 => ComponentAlias::InstanceExport {
kind: ComponentExternalKind::from_bytes(byte1, byte2, offset)?,
instance_index: reader.read_var_u32()?,
name: reader.read_string()?,
},
0x01 => ComponentAlias::CoreInstanceExport {
kind: BinaryReader::external_kind_from_byte(
byte2.ok_or_else(|| {
BinaryReader::invalid_leading_byte_error(
byte1,
"core instance export kind",
offset,
)
})?,
offset,
)?,
instance_index: reader.read_var_u32()?,
name: reader.read_string()?,
},
0x02 => ComponentAlias::Outer {
kind: component_outer_alias_kind_from_bytes(byte1, byte2, offset)?,
count: reader.read_var_u32()?,
index: reader.read_var_u32()?,
},
x => reader.invalid_leading_byte(x, "alias")?,
})
}
}
fn component_outer_alias_kind_from_bytes(
byte1: u8,
byte2: Option<u8>,
offset: usize,
) -> Result<ComponentOuterAliasKind> {
Ok(match byte1 {
0x00 => match byte2.unwrap() {
0x10 => ComponentOuterAliasKind::CoreType,
0x11 => ComponentOuterAliasKind::CoreModule,
x => {
return Err(BinaryReader::invalid_leading_byte_error(
x,
"component outer alias kind",
offset + 1,
))
}
},
0x03 => ComponentOuterAliasKind::Type,
0x04 => ComponentOuterAliasKind::Component,
x => {
return Err(BinaryReader::invalid_leading_byte_error(
x,
"component outer alias kind",
offset,
))
}
})
}