add basic component implementation

Author: friendlymatthew

gabagool/src/binary_grammar.rs

@@ -1,5 +1,88 @@
-use crate::{parse_err, Error, Result};
-use std::result::Result as StdResult;
+use crate::{
+    compiler::{self, ModuleCode},
+    parse_err,
+    parser::Parser,
+    Error, Result,
+};
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct Component {
+    pub(crate) parsed: ParsedComponent,
+}
+
+impl Component {
+    pub fn new(bytes: &[u8]) -> Result<Self> {
+        let parsed = Parser::new(bytes).parse()?.try_as_component()?;
+
+        Ok(Self { parsed })
+    }
+}
+
+/// A parsed and compiled WASM module ready to be instantiated
+#[derive(Debug)]
+pub struct Module {
+    pub(crate) code: Arc<ModuleCode>,
+
+    pub(crate) functions: Vec<Function>,
+    pub(crate) tables: Vec<TableDef>,
+    pub(crate) mems: Vec<MemoryType>,
+    pub(crate) element_segments: Vec<ElementSegment>,
+    pub(crate) globals: Vec<Global>,
+    pub(crate) data_segments: Vec<DataSegment>,
+    pub(crate) start: Option<u32>,
+    pub(crate) import_declarations: Vec<ImportDeclaration>,
+    pub(crate) exports: Vec<Export>,
+    pub(crate) tags: Vec<Tag>,
+}
+
+impl Module {
+    pub fn new(bytes: &[u8]) -> Result<Self> {
+        let module = Parser::new(bytes).parse()?.try_as_module()?;
+
+        let code = compiler::compile(&module);
+
+        Ok(Self {
+            code: Arc::new(code),
+
+            functions: module.functions,
+            tables: module.tables,
+            mems: module.mems,
+            element_segments: module.element_segments,
+            globals: module.globals,
+            data_segments: module.data_segments,
+            start: module.start,
+            import_declarations: module.import_declarations,
+            exports: module.exports,
+            tags: module.tags,
+        })
+    }
+
+    pub fn from_parsed(parsed: ParsedModule) -> Result<Self> {
+        let code = compiler::compile(&parsed);
+        Ok(Self {
+            code: Arc::new(code),
+            functions: parsed.functions,
+            tables: parsed.tables,
+            mems: parsed.mems,
+            element_segments: parsed.element_segments,
+            globals: parsed.globals,
+            data_segments: parsed.data_segments,
+            start: parsed.start,
+            import_declarations: parsed.import_declarations,
+            exports: parsed.exports,
+            tags: parsed.tags,
+        })
+    }
+
+    pub fn import_declarations(&self) -> &[ImportDeclaration] {
+        &self.import_declarations
+    }
+
+    pub fn types(&self) -> &[SubType] {
+        &self.code.types
+    }
+}
 
 // todo: should we box ParsedModule?
 #[allow(clippy::large_enum_variant)]
@@ -9,19 +92,38 @@ pub enum Parsed {
     Component(ParsedComponent),
 }
 
