write runtime object bootstrap

src/runtime/declaration/declaration.c

@@ -19,7 +19,7 @@ ArErr runtime_declaration(Translated *translated, RuntimeState *state,
     SourceLocation *source_location = darray_get(&translated->source_locations, source_location_index);
     return create_err(source_location->line, source_location->column, source_location->length, state->path, "Runtime Error", "Identifier '%.*s' has already been declared in the current scope", length, arena_get(&translated->constants, offset));
   }
-  ArgonObject * key = init_string_object(arena_get(&translated->constants, offset), length);
+  ArgonObject * key = new_string_object(arena_get(&translated->constants, offset), length);
   hashmap_insert_GC(stack->scope, hash, key, state->registers[from_register], 0);
   return no_err;
 }

src/runtime/objects/functions/functions.c

@@ -6,6 +6,7 @@
 
 #include "../../runtime.h"
 #include "../object.h"
+#include "../string/string.h"
 #include <stdio.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -13,34 +14,27 @@
 
 ArgonObject *ARGON_FUNCTION_TYPE = NULL;
 
-void init_function_type() {
-  ARGON_FUNCTION_TYPE = init_argon_class("Function");
-}
-
 void load_argon_function(Translated *translated, RuntimeState *state,
                                  struct Stack *stack) {
-  ArgonObject *object = init_child_argon_object(ARGON_FUNCTION_TYPE);
+  ArgonObject *object = new_object();
+  add_field(object, "__class__", ARGON_FUNCTION_TYPE);
   object->type = TYPE_FUNCTION;
   uint64_t offset = pop_bytecode(translated, state);
   uint64_t length = pop_bytecode(translated, state);
-  object->name = ar_alloc_atomic(length + 1);
-  memcpy(object->name, arena_get(&translated->constants, offset), length);
-  object->name[length] = '\0';
+  add_field(object, "__class__", new_string_object(arena_get(&translated->constants, offset), length));
   object->value.argon_fn.number_of_parameters = pop_bytecode(translated, state);
   object->value.argon_fn.parameters =
-      ar_alloc(object->value.argon_fn.number_of_parameters * sizeof(char *));
+      ar_alloc(object->value.argon_fn.number_of_parameters * sizeof(struct string_struct));
   for (size_t i = 0; i < object->value.argon_fn.number_of_parameters; i++) {
     offset = pop_bytecode(translated, state);
     length = pop_bytecode(translated, state);
-    object->value.argon_fn.parameters[i] = ar_alloc_atomic(length + 1);
-    memcpy(object->value.argon_fn.parameters[i], arena_get(&translated->constants, offset), length);
-    object->value.argon_fn.parameters[i][length] = '\0';
+    object->value.argon_fn.parameters[i].data = arena_get(&translated->constants, offset);
+    object->value.argon_fn.parameters[i].length = length;
   }
   offset = pop_bytecode(translated, state);
   length = pop_bytecode(translated, state);
-  darray_armem_init(&object->value.argon_fn.bytecode, sizeof(uint64_t));
-  darray_armem_resize(&object->value.argon_fn.bytecode, length/object->value.argon_fn.bytecode.element_size);
-  memcpy(object->value.argon_fn.bytecode.data, arena_get(&translated->constants, offset), length);
+  object->value.argon_fn.bytecode = arena_get(&translated->constants, offset);
+  object->value.argon_fn.bytecode_length = length;
   object->value.argon_fn.stack = *stack;
   state->registers[0]=object;
 }

src/runtime/objects/functions/functions.h

@@ -8,7 +8,7 @@
 #define FUNCTION_H
 #include "../object.h"
 
-void init_function_type();
+extern ArgonObject *ARGON_FUNCTION_TYPE;
 
 ArgonObject *load_argon_function(Translated *translated, RuntimeState *state, struct Stack *stack);
 

src/runtime/objects/literals/literals.c

@@ -13,19 +13,4 @@ ArgonObject *ARGON_NULL = NULL;
 
 ArgonObject *ARGON_BOOL_TYPE = NULL;
 ArgonObject *ARGON_TRUE = NULL;
