V0.2.x (#28)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "chimpanzee"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 authors = ["Yago Iglesias <yagoiglesias7@gmail.com>"]
 license = "MIT OR Apache-2.0"

docs/MONKEY.md

@@ -28,6 +28,7 @@ Integers support the following operators:
 - `-`: subtraction
 - `*`: multiplication
 - `/`: division (integer division)
+- `%`: modulo
 - `==`: equality
 - `!=`: inequality
 - `<`: less than

monkey_examples/filter.monkey

@@ -16,6 +16,6 @@ let filter = fn (arr, f) {
 };
 let a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 100];
 let is_even = fn (x) {
-    x / 2 * 2 == x
+    x % 2 == 0
 };
 filter(a, is_even);

src/compiler/code.rs

@@ -87,6 +87,7 @@ pub enum Opcode {
     NotEqual,
     Or,
     And,
+    Modulo,
 
     // Prefix operators
     Minus,
@@ -142,6 +143,7 @@ impl Display for Opcode {
             Opcode::Or => "OpOr",
             Opcode::And => "OpAnd",
             Opcode::Minus => "OpMinus",
+            Opcode::Modulo => "OpModulo",
             Opcode::Bang => "OpBang",
             Opcode::JumpNotTruthy => "OpJumpNotTruthy",
             Opcode::Jump => "OpJump",

src/compiler/compiler_tests.rs

@@ -72,6 +72,16 @@ pub mod tests {
                     Opcode::Pop.make(vec![]),
                 ]),
             },
+            CompilerTestCase {
+                input: "1 % 2".to_string(),
+                expected_constants: vec![Object::INTEGER(1), Object::INTEGER(2)],
+                expected_instructions: flatten_instructions(vec![
+                    Opcode::Constant.make(vec![0]),
+                    Opcode::Constant.make(vec![1]),
+                    Opcode::Modulo.make(vec![]),
+                    Opcode::Pop.make(vec![]),
+                ]),
+            },
         ];
 
         run_compiler(tests);

src/compiler/mod.rs

@@ -337,6 +337,7 @@ impl Compiler {
             Token::NotEqual => self.emit(Opcode::NotEqual, vec![]),
             Token::Or => self.emit(Opcode::Or, vec![]),
             Token::And => self.emit(Opcode::And, vec![]),
+            Token::Modulo => self.emit(Opcode::Modulo, vec![]),
             _ => return Err(format!("Unknown operator: {operator}")),
         };
         Ok(())

src/compiler/test_utils.rs

