From 3971c2a09ab6fedc6bdcf5b7597fbf3d0bafeb0d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gustav=20S=C3=B6rn=C3=A4s?= <gustav@sornas.net>
Date: Sat, 9 Jan 2021 20:58:40 +0100
Subject: assert operator

---
 src/compiler.rs  | 13 +++++++++----
 src/tokenizer.rs |  6 ++++--
 src/vm.rs        | 18 ++++++++++++++++--
 3 files changed, 29 insertions(+), 8 deletions(-)

(limited to 'src')

diff --git a/src/compiler.rs b/src/compiler.rs
index 4b9e74c..9ab997c 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -8,10 +8,11 @@ struct Compiler {
 
 //TODO rustify
 const PREC_NO: u64 = 0;
-const PREC_BOOL: u64 = 1;
-const PREC_COMP: u64 = 2;
-const PREC_TERM: u64 = 3;
-const PREC_FACTOR: u64 = 4;
+const PREC_ASSERT: u64 = 1;
+const PREC_BOOL: u64 = 2;
+const PREC_COMP: u64 = 3;
+const PREC_TERM: u64 = 4;
+const PREC_FACTOR: u64 = 5;
 
 impl Compiler {
     pub fn new(tokens: TokenStream) -> Self {
@@ -56,6 +57,8 @@ impl Compiler {
 
             Token::And | Token::Or => PREC_BOOL,
 
+            Token::AssertEqual => PREC_ASSERT,
+
             _ => PREC_NO,
         }
     }
@@ -83,6 +86,7 @@ impl Compiler {
                 | Token::Plus
                 | Token::Slash
                 | Token::Star
+                | Token::AssertEqual
                 => self.binary(block),
 
             Token::EqualEqual
@@ -140,6 +144,7 @@ impl Compiler {
             Token::Minus => Op::Sub,
             Token::Star => Op::Mul,
             Token::Slash => Op::Div,
+            Token::AssertEqual => Op::AssertEqual,
             _ => { self.error("Illegal operator"); }
         };
         block.add(op);
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
index c804f6b..a53015d 100644
--- a/src/tokenizer.rs
+++ b/src/tokenizer.rs
@@ -61,6 +61,8 @@ pub enum Token {
     EqualEqual,
     #[token("!=")]
     NotEqual,
+    #[token("<=>")]
+    AssertEqual,
 
     #[token("(")]
     LeftParen,
@@ -137,13 +139,13 @@ mod tests {
     }
 
     #[test]
-    fn test_lex_once_affirm() {
+    fn test_lex_once() {
         lex_once("1");
     }
 
     #[test]
     #[should_panic]
-    fn test_lex_panic() {
+    fn test_lex_once_panic() {
         lex_once("1 2");
     }
 
diff --git a/src/vm.rs b/src/vm.rs
index 9102f81..633b920 100644
--- a/src/vm.rs
+++ b/src/vm.rs
@@ -21,10 +21,12 @@ pub enum Op {
     Or,
     Not,
 
-    Equal, // ==
-    Less, // <
+    Equal,   // ==
+    Less,    // <
     Greater, // >
 
+    AssertEqual,
+
     Print,
     Return,
 }
@@ -83,6 +85,10 @@ impl VM {
         (b, a)
     }
 
+    fn _peek_up(&self, amount: usize) -> Option<&Value> {
+        self.stack.get(self.stack.len() - amount)
+    }
+
     pub fn run(&mut self) {
         const PRINT_WHILE_RUNNING: bool = true;
         const PRINT_BLOCK: bool = true;
@@ -192,6 +198,14 @@ impl VM {
                     }
                 }
 
+                Op::AssertEqual => {
+                    let (a, b) = self.pop_twice();
+                    if a != b {
+                        println!("Assert failed for '{:?}' and '{:?}'", a, b);
+                    }
+                    self.stack.push(Value::Bool(a == b));
+                }
+
                 Op::Print => {
                     println!("PRINT: {:?}", self.stack.pop());
                 }
-- 
cgit v1.2.1