add functions to bytecode and continuing working on runtime objects

src/runtime/objects/function/functions.h

@@ -0,0 +1,6 @@
+#ifndef FUNCTION_H
+#define FUNCTION_H
+#include "../object.h"
+
+
+#endif // FUNCTION_H

src/runtime/objects/null/null.c

@@ -3,8 +3,12 @@
 #include <string.h>
 #include "null.h"
 
+ArgonObject *ARGON_NULL_TYPE = NULL;
 ArgonObject *ARGON_NULL = NULL;
 
 void init_null() {
-    ARGON_NULL = init_argon_object();
+    ARGON_NULL_TYPE = init_argon_class("NULL_TYPE");
+
+    ARGON_NULL = init_child_argon_object(ARGON_NULL_TYPE);
+    ARGON_NULL->type=TYPE_NULL;
 }

src/runtime/objects/object.c

@@ -1,19 +1,30 @@
 #include "object.h"
 #include "../../memory.h"
 #include "../runtime.h"
+#include <stdbool.h>
 #include <string.h>
 
-ArgonObject *BASE_OBJECT = NULL;
+ArgonObject *BASE_CLASS = NULL;
 
 void init_base_field() {
-    add_field(BASE_OBJECT, "test", BASE_OBJECT);
+    // add_field(BASE_CLASS, "test", BASE_CLASS);
 }
 
-ArgonObject* init_argon_object() {
+ArgonObject* init_child_argon_object(ArgonObject *cls) {
+    ArgonObject *object = init_argon_class(NULL);
+    object->self = object;
+    object->baseObject = cls;
+    add_field(object, "__call__", NULL);
+    return object;
+}
+
+
+ArgonObject* init_argon_class(char*name) {
     ArgonObject *object = ar_alloc(sizeof(ArgonObject));
+    object->name = name;
     object->type = TYPE_OBJECT;
-    object->typeObject = NULL;
-    object->baseObject = BASE_OBJECT;
+    object->self = NULL;
+    object->baseObject = BASE_CLASS;
     object->fields = createHashmap();
     memset(&object->value, 0, sizeof(object->value));
     return object;

src/runtime/objects/object.h

@@ -4,7 +4,7 @@
 #include <gmp.h>
 #include <stdbool.h>
 
-extern ArgonObject *BASE_OBJECT;
+extern ArgonObject *BASE_CLASS;
 
 struct string_struct {
   char *data;
@@ -17,14 +17,14 @@ typedef enum {
   TYPE_NUMBER,
   TYPE_STRING,
   TYPE_FUNCTION,
-  TYPE_NATIVE_FUNCTION,
   TYPE_OBJECT, // generic user object
 } ArgonType;
 
 struct ArgonObject {
   ArgonType type;
+  char* name;
+  ArgonObject *self;
   ArgonObject *baseObject;
-  ArgonObject *typeObject;
   struct hashmap *fields; // dynamic fields/methods
   union {
     mpq_t as_number;
@@ -36,8 +36,8 @@ struct ArgonObject {
 };
 typedef struct ArgonObject ArgonObject;
 void init_base_field();
-
-ArgonObject *init_argon_object();
+ArgonObject* init_child_argon_object(ArgonObject *cls);
+ArgonObject* init_argon_class(char*name);
 
 void add_field(ArgonObject*target, char* name, ArgonObject *object);
 #endif // OBJECT_H

src/runtime/objects/string/string.c

@@ -4,21 +4,15 @@
 #include <stdio.h>
 
 ArgonObject *ARGON_STRING_TYPE = NULL;
-ArgonObject *ARGON_STRING_BASE = NULL;
 
 void init_string_type() {
-  ARGON_STRING_TYPE = init_argon_object();
-
-  ARGON_STRING_BASE = init_argon_object();
+  ARGON_STRING_TYPE = init_argon_class("String");
 
 }
 
 ArgonObject *init_string_object(char*data, size_t length) {
-  fwrite(data, 1, length, stdout);
-  printf("\n");
-  ArgonObject * object = init_argon_object();
-  object->typeObject = ARGON_STRING_TYPE;
-  object->baseObject = ARGON_STRING_BASE;
+  ArgonObject * object = init_child_argon_object(ARGON_STRING_TYPE);
+  object->type = TYPE_STRING;
   object->value.as_str.data = data;
   object->value.as_str.length = length;
   return object;

src/runtime/objects/type/type.c

@@ -6,5 +6,5 @@
 ArgonObject *ARGON_TYPE = NULL;
 
 void init_type() {
-    ARGON_TYPE = init_argon_object();
+    ARGON_TYPE = init_argon_class("function");
 }

src/runtime/runtime.c

@@ -13,7 +13,7 @@
 #include <unistd.h>
 
 void init_types() {
-  BASE_OBJECT = init_argon_object();
+  BASE_CLASS = init_argon_class("BASE_CLASS");
 
   init_type();
   init_null();
@@ -33,7 +33,7 @@ void load_const(Translated *translated, RuntimeState *state) {
   size_t length = pop_bytecode(translated, state);
   uint64_t offset = pop_bytecode(translated, state);
 
-  void*data = ar_alloc(length);
+  void*data = ar_alloc_atomic(length);
   memcpy(data, arena_get(&translated->constants,offset), length);
   ArgonObject *object = ARGON_NULL;
   switch (type) {
@@ -44,7 +44,7 @@ void load_const(Translated *translated, RuntimeState *state) {
   state->registers[to_register] = object;
 }
 
-void run_instruction(Translated *translated, RuntimeState *state) {
+void run_instruction(Translated *translated, RuntimeState *state, struct Stack stack) {
   OperationType opcode = pop_bytecode(translated, state);
   switch (opcode) {
   case OP_LOAD_NULL:
@@ -59,9 +59,10 @@ void run_instruction(Translated *translated, RuntimeState *state) {
 void runtime(Translated translated) {
   RuntimeState state = {
       checked_malloc(translated.registerCount * sizeof(ArgonObject *)), 0};
+  struct Stack stack = {};
 
   while (state.head < translated.bytecode.size)
-    run_instruction(&translated, &state);
+    run_instruction(&translated, &state,stack);
   free(state.registers);
 }
 

src/runtime/runtime.h

@@ -8,9 +8,14 @@ typedef struct {
   size_t head;
 } RuntimeState;
 
+typedef struct Stack {
+    ArgonObject *scope;
+    struct Stack *prev;
+} Stack;
+
 void init_types();
 
-void run_instruction(Translated *translated, RuntimeState *state);
+void run_instruction(Translated *translated, RuntimeState *state, struct Stack stack);
 
 void runtime(Translated translated);