turn access into a function to be ran at runtime

src/parser/assignable/access/access.c

@@ -32,6 +32,9 @@ ParsedValueReturn parse_access(char *file, DArray *tokens, size_t *index,
       return (ParsedValueReturn){err, NULL};
     }
     Token *token = darray_get(tokens, *index);
+    parsedAccess->line = token->line;
+    parsedAccess->column = token->column;
+    parsedAccess->length = token->length;
     ParsedValueReturn parsedString = parse_string(token, false);
     if (parsedString.err.exists) {
       free_parsed(parsedValue);
@@ -42,6 +45,9 @@ ParsedValueReturn parse_access(char *file, DArray *tokens, size_t *index,
     free(parsedString.value);
     parsedAccess->access_fields = true;
   } else {
+    parsedAccess->line = first_token->line;
+    parsedAccess->column = first_token->column;
+    parsedAccess->length = first_token->length;
     parsedAccess->access_fields = false;
     Token *token = first_token;
     while (true) {

src/parser/assignable/access/access.h

@@ -13,6 +13,9 @@ typedef struct {
   ParsedValue to_access;
   bool access_fields;
   DArray access;
+  size_t line;
+  size_t column;
+  size_t length;
 } ParsedAccess;
 
 // Function declaration for parsing an identifier

src/parser/string/string.c

@@ -268,7 +268,8 @@ ParsedValueReturn parse_string(Token* token, bool to_unquote) {
                                  NULL};
     }
   } else {
-    parsedString->string = strdup(token->value);
+    parsedString->string = checked_malloc(token->length);
+    memcpy(parsedString->string, token->value, token->length);
     parsedString->length = token->length;
   }
   return (ParsedValueReturn){no_err,parsedValue};

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 *get_field_for_class_l(ArgonObject *target, char *name,
-                                 ArgonObject *binding_object) {
+                                   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 = get_field_l(target, name, length, false, false);
-    ArgonObject *object = hashmap_lookup_GC(target->dict, hash);
-
     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 = get_field_l(target, field, field_size, false, false);
-    target = hashmap_lookup_GC(target->dict, hash);
   }
   return NULL;
 }
 
-ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
+ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
-                       bool disable_method_wrapper) {
+                         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)),
+                        siphash64_bytes(field, field_size, siphash_key)),
-      name, binding);
+      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;
+    ArgonObject* args[] = {ARGON_BOOL_TYPE, state->registers[0]};
-    break;
+    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);

src/translator/access/access.c

@@ -0,0 +1,32 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+#include "access.h"
+
+size_t translate_access(Translated *translated, ParsedAccess *access,
+                        ArErr *err) {
+  set_registers(translated, 1);
+  uint64_t first = push_instruction_byte(translated, OP_LOAD_ACCESS_FUNCTION);
+  push_instruction_byte(translated, OP_INIT_CALL);
+  push_instruction_code(translated, 3);
+
+  translate_parsed(translated, &access->to_access, err);
+  push_instruction_byte(translated, OP_INSERT_ARG);
+  push_instruction_code(translated, 0);
+  translate_parsed(translated, darray_get(&access->access, 0), err);
+  push_instruction_byte(translated, OP_INSERT_ARG);
+  push_instruction_code(translated, 1);
+  
+  push_instruction_byte(translated, OP_LOAD_BOOL);
+  push_instruction_byte(translated, access->access_fields);
+  push_instruction_byte(translated, OP_INSERT_ARG);
+  push_instruction_code(translated, 2);
+  push_instruction_byte(translated, OP_SOURCE_LOCATION);
+  push_instruction_code(translated, access->line);
+  push_instruction_code(translated, access->column);
+  push_instruction_code(translated, access->length);
+  push_instruction_byte(translated, OP_CALL);
+  return first;
+}

src/translator/access/access.h

@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#ifndef translator_access_H
+#define translator_access_H
+#include "../../parser/assignable/access/access.h"
+#include "../translator.h"
+
+size_t translate_access(Translated *translated, ParsedAccess *access,
+                        ArErr *err);
+
+#endif // translator_access_H

src/translator/bytecode_spec.md

@@ -109,6 +109,16 @@ sets the source location onto the runtime
 4. the column
 5. the length
 
+## OP_LOAD_ACCESS_FUNCTION
+
+loads the access function into register 1
+
+## OP_LOAD_BOOL
+
+loads a boolean into register 1
+
+1. byte representing true or false (1 or 0) *
+
 ## OP_SWAP_REGISTERS
 
 swap the contents in two registers

src/translator/translator.c

@@ -15,6 +15,7 @@
 #include "number/number.h"
 #include "string/string.h"
 #include "return/return.h"
+#include "access/access.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -146,6 +147,8 @@ size_t translate_parsed(Translated *translated, ParsedValue *parsedValue, ArErr*
     return translate_parsed_return(translated, (ParsedReturn *)parsedValue->data, err);
   case AST_CALL:
     return translate_parsed_call(translated, (ParsedCall*)parsedValue->data, err);
+  case AST_ACCESS:
+    return translate_access(translated,(ParsedAccess*)parsedValue->data, err);
   }
   return 0;
 }

src/translator/translator.h

@@ -8,13 +8,30 @@
 #define TRANSLATOR_H
 
 #include "../dynamic_array/darray.h"
+#include "../hashmap/hashmap.h"
 #include "../memory.h"
 #include "../parser/parser.h"
-#include "../hashmap/hashmap.h"
 #include <stddef.h>
 #include <stdint.h>
 
-typedef enum { OP_LOAD_CONST, OP_DECLARE, OP_LOAD_NULL, OP_LOAD_FUNCTION, OP_IDENTIFIER, OP_BOOL, OP_JUMP_IF_FALSE, OP_JUMP, OP_NEW_SCOPE, OP_POP_SCOPE, OP_INIT_CALL, OP_INSERT_ARG, OP_CALL, OP_SOURCE_LOCATION } OperationType;
+typedef enum {
+  OP_LOAD_CONST,
+  OP_DECLARE,
+  OP_LOAD_NULL,
+  OP_LOAD_FUNCTION,
+  OP_IDENTIFIER,
+  OP_BOOL,
+  OP_JUMP_IF_FALSE,
+  OP_JUMP,
+  OP_NEW_SCOPE,
+  OP_POP_SCOPE,
+  OP_INIT_CALL,
+  OP_INSERT_ARG,
+  OP_CALL,
+  OP_SOURCE_LOCATION,
+  OP_LOAD_ACCESS_FUNCTION,
+  OP_LOAD_BOOL
+} OperationType;
 typedef enum { TYPE_OP_STRING, TYPE_OP_NUMBER } types;
 
 void arena_resize(ConstantArena *arena, size_t new_size);
@@ -33,9 +50,10 @@ void set_instruction_code(Translated *translator, size_t index, uint64_t code);
 
 void set_registers(Translated *translator, uint8_t count);
 
-Translated init_translator(char* path);
+Translated init_translator(char *path);
 
-size_t translate_parsed(Translated *translated, ParsedValue *parsedValue, ArErr*err);
+size_t translate_parsed(Translated *translated, ParsedValue *parsedValue,
+                        ArErr *err);
 
 ArErr translate(Translated *translated, DArray *ast);