Implement read, move variables out of ProcessorState

Author: object-Object

src/logic/ast.rs

@@ -14,6 +14,11 @@ pub enum Statement {
 #[derive(Debug, Clone, PartialEq)]
 pub enum Instruction {
     // input/output
+    Read {
+        result: Value,
+        target: Value,
+        address: Value,
+    },
     Draw {
         op: DrawOp,
         x: Value,

src/logic/grammar.lalrpop

@@ -14,6 +14,7 @@ match {
 
     r"[^\r\n #\t;]+:" => LABEL,
 
+    "read",
     "draw",
     "print",
     "printchar",
@@ -178,6 +179,9 @@ Statement: Statement = {
 Instruction: Instruction = {
     // input/output
 
+    "read" <result:Value> <target:Value> <address:Value> =>
+        Instruction::Read { <> },
+
     "draw" <op:DrawOp0> =>
         optional_args!(Instruction::Draw { <>; x, y, p1, p2, p3, p4 }),
 
@@ -494,6 +498,7 @@ Symbol = {
     SYMBOL,
     LABEL,
 
+    "read",
     "draw",
     "print",
     "printchar",

src/logic/vm/buildings.rs

@@ -1,11 +1,11 @@
-use std::{cell::RefCell, rc::Rc};
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
 
 use strum_macros::IntoStaticStr;
 
 use super::{
     LogicVMBuilder, VMLoadError, VMLoadResult,
     processor::{Processor, ProcessorBuilder, ProcessorState},
-    variables::LValue,
+    variables::{LValue, LVar},
 };
 use crate::types::{
     Object, Point2, ProcessorConfig, SchematicTile,
@@ -177,6 +177,46 @@ impl Building {
     ) -> VMLoadResult<Self> {
         Self::from_config(name, (*position).into(), config, builder)
     }
+
+    pub fn borrow_data<T, U, R>(
+        &self,
+        state: &ProcessorState,
+        variables: &HashMap<String, LVar>,
+        f_processor: T,
+        f_other: U,
+    ) -> R
+    where
+        T: FnOnce(&ProcessorState, &HashMap<String, LVar>) -> R,
+        U: FnOnce(&BuildingData) -> R,
+    {
+        match self.data.try_borrow() {
+            Ok(data) => match &*data {
+                BuildingData::Processor(p) => f_processor(&p.state, &p.variables),
+                other => f_other(other),
+            },
+            Err(_) => f_processor(state, variables),
+        }
+    }
+
+    pub fn borrow_data_mut<T, U, R>(
+        &self,
+        state: &mut ProcessorState,
+        variables: &HashMap<String, LVar>,
+        f_processor: T,
+        f_other: U,
+    ) -> R
+    where
+        T: FnOnce(&mut ProcessorState, &HashMap<String, LVar>) -> R,
+        U: FnOnce(&mut BuildingData) -> R,
+    {
+        match self.data.try_borrow_mut() {
+            Ok(mut data) => match &mut *data {
+                BuildingData::Processor(p) => f_processor(&mut p.state, &p.variables),
+                other => f_other(other),
+            },
+            Err(_) => f_processor(state, variables),
+        }
+    }
 }
 
 #[derive(IntoStaticStr)]