Implement format

Author: object-Object

src/logic/ast.rs

@@ -29,6 +29,9 @@ pub enum Instruction {
     PrintChar {
         value: Value,
     },
+    Format {
+        value: Value,
+    },
     // operations
     Set {
         to: Value,

src/logic/grammar.lalrpop

@@ -17,6 +17,7 @@ match {
     "draw",
     "print",
     "printchar",
+    "format",
     "set",
     "noop",
     "wait",
@@ -118,10 +119,13 @@ Instruction: Instruction = {
 
     "print" <value:Value> =>
         Instruction::Print { <> },
-    
+
     "printchar" <value:Value> =>
         Instruction::PrintChar { <> },
 
+    "format" <value:Value> =>
+        Instruction::Format { <> },
+
     // operations
 
     "set" <to:Value> <from:Value> =>
@@ -271,6 +275,7 @@ Symbol = {
     "draw",
     "print",
     "printchar",
+    "format",
     "set",
     "noop",
     "wait",

src/logic/vm/instructions.rs

@@ -60,6 +60,7 @@ pub fn parse_instruction(
         ast::Instruction::Draw { .. } => Box::new(Noop),
         ast::Instruction::Print { value } => Box::new(Print { value: lvar(value) }),
         ast::Instruction::PrintChar { value } => Box::new(PrintChar { value: lvar(value) }),
+        ast::Instruction::Format { value } => Box::new(Format { value: lvar(value) }),
 
         // operations
         ast::Instruction::Set { to, from } => Box::new(Set {
@@ -143,10 +144,12 @@ impl Print {
 
 impl SimpleInstruction for Print {
     fn execute(&self, state: &mut ProcessorState, _: &LogicVM) {
-        if state.printbuffer.len() < MAX_TEXT_BUFFER {
-            let value = self.value.get(state);
-            state.append_printbuffer(&Print::to_string(&value));
+        if state.printbuffer.len() >= MAX_TEXT_BUFFER {
+            return;
         }
+
+        let value = self.value.get(state);
+        state.append_printbuffer(&Print::to_string(&value));
     }
 }
 
@@ -156,13 +159,53 @@ struct PrintChar {
 
 impl SimpleInstruction for PrintChar {
     fn execute(&self, state: &mut ProcessorState, _: &LogicVM) {
-        if state.printbuffer.len() < MAX_TEXT_BUFFER {
-            // TODO: content emojis
-            if let LValue::Number(c) = self.value.get(state) {
-                // Java converts from float to char via int, not directly
-                state.printbuffer.push(c.floor() as u32 as u16);
+        if state.printbuffer.len() >= MAX_TEXT_BUFFER {
+            return;
+        }
+
+        // TODO: content emojis
+        if let LValue::Number(c) = self.value.get(state) {
+            // Java converts from float to char via int, not directly
+            state.printbuffer.push(c.floor() as u32 as u16);
+        }
+    }
+}
+
+struct Format {
+    value: LVar,
+}
+
+impl SimpleInstruction for Format {
+    fn execute(&self, state: &mut ProcessorState, _: &LogicVM) {
+        if state.printbuffer.len() >= MAX_TEXT_BUFFER {
+            return;
+        }
+
+        let mut placeholder_index = MAX_TEXT_BUFFER;
+        let mut placeholder_number = 10;
+
+        for (i, vals) in state.printbuffer.windows(3).enumerate() {
+            let &[left, c, right] = vals else {
+                unreachable!()
+            };
+            if left == ('{' as u16) && right == ('}' as u16) {
+                let n = (c as i32) - ('0' as i32);
+                if (0..=9).contains(&n) && n < placeholder_number {
+                    placeholder_number = n;
+                    placeholder_index = i;
+                }
             }
         }
+
+        if placeholder_index == MAX_TEXT_BUFFER {
+            return;
+        }
+
+        let value = self.value.get(state);
+        state.printbuffer.splice(
+            placeholder_index..placeholder_index + 3,
+            ProcessorState::encode_utf16(&Print::to_string(&value)),
+        );
     }
 }
 

src/logic/vm/mod.rs

@@ -634,4 +634,78 @@ mod tests {
             ]
         );
     }
+
+    #[test]
+    fn test_format() {
+        let mut vm = single_processor_vm(
+            BlockType::MicroProcessor,
+            r#"
+            print "{0} {2} {/} {3} {:} {10} {1}"
+            noop
+
+            format 4
+            noop
+
+            format "abcde"
+            noop
+
+            format "aa"
+            noop
+
+            format ""
+            noop
+
+            format "ignored"
+            stop
+            "#,
+        );
+
+        vm.do_tick(Duration::ZERO);
+
+        with_processor(&mut vm, 0, |p| {
+            assert_eq!(
+                p.state.decode_printbuffer(),
+                r#"{0} {2} {/} {3} {:} {10} {1}"#
+            );
+        });
+
+        vm.do_tick(Duration::ZERO);
+
+        with_processor(&mut vm, 0, |p| {
+            assert_eq!(
+                p.state.decode_printbuffer(),
+                r#"4 {2} {/} {3} {:} {10} {1}"#
+            );
+        });
+
+        vm.do_tick(Duration::ZERO);
+
+        with_processor(&mut vm, 0, |p| {
+            assert_eq!(
+                p.state.decode_printbuffer(),
+                r#"4 {2} {/} {3} {:} {10} abcde"#
+            );
+        });
+
+        vm.do_tick(Duration::ZERO);
+
+        with_processor(&mut vm, 0, |p| {
+            assert_eq!(
+                p.state.decode_printbuffer(),
+                r#"4 aa {/} {3} {:} {10} abcde"#
+            );
+        });
+
+        vm.do_tick(Duration::ZERO);
+
+        with_processor(&mut vm, 0, |p| {
+            assert_eq!(p.state.decode_printbuffer(), r#"4 aa {/}  {:} {10} abcde"#);
+        });
+
+        vm.do_tick(Duration::ZERO);
+
+        with_processor(&mut vm, 0, |p| {
+            assert_eq!(p.state.decode_printbuffer(), r#"4 aa {/}  {:} {10} abcde"#);
+        });
+    }
 }

src/logic/vm/processor.rs

@@ -112,12 +112,20 @@ impl ProcessorState {
         self.time.get() * 60. / 1000.
     }
 
+    pub fn encode_utf16(value: &str) -> impl Iterator<Item = u16> {
+        value.encode_utf16()
+    }
+
+    pub fn decode_utf16(value: &[u16]) -> String {
+        String::from_utf16_lossy(value)
+    }
+
     pub fn append_printbuffer(&mut self, value: &str) {
-        self.printbuffer.extend(value.encode_utf16())
+        self.printbuffer.extend(Self::encode_utf16(value))
     }
 
     pub fn decode_printbuffer(&self) -> String {
-        String::from_utf16_lossy(&self.printbuffer)
+        Self::decode_utf16(&self.printbuffer)
     }
 }