@@ -53,7 +53,7 @@ pub(crate) fn run_compiler(tests: Vec<CompilerTestCase>) {
         let mut compiler = Compiler::new();
 
         match compiler.compile(program) {
-            Ok(_) => {
+            Ok(()) => {
                 let bytecode = compiler.bytecode();
                 println!(
                     "want {}, got {}",

src/lexer/mod.rs

@@ -86,6 +86,7 @@ impl Lexer {
                     Token::Illegal("|".to_string())
                 }
             }
+            '%' => Token::Modulo,
             ';' => Token::Semicolon,
             '(' => Token::LParen,
             ')' => Token::RParen,
@@ -230,6 +231,7 @@ mod tests {
 
             break;
             continue;
+            42%13==20;
         "#;
 
         let mut lexer = Lexer::new(input);
@@ -361,6 +363,13 @@ mod tests {
             Token::Continue,
             Token::Semicolon,
             //
+            Token::Int(String::from("42")),
+            Token::Modulo,
+            Token::Int(String::from("13")),
+            Token::Equal,
+            Token::Int(String::from("20")),
+            Token::Semicolon,
+            //
             Token::Eof,
         ];
 

src/lexer/token.rs

@@ -27,6 +27,7 @@ pub enum Token {
     NotEqual,
     And,
     Or,
+    Modulo,
 
     // Delimiters
     Comma,
@@ -92,6 +93,7 @@ impl Display for Token {
             Token::While => write!(f, "while"),
             Token::Break => write!(f, "break"),
             Token::Continue => write!(f, "continue"),
+            Token::Modulo => write!(f, "%"),
         }
     }
 }

src/parser/ast.rs

@@ -80,7 +80,8 @@ impl Expression {
                 | Token::LTE
                 | Token::GTE
                 | Token::And
-                | Token::Or => {
+                | Token::Or
+                | Token::Modulo => {
                     parser.next_token(); // TODO: Solve this.
                                          //  This is absolutely awful, I need to peek the next token
                                          //  only if a infix operator is found, I want to also
@@ -635,7 +636,7 @@ impl From<&Token> for Precedence {
             Token::Equal | Token::NotEqual => Precedence::Equals,
             Token::LT | Token::GT | Token::LTE | Token::GTE => Precedence::LessGreater,
             Token::Plus | Token::Minus | Token::Or => Precedence::Sum,
-            Token::Slash | Token::Asterisk | Token::And => Precedence::Product,
+            Token::Slash | Token::Asterisk | Token::And | Token::Modulo => Precedence::Product,
             Token::LParen => Precedence::Call,
             Token::LSquare => Precedence::Index,
             _ => Precedence::Lowest,

src/parser/parser_tests.rs

@@ -172,6 +172,7 @@ mod tests {
             ("5 - 5;", "5", "-", "5"),
             ("5 * 5;", "5", "*", "5"),
             ("5 / 5;", "5", "/", "5"),
+            ("5 % 5;", "5", "%", "5"),
             ("5 > 5;", "5", ">", "5"),
             ("5 >= 5;", "5", ">=", "5"),
             ("5 < 5;", "5", "<", "5"),

src/vm/mod.rs

@@ -111,6 +111,7 @@ impl VM {
                 | Opcode::Sub
                 | Opcode::Mul
                 | Opcode::Div
+                | Opcode::Modulo
                 | Opcode::Or
                 | Opcode::And => {
                     self.execute_binary_operation(op)?;
@@ -305,7 +306,20 @@ impl VM {
             Opcode::Add => left + right,
             Opcode::Sub => left - right,
             Opcode::Mul => left * right,
-            Opcode::Div => left / right,
+            Opcode::Div => {
+                if right == 0 {
+                    Err("Division by zero".to_string())?
+                } else {
+                    left / right
+                }
+            }
+            Opcode::Modulo => {
+                if right == 0 {
+                    Err("Division by zero".to_string())?
+                } else {
+                    left % right
+                }
+            }
             _ => unreachable!(),
         };
 

src/vm/test_utils.rs

@@ -37,3 +37,14 @@ pub(crate) fn run_vm_tests(tests: Vec<VmTestCase>) {
         check_constants(&vec![test.expected], &vec![got]);
     }
 }
+
+#[allow(dead_code)]
+pub(crate) fn run_vm_with_error_output(input: &str) -> Result<(), String> {
+    let program = parse(input);
+    let mut compiler = Compiler::new();
+    compiler.compile(program).unwrap();
+    let bytecode = compiler.bytecode();
+
+    let mut vm = VM::new(bytecode);
+    vm.run()
+}

src/vm/vm_tests.rs

@@ -5,7 +5,7 @@ mod tests {
 
     use crate::{
         object::Object,
-        vm::test_utils::{run_vm_tests, VmTestCase},
+        vm::test_utils::{run_vm_tests, run_vm_with_error_output, VmTestCase},
     };
 
     #[test]
@@ -67,10 +67,36 @@ mod tests {
                 input: "(5 + 10 * 2 + 15 / 3) * 2 + -10".to_string(),
                 expected: Object::INTEGER(50),
             },
+            VmTestCase {
+                input: "5 % 5".to_string(),
+                expected: Object::INTEGER(0),
+            },
+            VmTestCase {
+                input: "5 % 1".to_string(),
+                expected: Object::INTEGER(0),
+            },
+            VmTestCase {
+                input: "5 % 2".to_string(),
+                expected: Object::INTEGER(1),
+            },
+            VmTestCase {
+                input: "4 % 5".to_string(),
+                expected: Object::INTEGER(4),
+            },
         ];
         run_vm_tests(tests);
     }
 
+    #[test]
+    fn test_division_by_zero() {
+        let tests = vec!["1 / 0", "1 % 0"];
+
+        for test in tests {
+            let result = run_vm_with_error_output(test);
+            assert!(result.is_err());
+        }
+    }
+
     #[test]
     fn test_boolean_logic() {
         let tests = vec![

tests/formatting_integrity.rs

@@ -147,7 +147,7 @@ fn test_filter_integrity() {
             iter(arr, []);
         };
         let a = [1, 2, 3, 4,5,6,7,8,9,11,100];
-        let is_even = fn(x) { (x/2)*2 == x };
+            let is_even = fn(x) { x % 2 == 0 };
         filter(a, is_even);
     "#;