From 85211b127d61df52ee1b24cc33fee6c6256a869b Mon Sep 17 00:00:00 2001
From: Daniel M <daniel.q.mueller@stud.h-da.de>
Date: Mon, 31 Jan 2022 23:55:44 +0100
Subject: [PATCH] Impl missing operators for bytecode

---
 src/bytecode.rs | 25 ++++++++++++++++---------
 src/vm.rs       | 30 ++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 9 deletions(-)

diff --git a/src/bytecode.rs b/src/bytecode.rs
index f7b92ee..74e6005 100644
--- a/src/bytecode.rs
+++ b/src/bytecode.rs
@@ -14,13 +14,20 @@ pub enum OP {
     Subtract,
     Multiply,
     Divide,
-    Modulo,
+    Modulo,           
+    BOr,
+    BAnd,
+    BXor,
+    Shl,
+    Shr,
 
     Eq,
     Neq,
 
     Gt,
+    Ge,
     Lt,
+    Le,
 
     Jump,
 
@@ -153,18 +160,18 @@ impl Compiler {
             BinOpType::Mul => self.ops.push(OP::Multiply),
             BinOpType::Div => self.ops.push(OP::Divide),
             BinOpType::Mod => self.ops.push(OP::Modulo),
-            BinOpType::BOr => todo!(),
-            BinOpType::BAnd => todo!(),
-            BinOpType::BXor => todo!(),
-            BinOpType::Shl => todo!(),
-            BinOpType::Shr => todo!(),
+            BinOpType::BOr => self.ops.push(OP::BOr),
+            BinOpType::BAnd => self.ops.push(OP::BAnd),
+            BinOpType::BXor => self.ops.push(OP::BXor),
+            BinOpType::Shl => self.ops.push(OP::Shl),
+            BinOpType::Shr => self.ops.push(OP::Shr),
             BinOpType::Equ => self.ops.push(OP::Eq),
             BinOpType::Neq => self.ops.push(OP::Neq),
             BinOpType::Gt => self.ops.push(OP::Gt),
-            BinOpType::Ge => todo!(),
+            BinOpType::Ge => self.ops.push(OP::Ge),
             BinOpType::Lt => self.ops.push(OP::Lt),
-            BinOpType::Le => todo!(),
-            BinOpType::Assign => todo!(),
+            BinOpType::Le => self.ops.push(OP::Le),
+            BinOpType::Assign => unreachable!(),
         }
     }
 
diff --git a/src/vm.rs b/src/vm.rs
index 902ec92..5323792 100644
--- a/src/vm.rs
+++ b/src/vm.rs
@@ -101,11 +101,41 @@ impl Vm {
                     self.stack
                         .push(Value::I64(if vals.0 > vals.1 { 1 } else { 0 }))
                 }
+                OP::Ge => {
+                    let vals = self.pop2_i64();
+                    self.stack
+                        .push(Value::I64(if vals.0 >= vals.1 { 1 } else { 0 }))
+                }
                 OP::Lt => {
                     let vals = self.pop2_i64();
                     self.stack
                         .push(Value::I64(if vals.0 < vals.1 { 1 } else { 0 }))
                 }
+                OP::Le => {
+                    let vals = self.pop2_i64();
+                    self.stack
+                        .push(Value::I64(if vals.0 <= vals.1 { 1 } else { 0 }))
+                }
+                OP::BOr => {
+                    let vals = self.pop2_i64();
+                    self.stack.push(Value::I64(vals.0 | vals.1))
+                }
+                OP::BAnd => {
+                    let vals = self.pop2_i64();
+                    self.stack.push(Value::I64(vals.0 & vals.1))
+                }
+                OP::BXor => {
+                    let vals = self.pop2_i64();
+                    self.stack.push(Value::I64(vals.0 ^ vals.1))
+                }
+                OP::Shl => {
+                    let vals = self.pop2_i64();
+                    self.stack.push(Value::I64(vals.0 << vals.1))
+                }
+                OP::Shr => {
+                    let vals = self.pop2_i64();
+                    self.stack.push(Value::I64(vals.0 >> vals.1))
+                }
                 OP::Value(_) => {
                     panic!("This is not an instruction, but data. This should never be evaluated")
                 }