start adding set attribute support

src/arobject.h

@@ -16,7 +16,11 @@ typedef enum {
   __base__,
   __class__,
   __name__,
+  __binding__,
+  __function__,
+
   BUILT_IN_ARRAY_COUNT,
+
   __add__,
   __string__,
   __subtract__,
@@ -26,14 +30,13 @@ typedef enum {
   __init__,
   __boolean__,
   __get_attr__,
-  __binding__,
-  __function__,
   field__address,
   __call__,
   __number__,
   field_log,
   field_length,
   __getattribute__,
+  __setattr__,
   __hash__,
   __repr__,
 
@@ -121,8 +124,8 @@ struct ArgonObject {
   struct built_in_slot built_in_slot[BUILT_IN_ARRAY_COUNT];
   union {
     struct as_number *as_number;
-    struct hashmap_GC* as_hashmap;
+    struct hashmap_GC *as_hashmap;
-    struct string_struct* as_str;
+    struct string_struct *as_str;
     native_fn native_fn;
     struct argon_function_struct *argon_fn;
   } value;

src/parser/assignable/access/access.c

@@ -18,13 +18,11 @@ ParsedValueReturn parse_access(char *file, DArray *tokens, size_t *index,
   Token *first_token = darray_get(tokens, *index);
   (*index)++;
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
+  if (first_token->type == TOKEN_DOT) {
     ParsedAccess *parsedAccess = checked_malloc(sizeof(ParsedAccess));
-  parsedAccess->to_access = *to_access;
+    parsedAccess->to_access = to_access;
     parsedValue->type = AST_ACCESS;
     parsedValue->data = parsedAccess;
-  free(to_access);
-  darray_init(&parsedAccess->access, sizeof(ParsedValue));
-  if (first_token->type == TOKEN_DOT) {
     ArErr err = error_if_finished(file, tokens, index);
     if (err.exists) {
       free_parsed(parsedValue);
@@ -41,59 +39,7 @@ ParsedValueReturn parse_access(char *file, DArray *tokens, size_t *index,
       free(parsedValue);
       return parsedString;
     }
-    darray_push(&parsedAccess->access, parsedString.value);
+    parsedAccess->access = parsedString.value;
-    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) {
-      skip_newlines_and_indents(tokens, index);
-      ArErr err = error_if_finished(file, tokens, index);
-      if (err.exists) {
-        free_parsed(parsedValue);
-        free(parsedValue);
-        return (ParsedValueReturn){err, NULL};
-      }
-      ParsedValueReturn parsedAccessValue =
-          parse_token(file, tokens, index, true);
-      if (parsedAccessValue.err.exists) {
-        free_parsed(parsedValue);
-        free(parsedValue);
-        return parsedAccessValue;
-      } else if (!parsedAccessValue.value) {
-        free_parsed(parsedValue);
-        free(parsedValue);
-        return (ParsedValueReturn){create_err(token->line, token->column,
-                                              token->length, file,
-                                              "Syntax Error", "expected value"),
-                                   NULL};
-      }
-      darray_push(&parsedAccess->access, parsedAccessValue.value);
-      free(parsedAccessValue.value);
-      skip_newlines_and_indents(tokens, index);
-      err = error_if_finished(file, tokens, index);
-      if (err.exists) {
-        free_parsed(parsedValue);
-        free(parsedValue);
-        return (ParsedValueReturn){err, NULL};
-      }
-      token = darray_get(tokens, *index);
-      if (token->type == TOKEN_RBRACKET) {
-        break;
-      } else if (token->type != TOKEN_COLON) {
-        free_parsed(parsedValue);
-        free(parsedValue);
-        return (ParsedValueReturn){create_err(token->line, token->column,
-                                              token->length, file,
-                                              "Syntax Error", "expected colon"),
-                                   NULL};
-      }
-      (*index)++;
-    }
   }
   (*index)++;
   return (ParsedValueReturn){no_err, parsedValue};
@@ -102,7 +48,9 @@ ParsedValueReturn parse_access(char *file, DArray *tokens, size_t *index,
 void free_parse_access(void *ptr) {
   ParsedValue *parsedValue = ptr;
   ParsedAccess *parsedAccess = parsedValue->data;
-  free_parsed(&parsedAccess->to_access);
+  free_parsed(parsedAccess->to_access);
-  darray_free(&parsedAccess->access, free_parsed);
+  free(parsedAccess->to_access);
+  free_parsed(parsedAccess->access);
+  free(parsedAccess->access);
   free(parsedAccess);
 }

src/parser/assignable/access/access.h

@@ -10,9 +10,8 @@
 #include "../../../lexer/token.h"  // for Token
 
 typedef struct {
-  ParsedValue to_access;
+  ParsedValue *to_access;
-  bool access_fields;
+  ParsedValue *access;
-  DArray access;
   size_t line;
   size_t column;
   size_t length;

src/runtime/objects/object.c

@@ -52,6 +52,7 @@ const char *built_in_field_names[BUILT_IN_FIELDS_COUNT] = {
     "log",
     "length",
     "__getattribute__",
+    "__setattr__",
     "__hash__",
     "__repr__"};
 

src/runtime/runtime.c

@@ -46,15 +46,14 @@ ArgonObject *FLOORDIVISION_FUNCTION;
 ArgonObject *BASE_CLASS___getattribute__(size_t argc, ArgonObject **argv,
                                          ArErr *err, RuntimeState *state) {
   (void)state;
-  if (argc != 3) {
+  if (argc != 2) {
-    *err = create_err(0, 0, 0, "", "Runtime Error",
+    *err =
-                      "__getattribute__ expects 3 arguments, got %" PRIu64);
+        create_err(0, 0, 0, "", "Runtime Error",
+                   "__getattribute__ expects 2 arguments, got %" PRIu64, argc);
     return ARGON_NULL;
   }
   ArgonObject *to_access = argv[0];
-  bool check_field = argv[1] == ARGON_TRUE;
+  ArgonObject *access = argv[1];
-  if (check_field) {
-    ArgonObject *access = argv[2];
   uint64_t hash;
   if (access->value.as_str->hash_computed) {
     hash = access->value.as_str->hash;
@@ -65,8 +64,7 @@ ArgonObject *BASE_CLASS___getattribute__(size_t argc, ArgonObject **argv,
     access->value.as_str->hash = hash;
     access->value.as_str->hash_computed = true;
   }
-    ArgonObject *value =
+  ArgonObject *value = get_field_l(to_access, access->value.as_str->data, hash,
-        get_field_l(to_access, access->value.as_str->data, hash,
                                    access->value.as_str->length, true, false);
   if (value)
     return value;
@@ -86,7 +84,6 @@ ArgonObject *BASE_CLASS___getattribute__(size_t argc, ArgonObject **argv,
       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;
 }
 
@@ -310,9 +307,8 @@ ArgonObject *BASE_CLASS___string__(size_t argc, ArgonObject **argv, ArErr *err,
   return new_string_object_null_terminated(buffer);
 }
 
-
+ArgonObject *BASE_CLASS___repr__(size_t argc, ArgonObject **argv, ArErr *err,
-ArgonObject *BASE_CLASS___repr__(size_t argc, ArgonObject **argv,
+                                 RuntimeState *state) {
-                                          ArErr *err, RuntimeState *state) {
   if (argc != 1) {
     *err = create_err(0, 0, 0, "", "Runtime Error",
                       "__repr__ expects 1 arguments, got %" PRIu64, argc);
@@ -453,8 +449,9 @@ ArgonObject *ARGON_STRING_TYPE___repr__(size_t argc, ArgonObject **argv,
     *err = create_err(0, 0, 0, "", "Runtime Error",
                       "__repr__ expects 1 arguments, got %" PRIu64, argc);
   }
-  char* quoted = c_quote_string(argv[0]->value.as_str->data,argv[0]->value.as_str->length);
+  char *quoted = c_quote_string(argv[0]->value.as_str->data,
-  ArgonObject* result = new_string_object_null_terminated(quoted);
+                                argv[0]->value.as_str->length);
+  ArgonObject *result = new_string_object_null_terminated(quoted);
   free(quoted);
   return result;
 }
@@ -810,10 +807,11 @@ void runtime(Translated _translated, RuntimeState _state, Stack *stack,
       [OP_COPY_TO_REGISTER] = &&DO_COPY_TO_REGISTER,
       [OP_ADDITION] = &&DO_ADDITION,
       [OP_SUBTRACTION] = &&DO_SUBTRACTION,
-      [OP_LOAD_GETATTRIBUTE_FUNCTION] = &&DO_LOAD_GETATTRIBUTE_FUNCTION,
+      [OP_LOAD_GETATTRIBUTE_METHOD] = &&DO_LOAD_GETATTRIBUTE_METHOD,
       [OP_MULTIPLICATION] = &&DO_MULTIPLICATION,
       [OP_DIVISION] = &&DO_DIVISION,
-      [OP_NOT] = &&DO_NOT};
+      [OP_NOT] = &&DO_NOT,
+      [OP_LOAD_SETATTR_METHOD] = &&DO_LOAD_SETATTR_METHOD};
   _state.head = 0;
 
   StackFrame *currentStackFrame = ar_alloc(sizeof(StackFrame));
@@ -917,7 +915,7 @@ void runtime(Translated _translated, RuntimeState _state, Stack *stack,
       state->registers[0] =
           pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE;
       continue;
-    DO_LOAD_GETATTRIBUTE_FUNCTION:
+    DO_LOAD_GETATTRIBUTE_METHOD:
       state->registers[0] = get_builtin_field_for_class(
           get_builtin_field(state->registers[0], __class__), __getattribute__,
           state->registers[0]);
@@ -1177,6 +1175,18 @@ void runtime(Translated _translated, RuntimeState _state, Stack *stack,
           ARGON_DIVISION_FUNCTION(2, args, err, state);
       continue;
     }
+    DO_LOAD_SETATTR_METHOD: {
+      state->registers[0] = get_builtin_field_for_class(
+          get_builtin_field(state->registers[0], __class__), __setattr__,
+          state->registers[0]);
+      if (!state->registers[0]) {
+        *err = create_err(
+            state->source_location.line, state->source_location.column,
+            state->source_location.length, state->path, "Runtime Error",
+            "unable to get __setattr__ from objects class");
+      }
+      continue;
+    }
     }
 
     ArgonObject *result = currentStackFrame->state.registers[0];

src/translator/access/access.c

@@ -8,25 +8,19 @@
 size_t translate_access(Translated *translated, ParsedAccess *access,
                         ArErr *err) {
   set_registers(translated, 1);
-  uint64_t first = translate_parsed(translated, &access->to_access, err);
+  uint64_t first = translate_parsed(translated, access->to_access, err);
   if (err->exists)
     return 0;
-  push_instruction_byte(translated, OP_LOAD_GETATTRIBUTE_FUNCTION);
+  push_instruction_byte(translated, OP_LOAD_GETATTRIBUTE_METHOD);
   push_instruction_byte(translated, OP_INIT_CALL);
-  push_instruction_code(translated, access->access.size+1);
+  push_instruction_code(translated, 1);
-  push_instruction_byte(translated, OP_LOAD_BOOL);
+
-  push_instruction_byte(translated, access->access_fields);
+  translate_parsed(translated, access->access, err);
+  if (err->exists)
+    return 0;
   push_instruction_byte(translated, OP_INSERT_ARG);
   push_instruction_code(translated, 0);
 
-  for (size_t i = 0; i < access->access.size; i++) {
-    translate_parsed(translated, darray_get(&access->access, i), err);
-    if (err->exists)
-      return 0;
-    push_instruction_byte(translated, OP_INSERT_ARG);
-    push_instruction_code(translated, 1 + i);
-  }
-
   push_instruction_byte(translated, OP_SOURCE_LOCATION);
   push_instruction_code(translated, access->line);
   push_instruction_code(translated, access->column);

src/translator/assignment/assignment.c

@@ -7,6 +7,7 @@
 #include "assignment.h"
 #include "../../hash_data/hash_data.h"
 #include "../../parser/assignable/identifier/identifier.h"
+#include "../../parser/assignable/access/access.h"
 #include "../translator.h"
 #include <stddef.h>
 #include <stdio.h>
@@ -41,6 +42,9 @@ size_t translate_parsed_assignment(Translated *translated,
                                           siphash_key_fixed_for_translator));
     push_instruction_byte(translated, 0);
     break;
+  case AST_ACCESS:;
+    ParsedAccess *access = assignment->to->data;
+    break;
   default:
     fprintf(stderr, "panic: unsupported assignment\n");
     exit(EXIT_FAILURE);

src/translator/bytecode_spec.md

@@ -120,9 +120,9 @@ sets the source location onto the runtime
 1. the column
 1. the length
 
-## OP_LOAD_GETATTRIBUTE_FUNCTION
+## OP_LOAD_GETATTRIBUTE_METHOD
 
-loads the \_\_getattribute\_\_ function from the objects class in register 1 and put it into register 1
+loads the \_\_getattribute\_\_ method from the objects class in register 1 and put it into register 1
 
 ## OP_LOAD_BOOL
 
@@ -184,3 +184,7 @@ performs an division between register A and register B, storing the result in re
 ## OP_NOT
 
 inverts the boolean value in register 0.
+
+## OP_LOAD_SETATTR_METHOD
+
+loads the \_\_setattr\_\_ method from the objects class in register 1 and put it into register 1

src/translator/translator.h

@@ -36,10 +36,11 @@ typedef enum {
   OP_COPY_TO_REGISTER,
   OP_ADDITION,
   OP_SUBTRACTION,
-  OP_LOAD_GETATTRIBUTE_FUNCTION,
+  OP_LOAD_GETATTRIBUTE_METHOD,
   OP_MULTIPLICATION,
   OP_DIVISION,
-  OP_NOT
+  OP_NOT,
+  OP_LOAD_SETATTR_METHOD
 } OperationType;
 
 void arena_resize(ConstantArena *arena, size_t new_size);

tests/iteration-test.py

@@ -1,4 +1,3 @@
 i = 1000000
 while i:
-  print(i)
   i=i-1