implement yielding

Author: pufferfish101007

README.md

@@ -28,7 +28,7 @@ If you experience runtime stack overflow errors in debug mode, try using the `-s
 To add a new block named `category_opcode`, if it cannot be reduced to simpler blocks:
 1. create `src/instructions/category/opcode.rs`. Make sure to `use super::super::prelude::*` and create the relevant `pub` items:
 - (optional) `pub struct Fields` (must be `Debug` and `Clone`)
-- `pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>, (fields: &Fields)?) -> HQResult<Vec<Instruction<'static>>>;`
+- `pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>, (fields: &Fields)?) -> HQResult<Vec<InternalInstruction>>;`
 - - wasm is generated using the `wasm_gen::wasm` macro. See [its README](./wasm-gen/README.md) for usage instructions, or e.g. [say.rs](./src/instructions/looks/say.rs) for an example.
 - `pub fn acceptable_inputs() -> Rc<[IrType]>;`
 - - these should really be base types (see BASE_TYPES in [types.rs](./src/ir/types.rs))

build.rs

@@ -38,7 +38,14 @@ fn main() {
                         let fields_name =
                             format!("{}_{}_fields", category, opcode).to_case(Case::Pascal);
                         paths.push((
-                            format!("{}::{}", category, opcode),
+                            format!(
+                                "{}::{}",
+                                category,
+                                match opcode {
+                                    "yield" | "loop" => format!("r#{opcode}"),
+                                    _ => opcode.to_string(),
+                                }
+                            ),
                             format!("{}_{}", category, opcode,),
                             fields,
                             fields_name,
@@ -116,21 +123,28 @@ pub enum IrOpcode {{
 
 impl IrOpcode {{
     /// maps an opcode to its acceptable input types
-     pub fn acceptable_inputs(&self) -> Rc<[crate::ir::Type]> {{
+    pub fn acceptable_inputs(&self) -> Rc<[crate::ir::Type]> {{
         match self {{
             {}
         }}
     }}
 
     /// maps an opcode to its WASM instructions
-     pub fn wasm(&self, step_func: &crate::wasm::StepFunc, inputs: Rc<[crate::ir::Type]>) -> HQResult<Vec<wasm_encoder::Instruction<'static>>> {{
+    pub fn wasm(&self, step_func: &crate::wasm::StepFunc, inputs: Rc<[crate::ir::Type]>) -> HQResult<Vec<crate::wasm::InternalInstruction>> {{
         match self {{
             {}
         }}
     }}
     
     /// maps an opcode to its output type
-     pub fn output_type(&self, inputs: Rc<[crate::ir::Type]>) -> HQResult<Option<crate::ir::Type>> {{
+    pub fn output_type(&self, inputs: Rc<[crate::ir::Type]>) -> HQResult<Option<crate::ir::Type>> {{
+        match self {{
+            {}
+        }}
+    }}
+
+    /// does this opcode request a screen refresh (and by extension yields)?
+    pub const fn yields(&self) -> bool {{
         match self {{
             {}
         }}
@@ -170,6 +184,13 @@ pub use fields::*;
                     format!("IrOpcode::{} => {}::output_type(inputs),", id, path)
                 }
             }).collect::<Vec<_>>().join("\n\t\t\t"),
+            paths.iter().map(|(path, id, fields, _)| {
+                if *fields {
+                    format!("IrOpcode::{}(_) => {}::YIELDS,", id, path)
+                } else {
+                    format!("IrOpcode::{} => {}::YIELDS,", id, path)
+                }
+            }).collect::<Vec<_>>().join("\n\t\t\t"),
             paths.iter().filter(|(_, _, fields, _)| *fields)
             .map(|(path, _, _, fields_name)|
                 format!("pub use {}::Fields as {};", path, fields_name)

playground/views/HomeView.vue

@@ -50,6 +50,11 @@ import ProjectInput from '../components/ProjectInput.vue'
       id: 1050568991,
       name: 'fibonacci benchmark',
       author: 'pufferfish_test',
+    },
+    {
+      id: 1116438829,
+      name: 'HQ test project 2.0',
+      author: 'pufferfish_test'
     }
   ];
 </script>

src/instructions.rs

@@ -18,13 +18,13 @@ include!(concat!(env!("OUT_DIR"), "/ir-opcodes.rs"));
 mod input_switcher;
 pub use input_switcher::wrap_instruction;
 
-pub use hq::_yield::YieldMode;
+pub use hq::r#yield::YieldMode;
 
 mod prelude {
     pub(crate) use crate::ir::Type as IrType;
     pub use crate::prelude::*;
-    pub(crate) use crate::wasm::StepFunc;
-    pub use wasm_encoder::{Instruction, RefType, ValType};
+    pub(crate) use crate::wasm::{InternalInstruction, StepFunc};
+    pub use wasm_encoder::{RefType, ValType};
     pub use wasm_gen::wasm;
 
     /// Canonical NaN + bit 33, + string pointer in bits 1-32

src/instructions/control.rs

@@ -1,2 +1,2 @@
-pub mod _if;
-pub mod repeat;
+pub mod if_else;
+pub mod r#loop;

src/instructions/control/_if.rs

@@ -0,0 +1,49 @@
+use super::super::prelude::*;
+use crate::ir::Step;
+use wasm_encoder::BlockType;
+
+#[derive(Clone, Debug)]
+pub struct Fields {
+    pub branch_if: Rc<Step>,
+    pub branch_else: Rc<Step>,
+}
+
+pub fn wasm(
+    func: &StepFunc,
+    _inputs: Rc<[IrType]>,
+    Fields {
+        branch_if,
+        branch_else,
+    }: &Fields,
+) -> HQResult<Vec<InternalInstruction>> {
+    let if_instructions = func.compile_inner_step(Rc::clone(branch_if))?;
+    let else_instructions = func.compile_inner_step(Rc::clone(branch_else))?;
+    let block_type = func
+        .registries()
+        .types()
+        .register_default((vec![ValType::I32], vec![]))?;
+    Ok(wasm![
+        Block(BlockType::FunctionType(block_type)),
+        Block(BlockType::FunctionType(block_type)),
+        I32Eqz,
+        BrIf(0)
+    ]
+    .into_iter()
+    .chain(if_instructions)
+    .chain(wasm![Br(1), End,])
+    .chain(else_instructions)
+    .chain(wasm![End])
+    .collect())
+}
+
+pub fn acceptable_inputs(_fields: &Fields) -> Rc<[IrType]> {
+    Rc::new([IrType::Boolean])
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>, _fields: &Fields) -> HQResult<Option<IrType>> {
+    Ok(None)
+}
+
+pub const YIELDS: bool = false;
+
+// crate::instructions_test! {none; hq__if; @ super::Fields(None)}

src/instructions/control/if_else.rs

@@ -0,0 +1,48 @@
+// for use in warped contexts only.
+
+use super::super::prelude::*;
+use crate::ir::Step;
+use wasm_encoder::BlockType;
+
+#[derive(Clone, Debug)]
+pub struct Fields {
+    pub first_condition: Option<Rc<Step>>,
+    pub condition: Rc<Step>,
+    pub body: Rc<Step>,
+}
+
+pub fn wasm(
+    func: &StepFunc,
+    _inputs: Rc<[IrType]>,
+    Fields {
+        first_condition,
+        condition,
+        body,
+    }: &Fields,
+) -> HQResult<Vec<InternalInstruction>> {
+    let inner_instructions = func.compile_inner_step(Rc::clone(body))?;
+    let first_condition_instructions = func.compile_inner_step(Rc::clone(
+        &first_condition.clone().unwrap_or(Rc::clone(condition)),
+    ))?;
+    let condition_instructions = func.compile_inner_step(Rc::clone(condition))?;
+    Ok(wasm![Block(BlockType::Empty),]
+        .into_iter()
+        .chain(first_condition_instructions)
+        .chain(wasm![I32Eqz, BrIf(0), Loop(BlockType::Empty)])
+        .chain(inner_instructions)
+        .chain(condition_instructions)
+        .chain(wasm![BrIf(0), End, End])
+        .collect())
+}
+
+pub fn acceptable_inputs(_fields: &Fields) -> Rc<[IrType]> {
+    Rc::new([])
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>, _fields: &Fields) -> HQResult<Option<IrType>> {
+    Ok(None)
+}
+
+pub const YIELDS: bool = false;
+
+// crate::instructions_test! {none; hq_repeat; @ super::Fields(None)}

src/instructions/control/loop.rs

@@ -1,2 +1,3 @@
 pub mod setvariableto;
+pub mod teevariable;
 pub mod variable;