borrow op in eval_op

1 files changed, 20 insertions, 17 deletions

diff --git a/src/vm.rs b/src/vm.rs
index 2a6dd06..6e16db3 100644
--- a/src/vm.rs
+++ b/src/vm.rs
@@ -364,8 +364,8 @@ impl VM {
         }
     }
 
-    fn eval_op(&mut self, op: Op) -> Result<OpResult, Error> {
-        match op {
+    fn eval_op(&mut self) -> Result<OpResult, Error> {
+        match self.op() {
             Op::Illegal => {
                 error!(self, ErrorKind::InvalidProgram);
             }
@@ -388,6 +388,7 @@ impl VM {
                 let offset = self.frame().stack_offset;
                 let value = match value {
                     Value::Function(_, block) => {
+                        let block = Rc::clone(block);
                         let mut ups = Vec::new();
                         for (slot, is_up, _) in block.borrow().ups.iter() {
                             let up = if *is_up {
@@ -413,7 +414,7 @@ impl VM {
                 match self.stack.pop().unwrap() {
                     Value::Float(a) => self.stack.push(Value::Float(-a)),
                     Value::Int(a) => self.stack.push(Value::Int(-a)),
-                    a => error!(self, ErrorKind::RuntimeTypeError(op, vec![a])),
+                    a => error!(self, ErrorKind::RuntimeTypeError(Op::Neg, vec![a])),
                 }
             }
 
@@ -424,7 +425,7 @@ impl VM {
                     (Value::String(a), Value::String(b)) => {
                         self.stack.push(Value::String(Rc::from(format!("{}{}", a, b))))
                     }
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::Add, vec![a, b])),
                 }
             }
 
@@ -432,7 +433,7 @@ impl VM {
                 match self.pop_twice() {
                     (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a - b)),
                     (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a - b)),
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::Sub, vec![a, b])),
                 }
             }
 
@@ -440,7 +441,7 @@ impl VM {
                 match self.pop_twice() {
                     (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a * b)),
                     (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a * b)),
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::Mul, vec![a, b])),
                 }
             }
 
@@ -448,7 +449,7 @@ impl VM {
                 match self.pop_twice() {
                     (Value::Float(a), Value::Float(b)) => self.stack.push(Value::Float(a / b)),
                     (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Int(a / b)),
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::Div, vec![a, b])),
                 }
             }
 
@@ -458,7 +459,7 @@ impl VM {
                     (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a == b)),
                     (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a == b)),
                     (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a == b)),
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::Equal, vec![a, b])),
                 }
             }
 
@@ -468,7 +469,7 @@ impl VM {
                     (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a < b)),
                     (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a < b)),
                     (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a < b)),
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::Less, vec![a, b])),
                 }
             }
 
@@ -478,37 +479,38 @@ impl VM {
                     (Value::Int(a), Value::Int(b)) => self.stack.push(Value::Bool(a > b)),
                     (Value::String(a), Value::String(b)) => self.stack.push(Value::Bool(a > b)),
                     (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a > b)),
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::Greater, vec![a, b])),
                 }
             }
 
             Op::And => {
                 match self.pop_twice() {
                     (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a && b)),
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::And, vec![a, b])),
                 }
             }
 
             Op::Or => {
                 match self.pop_twice() {
                     (Value::Bool(a), Value::Bool(b)) => self.stack.push(Value::Bool(a || b)),
-                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(op, vec![a, b])),
+                    (a, b) => error!(self, ErrorKind::RuntimeTypeError(Op::Or, vec![a, b])),
                 }
             }
 
             Op::Not => {
                 match self.stack.pop().unwrap() {
                     Value::Bool(a) => self.stack.push(Value::Bool(!a)),
-                    a => error!(self, ErrorKind::RuntimeTypeError(op, vec![a])),
+                    a => error!(self, ErrorKind::RuntimeTypeError(Op::Not, vec![a])),
                 }
             }
 
             Op::Jmp(line) => {
-                self.frame_mut().ip = line;
+                self.frame_mut().ip = *line;
                 return Ok(OpResult::Continue);
             }
 
             Op::JmpFalse(line) => {
+                let line = *line;
                 if matches!(self.stack.pop(), Some(Value::Bool(false))) {
                     self.frame_mut().ip = line;
                     return Ok(OpResult::Continue);
@@ -526,7 +528,7 @@ impl VM {
                 let offset = self.frame().stack_offset;
                 let value = match &self.stack[offset] {
                     Value::Function(ups, _) => {
-                        ups[slot].borrow().get(&self.stack)
+                        ups[*slot].borrow().get(&self.stack)
                     }
                     _ => unreachable!(),
                 };
@@ -535,6 +537,7 @@ impl VM {
 
             Op::AssignUpvalue(slot) => {
                 let offset = self.frame().stack_offset;
+                let slot = *slot;
                 let value = self.stack.pop().unwrap();
                 let slot = match &self.stack[offset] {
                     Value::Function(ups, _) => Rc::clone(&ups[slot]),
@@ -647,7 +650,7 @@ impl VM {
                 self.print_stack()
             }
 
-            if matches!(self.eval_op(self.op())?, OpResult::Done) {
+            if matches!(self.eval_op()?, OpResult::Done) {
                 return Ok(());
             }
         }
@@ -787,7 +790,7 @@ impl VM {
                 }
             }
             _ => {
-                self.eval_op(op)?;
+                self.eval_op()?;
                 return Ok(())
             }
         }