turn access into a function to be ran at runtime

src/runtime/access/access.c

@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+#include "access.h"
+#include <stdio.h>
+
+ArgonObject *ARGON_TYPE_TYPE___get_attr__(size_t argc, ArgonObject **argv,
+                                          ArErr *err, RuntimeState *state) {
+  (void)state;
+  if (argc != 3) {
+    *err = create_err(0, 0, 0, "", "Runtime Error",
+                      "__get_attr__ expects 3 arguments, got %" PRIu64);
+    return ARGON_NULL;
+  }
+  ArgonObject *to_access = argv[0];
+  ArgonObject *access = argv[1];
+  bool check_field = argv[2] == ARGON_TRUE;
+  if (check_field) {
+    ArgonObject *value = get_field_l(to_access, access->value.as_str.data,
+                                     access->value.as_str.length, true, false);
+    if (value)
+      return value;
+  }
+  ArgonObject *name = get_field_for_class(
+      get_field(to_access, "__class__", false, false), "__name__", to_access);
+  *err = create_err(0, 0, 0, "", "Runtime Error",
+                    "'%.*s' object has no attribute '%.*s'",
+                    (int)name->value.as_str.length, name->value.as_str.data,
+                    (int)access->value.as_str.length, access->value.as_str.data);
+  return ARGON_NULL;
+}

src/runtime/access/access.h

@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#ifndef runtime_access_H
+#define runtime_access_H
+#include "../objects/literals/literals.h"
+#include "../objects/object.h"
+#include "../runtime.h"
+#include <inttypes.h>
+
+ArgonObject *ARGON_TYPE_TYPE___get_attr__(size_t argc, ArgonObject **argv,
+                                          ArErr *err, RuntimeState *state);
+
+#endif // runtime_access_H

src/runtime/objects/object.c

@@ -9,6 +9,7 @@
 #include "../../memory.h"
 #include "type/type.h"
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -16,6 +17,7 @@ ArgonObject *BASE_CLASS = NULL;
 
 ArgonObject *new_object() {
   ArgonObject *object = ar_alloc(sizeof(ArgonObject));
+  object->type = TYPE_OBJECT;
   object->dict = createHashmap_GC();
   add_field(object, "__class__", ARGON_TYPE_TYPE);
   return object;
@@ -40,38 +42,48 @@ ArgonObject *bind_object_to_function(ArgonObject *object,
   return bound_method_wrapper;
 }
 
-ArgonObject *get_field_for_class(ArgonObject *target, char *name,
-                                 ArgonObject *binding_object) {
+ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
+                                   size_t length, ArgonObject *binding_object) {
   char *field = "__base__";
+  size_t field_size = strlen(field);
   while (target) {
-    uint64_t hash = siphash64_bytes(name, strlen(name), siphash_key);
-    ArgonObject *object = hashmap_lookup_GC(target->dict, hash);
-
+    ArgonObject *object = get_field_l(target, name, length, false, false);
     if (object) {
       if ((object->type == TYPE_FUNCTION ||
-          object->type == TYPE_NATIVE_FUNCTION) && binding_object) {
+           object->type == TYPE_NATIVE_FUNCTION) &&
+          binding_object) {
         object = bind_object_to_function(binding_object, object);
       }
       return object;
     }
-    hash = siphash64_bytes(field, strlen(field), siphash_key);
-    target = hashmap_lookup_GC(target->dict, hash);
+    target = get_field_l(target, field, field_size, false, false);
   }
   return NULL;
 }
 
-ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
-                       bool disable_method_wrapper) {
+ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
+                         bool recursive, bool disable_method_wrapper) {
   char *field = "__class__";
+  size_t field_size = strlen(field);
   ArgonObject *object = hashmap_lookup_GC(
-      target->dict, siphash64_bytes(name, strlen(name), siphash_key));
+      target->dict, siphash64_bytes(name, length, siphash_key));
   if (!recursive || object)
     return object;
   ArgonObject *binding = target;
   if (disable_method_wrapper)
     binding = NULL;
