From 3c2e3699abc39b036802a8fb64a1d1849c4a7b47 Mon Sep 17 00:00:00 2001
From: Jeff <dev@jeffa.io>
Date: Fri, 6 Sep 2024 19:37:12 -0400
Subject: [PATCH] Add binary operations

---
 dust-lang/src/bytecode.rs | 131 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 126 insertions(+), 5 deletions(-)

diff --git a/dust-lang/src/bytecode.rs b/dust-lang/src/bytecode.rs
index d1a0f7a..e60ea9a 100644
--- a/dust-lang/src/bytecode.rs
+++ b/dust-lang/src/bytecode.rs
@@ -30,15 +30,51 @@ impl Vm {
 
                     self.stack.push(value.clone());
                 }
+                Instruction::Return => {
+                    let value = self.pop()?;
+
+                    return Ok(Some(value));
+                }
+
+                // Unary
                 Instruction::Negate => {
                     let negated = self.pop()?.negate()?;
 
                     self.stack.push(negated);
                 }
-                Instruction::Return => {
-                    let value = self.pop()?;
 
-                    return Ok(Some(value));
+                // Binary
+                Instruction::Add => {
+                    let b = self.pop()?;
+                    let a = self.pop()?;
+
+                    let sum = a.add(&b)?;
+
+                    self.stack.push(sum);
+                }
+                Instruction::Subtract => {
+                    let b = self.pop()?;
+                    let a = self.pop()?;
+
+                    let difference = a.subtract(&b)?;
+
+                    self.stack.push(difference);
+                }
+                Instruction::Multiply => {
+                    let b = self.pop()?;
+                    let a = self.pop()?;
+
+                    let product = a.multiply(&b)?;
+
+                    self.stack.push(product);
+                }
+                Instruction::Divide => {
+                    let b = self.pop()?;
+                    let a = self.pop()?;
+
+                    let quotient = a.divide(&b)?;
+
+                    self.stack.push(quotient);
                 }
             }
 
@@ -91,8 +127,16 @@ impl From<ValueError> for VmError {
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
 pub enum Instruction {
     Constant(usize),
-    Negate,
     Return,
+
+    // Unary
+    Negate,
+
+    // Binary
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
 }
 
 impl Instruction {
@@ -103,8 +147,16 @@ impl Instruction {
 
                 format!("{:04} CONSTANT {} {}", offset, index, value)
             }
-            Instruction::Negate => format!("{:04} NEGATE", offset),
             Instruction::Return => format!("{:04} RETURN", offset),
+
+            // Unary
+            Instruction::Negate => format!("{:04} NEGATE", offset),
+
+            // Binary
+            Instruction::Add => format!("{:04} ADD", offset),
+            Instruction::Subtract => format!("{:04} SUBTRACT", offset),
+            Instruction::Multiply => format!("{:04} MULTIPLY", offset),
+            Instruction::Divide => format!("{:04} DIVIDE", offset),
         }
     }
 }
@@ -183,4 +235,73 @@ pub mod tests {
 
         assert_eq!(result, Ok(Some(Value::integer(-42))));
     }
+
+    #[test]
+    fn addition() {
+        let mut chunk = Chunk::new();
+        let left = chunk.push_constant(Value::integer(42));
+        let right = chunk.push_constant(Value::integer(23));
+
+        chunk.write(Instruction::Constant(left), Span(0, 1));
+        chunk.write(Instruction::Constant(right), Span(2, 3));
+        chunk.write(Instruction::Add, Span(4, 5));
+        chunk.write(Instruction::Return, Span(6, 7));
+
+        let mut vm = Vm::new(chunk);
+        let result = vm.interpret();
+
+        assert_eq!(result, Ok(Some(Value::integer(65))));
+    }
+
+    #[test]
+    fn subtraction() {
+        let mut chunk = Chunk::new();
+        let left = chunk.push_constant(Value::integer(42));
+        let right = chunk.push_constant(Value::integer(23));
+
+        chunk.write(Instruction::Constant(left), Span(0, 1));
+        chunk.write(Instruction::Constant(right), Span(2, 3));
+        chunk.write(Instruction::Subtract, Span(4, 5));
+        chunk.write(Instruction::Return, Span(6, 7));
+
+        let mut vm = Vm::new(chunk);
+        let result = vm.interpret();
+
+        assert_eq!(result, Ok(Some(Value::integer(19))));
+    }
+
+    #[test]
+    fn multiplication() {
+        let mut chunk = Chunk::new();
+        let left = chunk.push_constant(Value::integer(42));
+        let right = chunk.push_constant(Value::integer(23));
+
+        chunk.write(Instruction::Constant(left), Span(0, 1));
+        chunk.write(Instruction::Constant(right), Span(2, 3));
+        chunk.write(Instruction::Multiply, Span(4, 5));
+        chunk.write(Instruction::Return, Span(6, 7));
+
+        let mut vm = Vm::new(chunk);
+        let result = vm.interpret();
+
+        assert_eq!(result, Ok(Some(Value::integer(966))));
+    }
+
+    #[test]
+
+    fn division() {
+        let mut chunk = Chunk::new();
+        let left = chunk.push_constant(Value::integer(42));
+        let right = chunk.push_constant(Value::integer(23));
+
+        chunk.write(Instruction::Constant(left), Span(0, 1));
+        chunk.write(Instruction::Constant(right), Span(2, 3));
+        chunk.write(Instruction::Divide, Span(4, 5));
+        chunk.write(Instruction::Return, Span(6, 7));
+
+        let mut vm = Vm::new(chunk);
+        let result = vm.interpret();
+
+        assert_eq!(result, Ok(Some(Value::integer(1))));
+    }
 }