Added modulo operator and tests for modulo

src/lexer.c

@@ -180,6 +180,10 @@ static bool IsCharacter() {
     case '*':
       token.type = kTokenStar;
 
+      break;
+    case '%':
+      token.type = kTokenPercent;
+
       break;
     case '/':
       token.type = kTokenSlash;

src/lexer.h

@@ -43,6 +43,7 @@ typedef enum TokenType {
   kTokenMinus,
   kTokenStar,
   kTokenSlash,
+  kTokenPercent,
   kTokenDot,
   kTokenComma,
   kTokenColon,

src/parser.c

@@ -157,6 +157,10 @@ static void ParseOperator(const TokenType operation) {
     case kTokenStar:
       EmitByte(kOpMultiply);
 
+      break;
+    case kTokenPercent:
+      EmitByte(kOpModulo);
+
       break;
     case kTokenSlash:
       EmitByte(kOpDivide);
@@ -343,7 +347,8 @@ static VariableType ParseTerm() {
   VariableType left_type = ParseFactor();
   VariableType right_type = kVariableTypeUnknown;
 
-  while (kTokenStar == token.type || kTokenSlash == token.type) {
+  while (kTokenStar == token.type || kTokenSlash == token.type ||
+         kTokenPercent == token.type) {
     const TokenType kOperator = token.type;
 
     ConsumeNextToken();

src/vm.c

@@ -358,6 +358,30 @@ void RunVm() {
 
         break;
       }
+      case kOpModulo: {
+        StackValue stack_value_one = {};
+        StackValue stack_value_two = {};
+        StackValue result = {};
+
+        // cppcheck-suppress-begin redundantInitialization
+        stack_value_one = Pop();
+        stack_value_two = Pop();
+        // cppcheck-suppress-end redundantInitialization
+
+        if (0 == stack_value_one.as.number) {
+          puts("Error: Division by zero.");
+
+          return;
+        }
+
+        result.as.number =
+            stack_value_two.as.number % stack_value_one.as.number;
+        result.type = kConstantTypeNumber;
+
+        Push(result);
+
+        break;
+      }
       case kOpEquals: {
         StackValue stack_value_one = {};
         StackValue stack_value_two = {};

src/vm.h

@@ -19,6 +19,7 @@ typedef enum Opcode {
   kOpSubtract,
   kOpMultiply,
   kOpDivide,
+  kOpModulo,
   kOpEquals,
   kOpNotEquals,
   kOpGreaterThan,

tests/lexer_test.c

@@ -94,6 +94,14 @@ void TestSlash() {
   TEST_ASSERT_EQUAL_INT(kTokenSlash, token.type);
 }
 
+void TestPercent() {
+  FillProgramBuffer("60%3");
+
+  ConsumeNextToken();  // 60
+  ConsumeNextToken();  // %
+  TEST_ASSERT_EQUAL_INT(kTokenPercent, token.type);
+}
+
 void TestString() {
   FillProgramBuffer("\"Hello, world!\"");
 

tests/lexer_test.h

@@ -7,6 +7,7 @@ void TestPrintArithmetic();
 void TestMinus();
 void TestStar();
 void TestSlash();
+void TestPercent();
 void TestString();
 void TestPrintString();
 void TestIdentifier();

tests/main.c

@@ -21,6 +21,7 @@ int main() {
   RUN_TEST(TestMinus);
   RUN_TEST(TestStar);
   RUN_TEST(TestSlash);
+  RUN_TEST(TestPercent);
   RUN_TEST(TestString);
   RUN_TEST(TestPrintString);
   RUN_TEST(TestIdentifier);
@@ -60,6 +61,7 @@ int main() {
   RUN_TEST(TestSubtractArithmetic);
   RUN_TEST(TestMultiplyArithmetic);
   RUN_TEST(TestDivideArithmetic);
+  RUN_TEST(TestModuloArithmetic);
   RUN_TEST(TestTrueBoolean);
   RUN_TEST(TestFalseBoolean);
   RUN_TEST(TestStringParse);

tests/parser_test.c

@@ -58,6 +58,8 @@ void TestMultiplyArithmetic() {
 
 void TestDivideArithmetic() { TestBinaryOperator("print(10 / 5)", kOpDivide); }
 
+void TestModuloArithmetic() { TestBinaryOperator("print(10 % 5)", kOpModulo); }
+
 void TestLessThanCondition() {
   TestBinaryOperator("print(1 < 10)", kOpLessThan);
 }

tests/parser_test.h

@@ -13,6 +13,7 @@ void TestAddArithmetic();
 void TestSubtractArithmetic();
 void TestMultiplyArithmetic();
 void TestDivideArithmetic();
+void TestModuloArithmetic();
 void TestTrueBoolean();
 void TestFalseBoolean();
 void TestStringParse();