feat: implement function calls

Author: aymaneelmaini

src/chunk.h

@@ -29,6 +29,7 @@ typedef enum
     OP_JUMP,
     OP_JUMP_IF_FALSE,
     OP_LOOP,
+    OP_CALL,
     OP_RETURN,
 } OpCode;
 

src/compiler.c

@@ -363,6 +363,26 @@ static void define_variable(u8 global, bool is_immutable)
     emit_bytes(OP_DEFINE_GLOBAL, global);
 }
 
+static u8 arguments_list()
+{
+    u8 arg_count = 0;
+
+    if (!check(TOKEN_RIGHT_PAREN))
+    {
+        do
+        {
+            expression();
+            if (arg_count == 255)
+            {
+                error("Can't have more than 255 arguments");
+            }
+            arg_count++;
+        } while (match(TOKEN_COMMA));
+    }
+    consume(TOKEN_RIGHT_PAREN, "Expect ')' after arguments");
+    return arg_count;
+}
+
 static void and_(bool can_assign)
 {
     int end_jump = emit_jump(OP_JUMP_IF_FALSE);
@@ -417,6 +437,12 @@ static void binary(bool can_assign)
     }
 }
 
+static void call(bool can_assign)
+{
+    u8 arg_count = arguments_list();
+    emit_bytes(OP_CALL, arg_count);
+}
+
 static void literal(bool can_assign)
 {
     switch (parser.previous.type)
@@ -534,7 +560,7 @@ static void unary(bool can_assign)
 }
 // clang-format off
 ParseRule rules[] = {
-    [TOKEN_LEFT_PAREN]     =  { grouping,  NULL,    PREC_NONE        },
+    [TOKEN_LEFT_PAREN]     =  { grouping,  call,    PREC_CALL        },
     [TOKEN_RIGHT_PAREN]    =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_LEFT_BRACE]     =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_RIGHT_BRACE]    =  { NULL,      NULL,    PREC_NONE        },

src/vm.c

@@ -1,3 +1,4 @@
+#include <linux/limits.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
@@ -68,6 +69,35 @@ static Value peek(int distance)
     return vm.stack_top[-1 - distance];
 }
 
+static bool call(ObjFunction* function, int arg_count)
+{
+    CallFrame* frame = &vm.frames[vm.frame_count++];
+    frame->function = function;
+    frame->ip = function->chunk.code;
+    frame->slots = vm.stack_top - arg_count - 1;
+    return true;
+}
+
+static bool call_value(Value callee, int arg_count)
+{
+    if (!IS_OBJ(callee))
+    {
+        runtime_error("Can only call functions and classes");
+        return false;
+    }
+
+    switch (OBJ_TYPE(callee))
+    {
+    case OBJ_FUNCTION:
+    {
+        return call(AS_FUNCTION(callee), arg_count);
+    }
+    default:
+        // No callable shit
+        break;
+    }
+}
+
 static bool is_falsey(Value value)
 {
     return IS_NIL(value) || (IS_BOOL(value) && !AS_BOOL(value));
@@ -262,6 +292,16 @@ static InterpretResult run()
             frame->ip -= offset;
             break;
         }
+        case OP_CALL:
+        {
+            u8 arg_count = READ_BYTE();
+            if (!call_value(peek(arg_count), arg_count))
+            {
+                return INTERPRET_RUNTIME_ERROR;
+            }
+            frame = &vm.frames[vm.frame_count - 1];
+            break;
+        }
         case OP_RETURN:
             return INTERPRET_OK;
         }