-ArgonObject *ARGON_FALSE = NULL;
-
-void init_literals() {
-    ARGON_NULL_TYPE = init_argon_class("NULL_TYPE");
-
-    ARGON_NULL = init_child_argon_object(ARGON_NULL_TYPE);
-    ARGON_NULL->type=TYPE_NULL;
-
-    ARGON_BOOL_TYPE = init_argon_class("Bool");
-
-    ARGON_FALSE = init_child_argon_object(ARGON_BOOL_TYPE);
-    ARGON_FALSE->type=TYPE_BOOL;
-
-    ARGON_TRUE = init_child_argon_object(ARGON_BOOL_TYPE);
-    ARGON_TRUE->type=TYPE_BOOL;
-}
+ArgonObject *ARGON_FALSE = NULL;

src/runtime/objects/literals/literals.h

@@ -8,8 +8,12 @@
 #define RUNTIME_LITERALS_H
 #include "../object.h"
 
+extern ArgonObject *ARGON_NULL_TYPE;
 extern ArgonObject *ARGON_NULL;
+
+extern ArgonObject *ARGON_BOOL_TYPE;
 extern ArgonObject *ARGON_FALSE;
+
 extern ArgonObject *ARGON_TRUE;
 
 void init_literals();

src/runtime/objects/object.c

@@ -13,32 +13,15 @@
 
 ArgonObject *BASE_CLASS = NULL;
 