-  return get_field_for_class(
+  return get_field_for_class_l(
       hashmap_lookup_GC(target->dict,
-                        siphash64_bytes(field, strlen(field), siphash_key)),
-      name, binding);
+                        siphash64_bytes(field, field_size, siphash_key)),
+      name, length, binding);
+}
+
+ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
+                       bool disable_method_wrapper) {
+  return get_field_l(target, name, strlen(name), recursive,
+                     disable_method_wrapper);
+}
+ArgonObject *get_field_for_class(ArgonObject *target, char *name,
+                                 ArgonObject *binding_object) {
+  return get_field_for_class_l(target, name, strlen(name), binding_object);
 }

src/runtime/objects/object.h

@@ -17,6 +17,15 @@ ArgonObject *new_object();
 
 void add_field(ArgonObject *target, char *name, ArgonObject *object);
 
+ArgonObject *bind_object_to_function(ArgonObject *object,
+                                     ArgonObject *function);
+
+ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
+                                   size_t length, ArgonObject *binding_object);
+
+ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
+                         bool recursive, bool disable_method_wrapper);
+
 ArgonObject *get_field_for_class(ArgonObject *target, char *name,
                                  ArgonObject *binding_object);
 

src/runtime/runtime.c

@@ -16,6 +16,7 @@
 #include "objects/object.h"
 #include "objects/string/string.h"
 #include "objects/type/type.h"
+#include "access/access.h"
 #include <fcntl.h>
 #include <gc/gc.h>
 #include <inttypes.h>
@@ -28,6 +29,7 @@
 
 ArgonObject *ARGON_METHOD_TYPE;
 Stack *Global_Scope = NULL;
+ArgonObject*ACCESS_FUNCTION;
 
 ArgonObject *ARGON_TYPE_TYPE___call__(size_t argc, ArgonObject **argv,
                                       ArErr *err, RuntimeState *state) {
@@ -226,6 +228,7 @@ void bootstrap_types() {
       create_argon_native_function("__string__", ARGON_STRING_TYPE___string__));
   add_field(ARGON_BOOL_TYPE, "__new__",
             create_argon_native_function("__new__", ARGON_BOOL_TYPE___new__));
+  ACCESS_FUNCTION = create_argon_native_function("ACCESS_FUNCTION", ARGON_TYPE_TYPE___get_attr__);
 }
 
 void add_to_scope(Stack *stack, char *name, ArgonObject *value) {
@@ -335,9 +338,11 @@ ArErr run_instruction(Translated *translated, RuntimeState *state,
   case OP_DECLARE:
     return runtime_declaration(translated, state, *stack);
   case OP_BOOL:;
+    ArErr err = no_err;
     uint8_t to_register = pop_byte(translated, state);
-    state->registers[to_register] = ARGON_TRUE;
-    break;
+    ArgonObject* args[] = {ARGON_BOOL_TYPE, state->registers[0]};
+    state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, &err, state);
+    return err;
   case OP_JUMP_IF_FALSE:;
     uint8_t from_register = pop_byte(translated, state);
     uint64_t to = pop_bytecode(translated, state);
@@ -388,7 +393,7 @@ ArErr run_instruction(Translated *translated, RuntimeState *state,
     (state->call_instance->args)[index] = state->registers[0];
     break;
   case OP_CALL:;
-    ArErr err = run_call(state->call_instance->to_call,
+    err = run_call(state->call_instance->to_call,
                          state->call_instance->args_length,
                          state->call_instance->args, state, false);
     free(state->call_instance->args);
@@ -420,6 +425,12 @@ ArErr run_instruction(Translated *translated, RuntimeState *state,
                                               pop_bytecode(translated, state),
                                               pop_bytecode(translated, state)};
     break;
+  case OP_LOAD_BOOL:
+    state->registers[0] = pop_byte(translated, state)?ARGON_TRUE:ARGON_FALSE;
+    break;
+  case OP_LOAD_ACCESS_FUNCTION:
+    state->registers[0] = ACCESS_FUNCTION;
+    break;
   default:
     return create_err(0, 0, 0, NULL, "Runtime Error", "Invalid Opcode %#x",
                       opcode);