+impl Parsed {
+    pub fn try_as_module(self) -> Result<ParsedModule> {
+        let out = match self {
+            Self::Module(m) => m,
+            Self::Component(_) => parse_err!("expected module"),
+        };
+
+        Ok(out)
+    }
+
+    pub fn try_as_component(self) -> Result<ParsedComponent> {
+        let out = match self {
+            Self::Module(_) => parse_err!("expected component"),
+            Self::Component(c) => c,
+        };
+
+        Ok(out)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ParsedComponent {
     pub sections: Vec<ComponentSection>,
 }
 
-#[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum ComponentSection {
-    CoreModule(ParsedModule),
+    CoreModule(Box<ParsedModule>),
     CoreInstance(Vec<CoreInstance>),
     CoreType(Vec<CoreType>),
     Component(ParsedComponent),
-    Instance(Vec<ComponentInstance>),
+    Instance(Vec<ParsedComponentInstance>),
     Alias(Vec<Alias>),
     ComponentType(Vec<ComponentTypeDef>),
     Canonical(Vec<CanonicalDef>),
@@ -283,7 +385,7 @@ pub enum Alias {
 }
 
 #[derive(Debug, Clone)]
-pub enum ComponentInstance {
+pub enum ParsedComponentInstance {
     Instantiate {
         component_idx: u32,
         args: Vec<ComponentInstantiateArg>,
@@ -445,115 +547,6 @@ pub struct ComponentExportDecl {
     pub desc: ExternDesc,
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum ComponentValue {
-    Bool(bool),
-    S8(i8),
-    U8(u8),
-    S16(i16),
-    U16(u16),
-    S32(i32),
-    U32(u32),
-    S64(i64),
-    U64(u64),
-    F32(f32),
-    F64(f64),
-    Char(char),
-    String(String),
-    List(Vec<Self>),
-    Record(Vec<(String, Self)>),
-    Tuple(Vec<Self>),
-    Variant(String, Option<Box<Self>>),
-    Enum(String),
-    Option(Option<Box<Self>>),
-    Result(StdResult<Option<Box<Self>>, Option<Box<Self>>>),
-    Flags(Vec<String>),
-}
-
-impl From<bool> for ComponentValue {
-    fn from(v: bool) -> Self {
-        Self::Bool(v)
-    }
-}
-
-impl From<i8> for ComponentValue {
-    fn from(v: i8) -> Self {
-        Self::S8(v)
-    }
-}
-
-impl From<u8> for ComponentValue {
-    fn from(v: u8) -> Self {
-        Self::U8(v)
-    }
-}
-
-impl From<i16> for ComponentValue {
-    fn from(v: i16) -> Self {
-        Self::S16(v)
-    }
-}
-
-impl From<u16> for ComponentValue {
-    fn from(v: u16) -> Self {
-        Self::U16(v)
-    }
-}
-
-impl From<i32> for ComponentValue {
-    fn from(v: i32) -> Self {
-        Self::S32(v)
-    }
-}
-
-impl From<u32> for ComponentValue {
-    fn from(v: u32) -> Self {
-        Self::U32(v)
-    }
-}
-
-impl From<i64> for ComponentValue {
-    fn from(v: i64) -> Self {
-        Self::S64(v)
-    }
-}
-
-impl From<u64> for ComponentValue {
-    fn from(v: u64) -> Self {
-        Self::U64(v)
-    }
-}
-
-impl From<f32> for ComponentValue {
-    fn from(v: f32) -> Self {
-        Self::F32(v)
-    }
-}
-
-impl From<f64> for ComponentValue {
-    fn from(v: f64) -> Self {
-        Self::F64(v)
-    }
-}
-
-impl From<char> for ComponentValue {
-    fn from(v: char) -> Self {
-        Self::Char(v)
-    }
-}
-
-impl From<String> for ComponentValue {
-    fn from(v: String) -> Self {
-        Self::String(v)
-    }
-}
-
-impl From<&str> for ComponentValue {
-    fn from(v: &str) -> Self {
-        Self::String(v.to_string())
-    }
-}
-
 #[derive(Debug, Default, Clone)]
 pub struct ParsedModule {
     pub types: Vec<SubType>,

gabagool/src/execution_grammar.rs

@@ -1,7 +1,7 @@
-use std::fmt::Debug;
-use std::rc::Rc;
-
 use crate::binary_grammar::{Function, FunctionType, GlobalType, MemoryType, RefType, TableType};
+use std::rc::Rc;
+use std::result::Result as StdResult;
+use std::{collections::HashMap, fmt::Debug};
 
 #[repr(u8)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -95,6 +95,115 @@ impl From<f64> for RawValue {
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum ComponentValue {
+    Bool(bool),
+    S8(i8),
+    U8(u8),
+    S16(i16),
+    U16(u16),
+    S32(i32),
+    U32(u32),
+    S64(i64),
+    U64(u64),
+    F32(f32),
+    F64(f64),
+    Char(char),
+    String(String),
+    List(Vec<Self>),
+    Record(Vec<(String, Self)>),
+    Tuple(Vec<Self>),
+    Variant(String, Option<Box<Self>>),
+    Enum(String),
+    Option(Option<Box<Self>>),
+    Result(StdResult<Option<Box<Self>>, Option<Box<Self>>>),
+    Flags(Vec<String>),
+}
+
+impl From<bool> for ComponentValue {
+    fn from(v: bool) -> Self {
+        Self::Bool(v)
+    }
+}
+
+impl From<i8> for ComponentValue {
+    fn from(v: i8) -> Self {
+        Self::S8(v)
+    }
+}
+
+impl From<u8> for ComponentValue {
+    fn from(v: u8) -> Self {
+        Self::U8(v)
+    }
+}
+
+impl From<i16> for ComponentValue {
+    fn from(v: i16) -> Self {
+        Self::S16(v)
+    }
+}
+
+impl From<u16> for ComponentValue {
+    fn from(v: u16) -> Self {
+        Self::U16(v)
+    }
+}
+
+impl From<i32> for ComponentValue {
+    fn from(v: i32) -> Self {
+        Self::S32(v)
+    }
+}
+
+impl From<u32> for ComponentValue {
+    fn from(v: u32) -> Self {
+        Self::U32(v)
+    }
+}
+
+impl From<i64> for ComponentValue {
+    fn from(v: i64) -> Self {
+        Self::S64(v)
+    }
+}
+
+impl From<u64> for ComponentValue {
+    fn from(v: u64) -> Self {
+        Self::U64(v)
+    }
+}
+
+impl From<f32> for ComponentValue {
+    fn from(v: f32) -> Self {
+        Self::F32(v)
+    }
+}
+
+impl From<f64> for ComponentValue {
+    fn from(v: f64) -> Self {
+        Self::F64(v)
+    }
+}
+
+impl From<char> for ComponentValue {
+    fn from(v: char) -> Self {
+        Self::Char(v)
+    }
+}
+
+impl From<String> for ComponentValue {
+    fn from(v: String) -> Self {
+        Self::String(v)
+    }
+}
+
+impl From<&str> for ComponentValue {
+    fn from(v: &str) -> Self {
+        Self::String(v.to_string())
+    }
+}
+
 /// A temporary struct that accumulates address mappings during instantiation
 #[derive(Debug, Clone, Default)]
 pub struct AddressMap {
@@ -170,3 +279,10 @@ pub struct ExportInstance {
     pub name: String,
     pub value: ExternalValue,
 }
+
+#[derive(Debug)]
+pub struct InstantiatedComponent {
+    // maps from name to func addr
+    pub exports: HashMap<String, usize>,
+    pub may_leave: bool,
+}