feat: support native functions

Author: aymaneelmaini

Makefile

@@ -3,7 +3,7 @@ CFLAGS = -std=c99 -Wall -Wextra  -Wno-unused-parameter -g
 CTEST_FLAGS = -std=c99 -g
 LDFLAGS = -lcriterion
 
-SOURCES = src/scanner.c src/chunk.c src/compiler.c src/debug.c src/memory.c src/value.c src/vm.c src/object.c src/table.c
+SOURCES = src/scanner.c src/chunk.c src/compiler.c src/debug.c src/memory.c src/value.c src/vm.c src/object.c src/table.c src/native_fn.c
 TEST_SOURCES = tests/scanner_test.c 
 
 all: clox

src/memory.c

@@ -31,6 +31,11 @@ static void free_object(Obj* object)
         FREE(ObjFunction, object);
         break;
     }
+    case OBJ_NATIVE:
+    {
+        FREE(ObjNative, object);
+        break;
+    }
     case OBJ_STRING:
     {
         ObjString* string = (ObjString*)object;

src/native_fn.c

@@ -0,0 +1,7 @@
+#include "native_fn.h"
+#include <time.h>
+
+Value clock_native(int arg_count, Value* args)
+{
+    return NUMBER_VAL((double)clock() / CLOCKS_PER_SEC);
+}

src/native_fn.h

@@ -0,0 +1,8 @@
+#ifndef clox_native_fn_c
+#define clox_native_fn_c
+
+#include "value.h"
+
+Value clock_native(int arg_count, Value* args);
+
+#endif

src/object.c

@@ -33,6 +33,13 @@ ObjFunction* new_function()
     return function;
 }
 
+ObjNative* new_native(NativeFn function)
+{
+    ObjNative* native = ALLOCATE_OBJ(ObjNative, OBJ_NATIVE);
+    native->function = function;
+    return native;
+}
+
 static ObjString* allocate_string(char* chars, int length, u32 hash)
 {
     ObjString* string = ALLOCATE_OBJ(ObjString, OBJ_STRING);
@@ -106,6 +113,11 @@ void print_object(Value value)
         print_function(AS_FUNCTION(value));
         break;
     }
+    case OBJ_NATIVE:
+    {
+        printf("<native fn>");
+        break;
+    }
     case OBJ_STRING:
     {
 

src/object.h

@@ -10,14 +10,18 @@
 #define IS_FUNCTION(value) is_obj_type(value, OBJ_FUNCTION);
 #define AS_FUNCTION(value) (((ObjFunction*)AS_OBJ(value)))
 
+#define IS_NATIVE(value) is_obj_type(value, OBJ_NATIVE);
+#define AS_NATIVE(value) (((ObjNative*)AS_OBJ(value))->function)
+
 #define IS_STRING(value) is_obj_type(value, OBJ_STRING)
 #define AS_STRING(value) ((ObjString*)AS_OBJ(value))
 #define AS_CSTRING(value) (((ObjString*)AS_OBJ(value))->chars)
 
 typedef enum
 {
-    OBJ_STRING,
     OBJ_FUNCTION,
+    OBJ_NATIVE,
+    OBJ_STRING,
 } ObjType;
 
 struct Obj
@@ -34,6 +38,15 @@ typedef struct
     ObjString* name;
 } ObjFunction;
 
+typedef Value (*NativeFn)(int arg_count, Value* args);
+
+typedef struct
+{
+    Obj      obj;
+    NativeFn function;
+
+} ObjNative;
+
 struct ObjString
 {
     Obj   obj;
@@ -43,6 +56,7 @@ struct ObjString
 };
 
 ObjFunction* new_function();
+ObjNative*   new_native(NativeFn function);
 ObjString*   take_string(char* chars, int length);
 ObjString*   copy_string(const char* chars, int length);
 void         print_object(Value value);

src/value.h

@@ -1,6 +1,8 @@
 #ifndef clox_value_h
 #define clox_value_h
 
+#include <stdbool.h>
+
 typedef struct Obj       Obj;
 typedef struct ObjString ObjString;
 

src/vm.c

@@ -8,6 +8,7 @@
 #include "compiler.h"
 #include "debug.h"
 #include "memory.h"
+#include "native_fn.h"
 #include "object.h"
 #include "table.h"
 #include "value.h"
@@ -45,12 +46,23 @@ static void runtime_error(const char* format, ...)
     }
 }
 
+static void define_native(const char* name, NativeFn function)
+{
+    push(OBJ_VAL(copy_string(name, (int)strlen(name))));
+    push(OBJ_VAL(new_native(function)));
+    table_set(&vm.globals, AS_STRING(vm.stack[0]), vm.stack[1]);
+    pop();
+    pop();
+}
+
 void init_VM()
 {
     reset_stack();
     vm.objects = NULL;
     init_table(&vm.globals);
     init_table(&vm.strings);
+
+    define_native("clock", clock_native);
 }
 
 void free_VM()
@@ -108,6 +120,14 @@ static bool call_value(Value callee, int arg_count)
         {
             return call(AS_FUNCTION(callee), arg_count);
         }
+        case OBJ_NATIVE:
+        {
+            NativeFn native = AS_NATIVE(callee);
+            Value    result = native(arg_count, vm.stack_top - arg_count);
+            vm.stack_top -= arg_count + 1;
+            push(result);
+            return true;
+        }
         default:
             // No callable shit
             break;