-void init_base_field() {
-  // add_field(BASE_CLASS, "test", BASE_CLASS);
-}
-
-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 *new_object() {
   ArgonObject *object = ar_alloc(sizeof(ArgonObject));
-  object->name = name;
-  object->type = TYPE_OBJECT;
-  object->self = object;
-  object->classObject = ;
-  object->baseObject = BASE_CLASS;
-  object->fields = createHashmap_GC();
-  memset(&object->value, 0, sizeof(object->value));
+  object->dict = createHashmap_GC();
+  add_field(object, "__class__", ARGON_TYPE_TYPE);
   return object;
 }
 
 void add_field(ArgonObject *target, char *name, ArgonObject *object) {
-  hashmap_insert_GC(target->fields,
+  hashmap_insert_GC(target->dict,
                     siphash64_bytes(name, strlen(name), siphash_key), name,
                     object, 0);
 }

src/runtime/objects/object.h

@@ -13,9 +13,7 @@
 extern ArgonObject *BASE_CLASS;
 
 typedef struct ArgonObject ArgonObject;
-void init_base_field();
-ArgonObject *init_child_argon_object(ArgonObject *cls);
-ArgonObject *init_argon_class(char *name);
+ArgonObject *new_object();
 
 void add_field(ArgonObject *target, char *name, ArgonObject *object);
 #endif // OBJECT_H

src/runtime/objects/string/string.c

@@ -8,19 +8,20 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <stdio.h>
+#include <string.h>
 #include "string.h"
 
 ArgonObject *ARGON_STRING_TYPE = NULL;
 
-void init_string_type() {
-  ARGON_STRING_TYPE = init_argon_class("String");
-
-}
-
-ArgonObject *init_string_object(char*data, size_t length) {
-  ArgonObject * object = init_child_argon_object(ARGON_STRING_TYPE);
+ArgonObject *new_string_object(char*data, size_t length) {
+  ArgonObject * object = new_object();
+  add_field(object, "__class__", ARGON_STRING_TYPE);
   object->type = TYPE_STRING;
   object->value.as_str.data = data;
   object->value.as_str.length = length;
   return object;
+}
+
+ArgonObject *new_string_object_null_terminated(char*data) {
+  return new_string_object(data, strlen(data));
 }

src/runtime/objects/string/string.h

@@ -10,8 +10,7 @@
 
 extern ArgonObject *ARGON_STRING_TYPE;
 
-void init_string_type();
-
-ArgonObject *init_string_object(char*data, size_t length);
+ArgonObject *new_string_object(char*data, size_t length);
 
+ArgonObject *new_string_object_null_terminated(char*data);
 #endif // STRING_OBJ_H

src/runtime/objects/type/type.c

@@ -3,15 +3,8 @@
  *
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
-
-#include "../../internals/hashmap/hashmap.h"
 #include "../object.h"
 #include <string.h>
 #include "type.h"
 
-ArgonObject *ARGON_TYPE = NULL;
-
-void init_type() {
-    ARGON_TYPE = init_argon_class("type");
-    ARGON_TYPE->baseObject = BASE_CLASS;
-}
+ArgonObject *ARGON_TYPE_TYPE = NULL;

src/runtime/objects/type/type.h

@@ -8,9 +8,7 @@
 #define TYPES_H
 #include "../object.h"
 
-extern ArgonObject *ARGON_TYPE;
-
-void init_type();
+extern ArgonObject *ARGON_TYPE_TYPE;
 
 
 #endif // TYPES_H

src/runtime/runtime.c

@@ -23,16 +23,38 @@
 #include <string.h>
 #include <unistd.h>
 
-void init_types() {
-  BASE_CLASS = init_argon_class("BASE_CLASS");
+void bootstrap_types() {
+  BASE_CLASS = new_object();
+  ARGON_TYPE_TYPE = new_object();
+  add_field(ARGON_TYPE_TYPE, "__base__", BASE_CLASS);
+  add_field(ARGON_TYPE_TYPE, "__class__", ARGON_TYPE_TYPE);
 
-  init_type();
-  init_function_type();
-  init_literals();
-  init_string_type();
+  ARGON_NULL_TYPE = new_object();
+  add_field(ARGON_NULL_TYPE, "__base__", BASE_CLASS);
+  ARGON_NULL = new_object();
+  add_field(ARGON_NULL, "__class__", ARGON_NULL_TYPE);
 
-  init_base_field();
-  BASE_CLASS->baseObject = ARGON_NULL;
+  add_field(BASE_CLASS, "__base__", ARGON_NULL);
+
+  ARGON_BOOL_TYPE = new_object();
+  add_field(ARGON_BOOL_TYPE, "__base__", BASE_CLASS);
+  ARGON_TRUE = new_object();
+  add_field(ARGON_NULL, "__class__", ARGON_BOOL_TYPE);
+  ARGON_FALSE = new_object();
+  add_field(ARGON_NULL, "__class__", ARGON_BOOL_TYPE);
+
+  ARGON_STRING_TYPE = new_object();
+  add_field(ARGON_STRING_TYPE, "__base__", BASE_CLASS);
+
+
+  add_field(BASE_CLASS, "__name__", new_string_object_null_terminated("object"));
+  add_field(ARGON_TYPE_TYPE, "__name__", new_string_object_null_terminated("type"));
+  add_field(ARGON_NULL_TYPE, "__name__", new_string_object_null_terminated("NullType"));
+  add_field(ARGON_BOOL_TYPE, "__name__", new_string_object_null_terminated("boolean"));
+
+  ARGON_FUNCTION_TYPE = new_object();
+  add_field(ARGON_FUNCTION_TYPE, "__base__", BASE_CLASS);
+  add_field(ARGON_FUNCTION_TYPE, "__name__", new_string_object_null_terminated("function"));
 }
 
 int compare_by_order(const void *a, const void *b) {
@@ -64,7 +86,7 @@ void load_const(Translated *translated, RuntimeState *state) {
   ArgonObject *object = ARGON_NULL;
   switch (type) {
   case TYPE_OP_STRING:
-    object = init_string_object(data, length);
+    object = new_string_object(data, length);
     break;
   }
   state->registers[to_register] = object;

src/runtime/runtime.h

@@ -32,7 +32,7 @@ typedef struct StackFrame {
   StackFrame *previousStackFrame;
 } StackFrame;
 
-void init_types();
+void bootstrap_types();
 
 extern struct hashmap *runtime_hash_table;