add anonymous functions

src/main.c

@@ -428,7 +428,7 @@ Translated load_argon_file(char *path, ArErr *err) {
   hashmap_free(translated.constants.hashmap, NULL);
   Translated gc_translated = {
       translated.registerCount, NULL, {}, {}, translated.path};
-  gc_translated.bytecode.data = ar_alloc(translated.bytecode.capacity);
+  gc_translated.bytecode.data = ar_alloc_atomic(translated.bytecode.capacity);
   memcpy(gc_translated.bytecode.data, translated.bytecode.data,
          translated.bytecode.capacity);
   gc_translated.bytecode.element_size = translated.bytecode.element_size;
@@ -436,7 +436,7 @@ Translated load_argon_file(char *path, ArErr *err) {
   gc_translated.bytecode.resizable = false;
   gc_translated.bytecode.capacity =
       translated.bytecode.size * translated.bytecode.element_size;
-  gc_translated.constants.data = ar_alloc(translated.constants.capacity);
+  gc_translated.constants.data = ar_alloc_atomic(translated.constants.capacity);
   memcpy(gc_translated.constants.data, translated.constants.data,
          translated.constants.capacity);
   gc_translated.constants.size = translated.constants.size;

src/parser/parentheses-and-anonymous-function/parentheses-and-anonymous-function.c

@@ -0,0 +1,96 @@
+#include "parentheses-and-anonymous-function.h"
+#include "../assignable/identifier/identifier.h"
+#include "../function/function.h"
+#include "../../memory.h"
+#include <stddef.h>
+#include <string.h>
+
+ParsedValueReturn parse_parentheses(char *file, DArray *tokens, size_t *index) {
+  (*index)++;
+  skip_newlines_and_indents(tokens, index);
+  ArErr err = error_if_finished(file, tokens, index);
+  if (err.exists) {
+    // darray_free(&list, free_parsed);
+    return (ParsedValueReturn){err, NULL};
+  }
+  DArray list;
+  darray_init(&list, sizeof(ParsedValue));
+  Token *token = darray_get(tokens, *index);
+  if (token->type != TOKEN_RPAREN) {
+    while (*index < tokens->size) {
+      ParsedValueReturn parsedItem = parse_token(file, tokens, index, true);
+      if (parsedItem.err.exists) {
+        darray_free(&list, free_parsed);
+        return parsedItem;
+      }
+      darray_push(&list, parsedItem.value);
+      free(parsedItem.value);
+      skip_newlines_and_indents(tokens, index);
+      ArErr err = error_if_finished(file, tokens, index);
+      if (err.exists) {
+        darray_free(&list, free_parsed);
+        return (ParsedValueReturn){err, NULL};
+      }
+      token = darray_get(tokens, *index);
+      if (token->type == TOKEN_RPAREN) {
+        break;
+      } else if (token->type != TOKEN_COMMA) {
+        darray_free(&list, free_parsed);
+        return (ParsedValueReturn){create_err(token->line, token->column,
+                                              token->length, file,
+                                              "Syntax Error", "expected comma"),
+                                   NULL};
+      }
+      skip_newlines_and_indents(tokens, index);
+      err = error_if_finished(file, tokens, index);
+      if (err.exists) {
+        darray_free(&list, free_parsed);
+        return (ParsedValueReturn){err, NULL};
+      }
+    }
+  }
+  (*index)++;
+  if (*index < tokens->size) {
+    token = darray_get(tokens, *index);
+    if (token->type == TOKEN_ASSIGN) {
+      (*index)++;
+      ArErr err = error_if_finished(file, tokens, index);
+      if (err.exists) {
+        darray_free(&list, free_parsed);
+        return (ParsedValueReturn){err, NULL};
+      }
+      DArray parameters;
+      darray_init(&parameters, sizeof(char *));
+      for (size_t i = 0; i < list.size; i++) {
+        ParsedValue *item = darray_get(&list, i);
+        if (item->type != AST_IDENTIFIER) {
+          return (ParsedValueReturn){
+              create_err(token->line, token->column, token->length, file,
+                         "Syntax Error", "expected identifier"),
+              NULL};
+        }
+        char *param = strdup(((ParsedIdentifier *)item->data)->name);
+        darray_push(&parameters, &param);
+      }
+      darray_free(&list, free_parsed);
+      ParsedValueReturn parsedBody = parse_token(file, tokens, index, true);
+      if (parsedBody.err.exists) {
+        darray_free(&parameters, free_parameter);
+        return parsedBody;
+      }
+      return (ParsedValueReturn){
+          no_err,
+          create_parsed_function("anonymous", parameters, parsedBody.value)};
+    }
+  }
+  if (list.size != 1) {
+    return (ParsedValueReturn){create_err(token->line, token->column,
+                                          token->length, file, "Syntax Error",
+                                          "expected 1 body"),
+                               NULL};
+  }
+  ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
+  memcpy(parsedValue, darray_get(&list, 0), sizeof(ParsedValue));
+  darray_free(&list, NULL);
+  return (ParsedValueReturn){no_err, parsedValue};
+}

src/parser/parentheses-and-anonymous-function/parentheses-and-anonymous-function.h

@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#ifndef parentheses_and_anonymous_function_H
+#define parentheses_and_anonymous_function_H
+#include "../parser.h"
+#include "../../lexer/token.h"
+
+ParsedValueReturn parse_parentheses(char *file, DArray *tokens, size_t *index);
+
+#endif // parentheses_and_anonymous_function_H

src/parser/parser.c

@@ -13,6 +13,7 @@
 #include "assignable/identifier/identifier.h"
 #include "declaration/declaration.h"
 #include "dictionary/dictionary.h"
+#include "parentheses-and-anonymous-function/parentheses-and-anonymous-function.h"
 #include "dowrap/dowrap.h"
 #include "function/function.h"
 #include "if/if.h"
@@ -128,6 +129,9 @@ ParsedValueReturn parse_token_full(char *file, DArray *tokens, size_t *index,
   case TOKEN_LBRACKET:
     output = parse_list(file, tokens, index);
     break;
+  case TOKEN_LPAREN:
+    output = parse_parentheses(file, tokens, index);
+    break;
   case TOKEN_LBRACE:
     output = parse_dictionary(file, tokens, index);
     break;

src/runtime/access/access.c

@@ -15,19 +15,19 @@ ArgonObject *ARGON_TYPE_TYPE___get_attr__(size_t argc, ArgonObject **argv,
     return ARGON_NULL;
   }
   ArgonObject *to_access = argv[0];
-  ArgonObject *access = argv[1];
-  bool check_field = argv[2] == ARGON_TRUE;
+  bool check_field = argv[1] == ARGON_TRUE;
   if (check_field) {
+    ArgonObject *access = argv[2];
     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);
   }
-  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/objects/number/number.c

@@ -126,6 +126,56 @@ ArgonObject *ARGON_NUMBER_TYPE___subtract__(size_t argc, ArgonObject **argv,
   return result;
 }
 
+ArgonObject *ARGON_NUMBER_TYPE___multiply__(size_t argc, ArgonObject **argv,
+                                       ArErr *err, RuntimeState *state) {
+  (void)state;
+  if (argc != 2) {
+    *err = create_err(0, 0, 0, "", "Runtime Error",
+                      "__multiply__ expects 2 arguments, got %" PRIu64, argc);
+    return ARGON_NULL;
+  }
+  mpq_t r;
+  mpq_init(r);
+  if (argv[1]->type != TYPE_NUMBER) {
+    ArgonObject *type_name = get_field_for_class(
+        get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
+    *err = create_err(0, 0, 0, "", "Runtime Error",
+                      "__multiply__ cannot perform multiplication between number and %.*s",
+                      type_name->value.as_str.length,
+                      type_name->value.as_str.data);
+    return ARGON_NULL;
+  }
+  mpq_mul(r, *argv[0]->value.as_number, *argv[1]->value.as_number);
+  ArgonObject *result = new_number_object(r);
+  mpq_clear(r);
+  return result;
+}
+
+ArgonObject *ARGON_NUMBER_TYPE___division__(size_t argc, ArgonObject **argv,
+                                       ArErr *err, RuntimeState *state) {
+  (void)state;
+  if (argc != 2) {
+    *err = create_err(0, 0, 0, "", "Runtime Error",
+                      "__division__ expects 2 arguments, got %" PRIu64, argc);
+    return ARGON_NULL;
+  }
+  mpq_t r;
+  mpq_init(r);
+  if (argv[1]->type != TYPE_NUMBER) {
+    ArgonObject *type_name = get_field_for_class(
+        get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
+    *err = create_err(0, 0, 0, "", "Runtime Error",
+                      "__division__ cannot perform division between number and %.*s",
+                      type_name->value.as_str.length,
+                      type_name->value.as_str.data);
+    return ARGON_NULL;
+  }
+  mpq_div(r, *argv[0]->value.as_number, *argv[1]->value.as_number);
+  ArgonObject *result = new_number_object(r);
+  mpq_clear(r);
+  return result;
+}
+
 ArgonObject *ARGON_NUMBER_TYPE___string__(size_t argc, ArgonObject **argv,
                                           ArErr *err, RuntimeState *state) {
   (void)state;
@@ -298,12 +348,18 @@ void create_ARGON_NUMBER_TYPE() {
   add_field(ARGON_NUMBER_TYPE, "__subtract__",
             create_argon_native_function("__subtract__",
                                          ARGON_NUMBER_TYPE___subtract__));
+  add_field(ARGON_NUMBER_TYPE, "__multiply__",
+            create_argon_native_function("__multiply__",
+                                         ARGON_NUMBER_TYPE___multiply__));
+  add_field(ARGON_NUMBER_TYPE, "__division__",
+            create_argon_native_function("__division__",
+                                         ARGON_NUMBER_TYPE___division__));
 }
 
 void mpz_init_gc_managed(mpz_t z, size_t limbs_count) {
   z->_mp_alloc = limbs_count;
   z->_mp_size = 0;
-  z->_mp_d = ar_alloc(limbs_count * sizeof(mp_limb_t));
+  z->_mp_d = ar_alloc_atomic(limbs_count * sizeof(mp_limb_t));
 }
 
 void mpq_init_gc_managed(mpq_t q, size_t num_limbs, size_t den_limbs) {

src/runtime/runtime.c

@@ -37,10 +37,10 @@ ArgonObject *ACCESS_FUNCTION;
 ArgonObject *ADDITION_FUNCTION;
 ArgonObject *SUBTRACTION_FUNCTION;
 ArgonObject *MULTIPLY_FUNCTION;
-ArgonObject *DIVIDE_FUNCTION;
+ArgonObject *DIVISION_FUNCTION;
 ArgonObject *POWER_FUNCTION;
 ArgonObject *MODULO_FUNCTION;
-ArgonObject *FLOORDIV_FUNCTION;
+ArgonObject *FLOORDIVISION_FUNCTION;
 
 ArgonObject *ARGON_ADDITION_FUNCTION(size_t argc, ArgonObject **argv,
                                      ArErr *err, RuntimeState *state) {
@@ -70,7 +70,7 @@ ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv,
                                         ArErr *err, RuntimeState *state) {
   if (argc < 1) {
     *err = create_err(0, 0, 0, "", "Runtime Error",
-                      "add expects at least 1 argument, got %" PRIu64, argc);
+                      "subtract expects at least 1 argument, got %" PRIu64, argc);
     return ARGON_NULL;
   }
   ArgonObject *output = argv[0];
@@ -91,6 +91,56 @@ ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv,
   return output;
 }
 
+ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv,
+                                        ArErr *err, RuntimeState *state) {
+  if (argc < 1) {
+    *err = create_err(0, 0, 0, "", "Runtime Error",
+                      "multiply expects at least 1 argument, got %" PRIu64, argc);
+    return ARGON_NULL;
+  }
+  ArgonObject *output = argv[0];
+  for (size_t i = 1; i < argc; i++) {
+    ArgonObject *__multiply__ = get_field_for_class(
+        get_field(output, "__class__", false, false), "__multiply__", output);
+    if (!__multiply__) {
+      ArgonObject *cls___name__ = get_field(output, "__name__", true, false);
+      *err = create_err(0, 0, 0, "", "Runtime Error",
+                        "Object '%.*s' is missing __multiply__ method",
+                        (int)cls___name__->value.as_str.length,
+                        cls___name__->value.as_str.data);
+      return ARGON_NULL;
+    }
+    output =
+        argon_call(__multiply__, 1, (ArgonObject *[]){argv[i]}, err, state);
+  }
+  return output;
+}
+
+ArgonObject *ARGON_DIVISION_FUNCTION(size_t argc, ArgonObject **argv,
+                                        ArErr *err, RuntimeState *state) {
+  if (argc < 1) {
+    *err = create_err(0, 0, 0, "", "Runtime Error",
+                      "division expects at least 1 argument, got %" PRIu64, argc);
+    return ARGON_NULL;
+  }
+  ArgonObject *output = argv[0];
+  for (size_t i = 1; i < argc; i++) {
+    ArgonObject *__multiply__ = get_field_for_class(
+        get_field(output, "__class__", false, false), "__division__", output);
+    if (!__multiply__) {
+      ArgonObject *cls___name__ = get_field(output, "__name__", true, false);
+      *err = create_err(0, 0, 0, "", "Runtime Error",
+                        "Object '%.*s' is missing __division__ method",
+                        (int)cls___name__->value.as_str.length,
+                        cls___name__->value.as_str.data);
+      return ARGON_NULL;
+    }
+    output =
+        argon_call(__multiply__, 1, (ArgonObject *[]){argv[i]}, err, state);
+  }
+  return output;
+}
+
 ArgonObject *ARGON_TYPE_TYPE___call__(size_t argc, ArgonObject **argv,
                                       ArErr *err, RuntimeState *state) {
   (void)state;
@@ -509,6 +559,10 @@ void bootstrap_types() {
       create_argon_native_function("add", ARGON_ADDITION_FUNCTION);
   SUBTRACTION_FUNCTION =
       create_argon_native_function("subtract", ARGON_SUBTRACTION_FUNCTION);
+  MULTIPLY_FUNCTION =
+      create_argon_native_function("multiply", ARGON_MULTIPLY_FUNCTION);
+  DIVISION_FUNCTION =
+      create_argon_native_function("division", ARGON_DIVISION_FUNCTION);
   add_field(BASE_CLASS, "__get_attr__", ACCESS_FUNCTION);
 }
 
@@ -527,6 +581,8 @@ void bootstrap_globals() {
   add_to_scope(Global_Scope, "number", ARGON_NUMBER_TYPE);
   add_to_scope(Global_Scope, "add", ADDITION_FUNCTION);
   add_to_scope(Global_Scope, "subtract", SUBTRACTION_FUNCTION);
+  add_to_scope(Global_Scope, "multiply", MULTIPLY_FUNCTION);
+  add_to_scope(Global_Scope, "division", DIVISION_FUNCTION);
 
   ArgonObject *argon_term = new_object();
   add_field(argon_term, "__init__", ARGON_NULL);
@@ -722,6 +778,12 @@ ArErr run_instruction(Translated *translated, RuntimeState *state,
   case OP_LOAD_SUBTRACTION_FUNCTION:
     state->registers[0] = SUBTRACTION_FUNCTION;
     break;
+  case OP_LOAD_MULTIPLY_FUNCTION:
+    state->registers[0] = MULTIPLY_FUNCTION;
+    break;
+  case OP_LOAD_DIVISION_FUNCTION:
+    state->registers[0] = DIVISION_FUNCTION;
+    break;
   default:
     return create_err(0, 0, 0, NULL, "Runtime Error", "Invalid Opcode %#x",
                       opcode);

src/shell.c

@@ -3,10 +3,6 @@
  *
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
-#if defined(_WIN32) || defined(_WIN64)
-#else
-#include "../external/linenoise/linenoise.h"
-#endif
 #include "./lexer/lexer.h"
 #include "./runtime/call/call.h"
 #include "./runtime/objects/functions/functions.h"
@@ -22,13 +18,34 @@
 #if defined(__linux__)
 #include <malloc.h>
 #endif
+#if defined(_WIN32) || defined(_WIN64)
+FILE *fmemopen(void *buf, size_t size, const char *mode) {
+  if (strchr(mode, 'r') == NULL) {
+    return NULL;
+  }
 
-volatile sig_atomic_t interrupted = 0;
+  FILE *tmp = tmpfile();
+  if (!tmp)
+    return NULL;
+
+  if (fwrite(buf, 1, size, tmp) != size) {
+    fclose(tmp);
+    return NULL;
+  }
+
+  rewind(tmp);
+
+  return tmp;
+}
+#else
+#include "../external/linenoise/linenoise.h"
+#endif
 
 // Ctrl+C handler
 void handle_sigint(int sig) {
   (void)sig;
-  interrupted = 1;
+  printf("\nBye :)\n");
+  exit(0);
 }
 
 int execute_code(FILE *stream, char *path, Stack *scope,
@@ -99,9 +116,9 @@ int execute_code(FILE *stream, char *path, Stack *scope,
   return 0;
 }
 
-#if defined(_WIN32) || defined(_WIN64)
 // Simple input function
 char *input(const char *prompt) {
+#if defined(_WIN32) || defined(_WIN64)
   printf("%s", prompt);
   fflush(stdout);
 
@@ -114,14 +131,17 @@ char *input(const char *prompt) {
     return NULL;
   }
 
-  // Remove trailing newline
   if (len > 0 && buffer[len - 1] == '\n') {
     buffer[len - 1] = '\0';
   }
-
+#else
+  char *buffer = linenoise(prompt);
+  if (buffer && buffer[0] != '\0') {
+    linenoiseHistoryAdd(buffer);
+  }
+#endif
   return buffer;
 }
-#endif
 
 char *read_all_stdin(size_t *out_len) {
   size_t size = 1024;
@@ -199,11 +219,7 @@ int shell() {
       memcpy(prompt, textBefore, strlen(textBefore));
       memcpy(prompt + strlen(textBefore), indentStr, isz + 1);
 
-#if defined(_WIN32) || defined(_WIN64)
       char *inp = input(prompt);
-#else
-      char *inp = linenoise(prompt);
-#endif
       free(prompt);
 
       if (!inp) {
@@ -214,13 +230,6 @@ int shell() {
         free(indentStr);
         return 0;
       }
-#if defined(_WIN32) || defined(_WIN64)
-#else
-      if (inp[0] != '\0') {
-        // Optionally add line to history
-        linenoiseHistoryAdd(inp);
-      }
-#endif
 
       // Append line to totranslate
       size_t length = strlen(inp);

src/translator/access/access.c

@@ -10,19 +10,22 @@ size_t translate_access(Translated *translated, ParsedAccess *access,
   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);
+  push_instruction_code(translated, access->access.size + 2);
 
   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_code(translated, 1);
+
+  for (size_t i = 0; i < access->access.size; i++) {
+    translate_parsed(translated, darray_get(&access->access, i), err);
+    push_instruction_byte(translated, OP_INSERT_ARG);
+    push_instruction_code(translated, 2+i);
+  }
+
   push_instruction_byte(translated, OP_SOURCE_LOCATION);
   push_instruction_code(translated, access->line);
   push_instruction_code(translated, access->column);

src/translator/bytecode_spec.md

@@ -135,4 +135,12 @@ loads the addition function into register 1
 
 ## OP_LOAD_SUBTRACTION_FUNCTION
 
-loads the subtraction function into register 1
+loads the subtraction function into register 1
+
+## OP_LOAD_MULTIPLY_FUNCTION
+
+loads the multiply function into register 1
+
+## OP_LOAD_DIVISION_FUNCTION
+
+loads the division function into register 1

src/translator/operation/operation.c

@@ -18,6 +18,12 @@ size_t translate_operation(Translated *translated, ParsedOperation *operation,
   case TOKEN_MINUS:
     first = push_instruction_byte(translated, OP_LOAD_SUBTRACTION_FUNCTION);
     break;
+  case TOKEN_STAR:
+    first = push_instruction_byte(translated, OP_LOAD_MULTIPLY_FUNCTION);
+    break;
+  case TOKEN_SLASH:
+    first = push_instruction_byte(translated, OP_LOAD_DIVISION_FUNCTION);
+    break;
   default:
     *err = create_err(operation->line, operation->column, operation->length,
                       translated->path, "Syntax Error", "unknown operation");

src/translator/translator.h

@@ -33,7 +33,9 @@ typedef enum {
   OP_LOAD_BOOL,
   OP_LOAD_NUMBER,
   OP_LOAD_ADDITION_FUNCTION,
-  OP_LOAD_SUBTRACTION_FUNCTION
+  OP_LOAD_SUBTRACTION_FUNCTION,
+  OP_LOAD_MULTIPLY_FUNCTION,
+  OP_LOAD_DIVISION_FUNCTION
 } OperationType;
 
 void arena_resize(ConstantArena *arena, size_t new_size);

testing.ar

@@ -5,11 +5,33 @@ let say_hi(name) = do
     do
         return name
     )
-    return "hello "+u+", how are you?"
 
-term.log(say_hi("william"))
+    return "hello "+u+", how are you?"
+term.log(say_hi("william")
+, say_hi)
 
 let a = 9
 let b = 10
+term.log(string(a)+'+'+string(b)+'='+string(a+b))
 
-term.log(string(a)+'+'+string(b)+'='+string(a+b))
+
+let call(f) = do
+    term.log(f)
+
+    return f()
+
+
+term.log(
+call(
+()=call(
+()=call(
+()=call(
+()=do
+    term.log("hello this is a test of anonymous functions. hopefully this works :)")
+
+    return say_hi("test")
+)
+)
+)
+)
+)