mostly finish putting everything together

README.md

@@ -8,6 +8,7 @@ Compile scratch projects to WASM
 - [Rust](https://rust-lang.org) (v1.65.0 or later)
 - the `wasm32-unknown-unknown` target (`rustup target add wasm32-unknown-unknown`)
 - wasm-bindgen-cli (`cargo install -f wasm-bindgen-cli`)
+- ezno (`cargo install ezno`)
 - wasm-opt (install binaryen using whatever package manager you use)
 
 ## Building

src/instructions.rs

@@ -3,8 +3,8 @@
 
 use crate::prelude::*;
 
+mod hq;
 mod looks;
-mod math;
 mod operator;
 #[macro_use]
 mod utilities;

src/instructions/hq.rs

@@ -0,0 +1,2 @@
+pub mod float;
+pub mod integer;

src/instructions/utilities.rs

@@ -81,7 +81,7 @@ macro_rules! instructions_test {
                     let type_registry = Rc::new(TypeRegistry::new());
                     let external_functions = Rc::new(ExternalFunctionMap::new());
                     let types: &[IrType] = &[$($type_arg,)*];
-                    let step_func = StepFunc::new_with_param_count(types.len(), type_registry.clone(), external_functions.clone()).unwrap();
+                    let step_func = StepFunc::new(type_registry.clone(), external_functions.clone());
                     let wasm_result = wasm(&step_func, Rc::new([$($type_arg,)*]), $(&$fields)?);
                     match (output_type_result.clone(), wasm_result.clone()) {
                         (Err(..), Ok(..)) | (Ok(..), Err(..)) => panic!("output_type result doesn't match wasm result for type(s) {:?}:\noutput_type: {:?},\nwasm: {:?}", ($($type_arg,)*), output_type_result, wasm_result),
@@ -113,8 +113,14 @@ macro_rules! instructions_test {
                     };
                     let type_registry = Rc::new(TypeRegistry::new());
                     let external_functions = Rc::new(ExternalFunctionMap::new());
+                    let wasm_proj = $crate::wasm::WasmProject::new(Default::default(), $crate::wasm::ExternalEnvironment::WebBrowser);
                     let types: &[IrType] = &[$($type_arg,)*];
-                    let step_func = StepFunc::new_with_param_count(types.len(), type_registry.clone(), external_functions.clone())?;
+                    let params = [$($type_arg,)*].into_iter().map(|ty| wasm_proj.ir_type_to_wasm(ty)).collect::<HQResult<Vec<_>>>()?;
+                    let result = match output_type {
+                        Some(output) => Some(wasm_proj.ir_type_to_wasm(output)?),
+                        None => None,
+                      };
+                    let step_func = StepFunc::new_with_types(params.into(), result, Rc::clone(&type_registry), external_functions.clone())?;
                     let wasm = match wasm(&step_func, Rc::new([$($type_arg,)*]), $(&$fields)?) {
                         Ok(a) => a,
                         Err(_) => {
@@ -126,34 +132,22 @@ macro_rules! instructions_test {
                         step_func.add_instructions([Instruction::LocalGet(i.try_into().unwrap())])
                     }
                     step_func.add_instructions(wasm);
-                    let func = step_func.finish();
-
-                    let wasm_proj = $crate::wasm::WasmProject::new(Default::default(), $crate::wasm::ExternalEnvironment::WebBrowser);
 
                     let mut module = Module::new();
 
                     let mut imports = ImportSection::new();
+                    let mut types = TypeSection::new();
+                    let mut functions = FunctionSection::new();
+                    let mut codes = CodeSection::new();
 
-                    Rc::unwrap_or_clone(external_functions).finish(&mut imports, type_registry.clone())?;
 
-                    let mut types = TypeSection::new();
-                    let params = [$($type_arg,)*].into_iter().map(|ty| wasm_proj.ir_type_to_wasm(ty)).collect::<HQResult<Vec<_>>>()?;
-                    let results = match output_type {
-                      Some(output) => vec![wasm_proj.ir_type_to_wasm(output)?],
-                      None => vec![],
-                    };
-                    let step_type_index = type_registry.type_index(params, results)?;
+                    Rc::unwrap_or_clone(external_functions).finish(&mut imports, type_registry.clone())?;
+                    step_func.finish(&mut functions, &mut codes)?;
                     Rc::unwrap_or_clone(type_registry).finish(&mut types);
-                    module.section(&types);
 
+                    module.section(&types);
                     module.section(&imports);
-
-                    let mut functions = FunctionSection::new();
-                    functions.function(step_type_index);
                     module.section(&functions);
-
-                    let mut codes = CodeSection::new();
-                    codes.function(&func);
                     module.section(&codes);
 
                     let wasm_bytes = module.finish();

src/ir.rs

@@ -12,7 +12,7 @@ pub use context::StepContext;
 pub use event::Event;
 pub use proc::{Proc, ProcMap, ProcRegistry, ProcedureContext};
 pub use project::IrProject;
-pub use step::{Step, RcStep};
+pub use step::{RcStep, Step};
 pub use target::Target;
 pub use thread::Thread;
 pub use types::{Type, TypeStack};

src/ir/blocks.rs

@@ -1,6 +1,6 @@
 use crate::instructions::{fields, IrOpcode};
 use crate::prelude::*;
-use crate::sb3::{Block, BlockArray, BlockInfo, BlockMap, BlockOpcode};
+use crate::sb3::{Block, BlockArray, BlockArrayOrId, BlockInfo, BlockMap, BlockOpcode, Input};
 use fields::*;
 
 pub fn from_block(block: &Block, blocks: &BlockMap) -> HQResult<Box<[IrOpcode]>> {
@@ -10,35 +10,71 @@ pub fn from_block(block: &Block, blocks: &BlockMap) -> HQResult<Box<[IrOpcode]>>
     })
 }
 
-fn from_normal_block(block_info: &BlockInfo, _blocks: &BlockMap) -> HQResult<Box<[IrOpcode]>> {
-    Ok(match &block_info.opcode {
-        BlockOpcode::operator_add => [IrOpcode::operator_add].into_iter(),
-        BlockOpcode::looks_say => [IrOpcode::looks_say].into_iter(),
-        other => hq_todo!("unimplemented block: {:?}", other),
+pub fn input_names(opcode: BlockOpcode) -> HQResult<Vec<String>> {
+    Ok(match opcode {
+        BlockOpcode::looks_say => vec!["MESSAGE"],
+        BlockOpcode::operator_add => vec!["NUM1", "NUM2"],
+        other => hq_todo!("unimplemented input_names for {:?}", other),
     }
+    .into_iter()
+    .map(String::from)
     .collect())
 }
 
+pub fn inputs(block_info: &BlockInfo, blocks: &BlockMap) -> HQResult<Vec<IrOpcode>> {
+    Ok(input_names(block_info.opcode.clone())?
+        .into_iter()
+        .map(|name| -> HQResult<Vec<IrOpcode>> {
+            match block_info
+                .inputs
+                .get((*name).into())
+                .ok_or(make_hq_bad_proj!("missing input {}", name))?
+            {
+                Input::NoShadow(_, Some(block)) | Input::Shadow(_, Some(block), _) => match block {
+                    BlockArrayOrId::Array(arr) => Ok(vec![from_special_block(arr)?]),
+                    BlockArrayOrId::Id(id) => match blocks
+                        .get(id)
+                        .ok_or(make_hq_bad_proj!("block for input {} doesn't exist", name))?
+                    {
+                        Block::Normal { block_info, .. } => {
+                            Ok(from_normal_block(block_info, blocks)?.into())
+                        }
+                        Block::Special(block_array) => Ok(vec![from_special_block(block_array)?]),
+                    },
+                },
+                _ => hq_bad_proj!("missing input block for {}", name),
+            }
+        })
+        .collect::<HQResult<Vec<_>>>()?
+        .iter()
+        .flatten()
+        .cloned()
+        .collect())
+}
+
+fn from_normal_block(block_info: &BlockInfo, blocks: &BlockMap) -> HQResult<Box<[IrOpcode]>> {
+    Ok(inputs(block_info, blocks)?
+        .into_iter()
+        .chain(match &block_info.opcode {
+            BlockOpcode::operator_add => [IrOpcode::operator_add].into_iter(),
+            BlockOpcode::looks_say => [IrOpcode::looks_say].into_iter(),
+            other => hq_todo!("unimplemented block: {:?}", other),
+        })
+        .collect())
+}
+
 fn from_special_block(block_array: &BlockArray) -> HQResult<IrOpcode> {
     Ok(match block_array {
         BlockArray::NumberOrAngle(ty, value) => match ty {
-            4 | 8 => IrOpcode::math_number(MathNumberFields(*value)),
-            5 => IrOpcode::math_positive_number(MathPositiveNumberFields(*value)),
-            6 => IrOpcode::math_whole_number(MathWholeNumberFields(*value as i64)),
-            7 => IrOpcode::math_integer(MathIntegerFields(*value as i64)),
+            4 | 5 | 8 => IrOpcode::hq_float(HqFloatFields(*value)),
+            6 | 7 => IrOpcode::hq_integer(HqIntegerFields(*value as i64)),
             _ => hq_bad_proj!("bad project json (block array of type ({}, f64))", ty),
         },
         BlockArray::ColorOrString(ty, value) => match ty {
-            4 | 8 => IrOpcode::math_number(MathNumberFields(
-                value.parse().map_err(|_| make_hq_bug!(""))?,
-            )),
-            5 => IrOpcode::math_positive_number(MathPositiveNumberFields(
-                value.parse().map_err(|_| make_hq_bug!(""))?,
-            )),
-            6 => IrOpcode::math_whole_number(MathWholeNumberFields(
-                value.parse().map_err(|_| make_hq_bug!(""))?,
-            )),
-            7 => IrOpcode::math_integer(MathIntegerFields(
+            4 | 5 | 8 => {
+                IrOpcode::hq_float(HqFloatFields(value.parse().map_err(|_| make_hq_bug!(""))?))
+            }
+            6 | 7 => IrOpcode::hq_integer(HqIntegerFields(
                 value.parse().map_err(|_| make_hq_bug!(""))?,
             )),
             9 => hq_todo!(""),

src/ir/proc.rs

@@ -157,7 +157,12 @@ impl Proc {
                 step_context,
                 project,
             )?,
-            None => RcStep::new(Rc::new(Step::new(None, step_context, Box::new([]), project))),
+            None => RcStep::new(Rc::new(Step::new(
+                None,
+                step_context,
+                Box::new([]),
+                project,
+            ))),
         };
         Ok(Proc {
             first_step,

src/lib.rs

@@ -1,7 +1,6 @@
 #![cfg_attr(not(test), no_std)]
 #![doc(html_logo_url = "https://hyperquark.github.io/hyperquark/logo.png")]
 #![doc(html_favicon_url = "https://hyperquark.github.io/hyperquark/favicon.ico")]
-
 #![allow(clippy::new_without_default)]
 
 #[macro_use]
@@ -23,26 +22,6 @@ pub mod instructions;
 #[doc(inline)]
 pub use error::{HQError, HQErrorType, HQResult};
 
-// use wasm::wasm;
-
-#[cfg(target_family = "wasm")]
-#[cfg_attr(target_family = "wasm", wasm_bindgen(js_namespace=console))]
-extern "C" {
-    pub fn log(s: &str);
-}
-
-#[cfg(test)]
-pub fn log(s: &str) {
-    println!("{s}")
-}
-
-// #[wasm_bindgen]
-// pub fn sb3_to_wasm(proj: &str) -> Result<wasm::WasmProject, HQError> {
-//     let mut ir_proj = ir::IrProject::try_from(sb3::Sb3Project::try_from(proj)?)?;
-//     ir_proj.optimise()?;
-//     ir_proj.try_into()
-// }
-
 /// commonly used _things_ which would be nice not to have to type out every time
 pub mod prelude {
     pub use crate::{HQError, HQResult};
@@ -61,3 +40,25 @@ pub mod prelude {
     pub type IndexMap<K, V> = indexmap::IndexMap<K, V, BuildHasherDefault<FNV1aHasher64>>;
     pub type IndexSet<T> = indexmap::IndexSet<T, BuildHasherDefault<FNV1aHasher64>>;
 }
+
+use prelude::*;
+
+// use wasm::wasm;
+
+#[cfg(target_family = "wasm")]
+#[cfg_attr(target_family = "wasm", wasm_bindgen(js_namespace=console))]
+extern "C" {
+    pub fn log(s: &str);
+}
+
+#[cfg(test)]
+pub fn log(s: &str) {
+    println!("{s}")
+}
+
+#[cfg_attr(target_family = "wasm", wasm_bindgen)]
+pub fn sb3_to_wasm(proj: &str) -> HQResult<Vec<u8>> {
+    let sb3_proj = sb3::Sb3Project::try_from(proj)?;
+    let ir_proj: Rc<ir::IrProject> = sb3_proj.try_into()?;
+    wasm::WasmProject::try_from(ir_proj)?.finish()
+}