remove gmp-x86_64.h

.github/workflows/release.yml

@@ -10,11 +10,8 @@ on:
       - '*' # Any tag
 
 jobs:
-  build-linux:
+  build-linux-x86_64:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest # build both architectures
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]   # build both architectures
     steps:
       - uses: actions/checkout@v3
         with:
@@ -36,14 +33,8 @@ jobs:
 
       - name: Build
         run: |
-          if [ "${{ matrix.arch }}" = "x86_64" ]; then
+          conan install . --build=missing
-            conan install . --build=missing
+          conan build .
-            conan build .
-          else
-            sudo apt-get install -y aarch64-linux-gnu-gcc
-            conan install . --profile linux-arm-profile.txt --build=missing
-            conan build . --profile linux-arm-profile.txt
-          fi
 
       - name: Package
         run: |
@@ -60,7 +51,50 @@ jobs:
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
-          name: linux-${{ matrix.arch }}-artifact
+          name: linux-x86_64-artifact
+          path: ${{ env.TAR_NAME }}
+  build-linux-arm64:
+    runs-on: ubuntu-22.04-arm # build both architectures
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Install build tools
+        run: sudo apt-get update && sudo apt-get install -y flex bison
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+
+      - name: Install Conan
+        run: |
+          python -m pip install --upgrade pip
+          pip install conan
+          conan profile detect
+
+      - name: Build
+        run: |
+          conan install . --build=missing
+          conan build .
+
+      - name: Package
+        run: |
+          TAG=${GITHUB_REF##refs/tags/}
+          OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+          ARCH=$(uname -m)
+          FOLDER="chloride-$TAG-$OS-$ARCH"
+          TAR="$FOLDER.tar.gz"
+          mv build/bin "$FOLDER"
+          cp LICENSE.txt "$FOLDER"
+          tar -czf "$TAR" "$FOLDER"
+          echo "TAR_NAME=$TAR" >> $GITHUB_ENV
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-arm64-artifact
           path: ${{ env.TAR_NAME }}
 
   build-macos:
@@ -185,7 +219,7 @@ jobs:
 
   release:
     runs-on: ubuntu-latest
-    needs: [build-linux, build-macos, build-windows]
+    needs: [build-linux-x86_64, build-linux-arm64, build-macos, build-windows]
     steps:
       - name: Download artifacts
         uses: actions/download-artifact@v4

.gitmodules

@@ -11,3 +11,6 @@
 [submodule "external/libdye"]
 	path = external/libdye
 	url = https://github.com/Ugric/libdye.git
+[submodule "external/linenoise"]
+	path = external/linenoise
+	url = https://github.com/antirez/linenoise

CMakeLists.txt

@@ -33,8 +33,16 @@ add_custom_command(
 # Step 2: Custom target for lexer
 add_custom_target(GenerateLexer DEPENDS ${LEXER_C} ${LEXER_H})
 
+set(SOURCES
+    external/xxhash/xxhash.c external/cwalk/src/cwalk.c external/libdye/src/dye.c ${CFILES} ${LEXER_C}
+)
+
+if(NOT WIN32)
+    list(APPEND SOURCES external/linenoise/linenoise.c)
+endif()
+
 # Step 3: Add executable
-add_executable(argon external/xxhash/xxhash.c external/cwalk/src/cwalk.c external/libdye/src/dye.c ${CFILES} ${LEXER_C})
+add_executable(argon  ${SOURCES})
 set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
 target_include_directories(argon PRIVATE ${CMAKE_SOURCE_DIR}/external/cwalk/include)
 target_include_directories(argon PRIVATE ${CMAKE_SOURCE_DIR}/external/libdye/include)

Makefile

@@ -6,7 +6,7 @@
 BINARY = bin/argon
 FLEX_TOOL = flex
 
-CFILES = external/xxhash/xxhash.c external/cwalk/src/cwalk.c external/libdye/src/dye.c $(shell find src -name '*.c')
+CFILES = external/xxhash/xxhash.c external/cwalk/src/cwalk.c external/libdye/src/dye.c external/linenoise/linenoise.c $(shell find src -name '*.c')
 
 LEXER_SRC = src/lexer/lex.l
 LEXER_C = src/lexer/lex.yy.c

linux-arm-profile.txt

@@ -1,15 +0,0 @@
-[settings]
-os=Linux
-arch=armv8
-compiler=gcc
-compiler.version=12
-compiler.libcxx=libstdc++11
-build_type=Release
-
-[env]
-CC=aarch64-linux-gnu-gcc
-CXX=aarch64-linux-gnu-g++
-AR=aarch64-linux-gnu-ar
-RANLIB=aarch64-linux-gnu-ranlib
-LD=aarch64-linux-gnu-ld
-STRIP=aarch64-linux-gnu-strip

src/main.c

@@ -12,6 +12,7 @@
 #include "memory.h"
 #include "parser/parser.h"
 #include "returnTypes.h"
+#include "shell.h"
 #include "runtime/runtime.h"
 #include "translator/translator.h"
 
@@ -358,32 +359,29 @@ Translated load_argon_file(char *path, ArErr *err) {
 
     start = clock();
     *err = parser(path, &ast, &tokens, false);
+    darray_free(&tokens, free_token);
     if (err->exists) {
-      darray_free(&tokens, free_token);
       darray_free(&ast, free_parsed);
       return (Translated){};
     }
     end = clock();
     time_spent = (double)(end - start) / CLOCKS_PER_SEC;
     fprintf(stderr, "Parser time taken: %f seconds\n", time_spent);
-    darray_free(&tokens, free_token);
 
     start = clock();
 
     translated = init_translator(path);
     *err = translate(&translated, &ast);
+    darray_free(&ast, free_parsed);
     if (err->exists) {
       darray_free(&translated.bytecode, NULL);
       free(translated.constants.data);
       hashmap_free(translated.constants.hashmap, NULL);
-      darray_free(&ast, free_parsed);
       return (Translated){};
     }
     end = clock();
     time_spent = (double)(end - start) / CLOCKS_PER_SEC;
     fprintf(stderr, "Translation time taken: %f seconds\n", time_spent);
-
-    darray_free(&ast, free_parsed);
 #if defined(__linux__)
     malloc_trim(0);
 #endif
@@ -458,9 +456,9 @@ int main(int argc, char *argv[]) {
   generate_siphash_key(siphash_key);
   bootstrap_types();
   bootstrap_globals();
-  char *CWD = get_current_directory();
   if (argc <= 1)
-    return -1;
+    return shell();
+  char *CWD = get_current_directory();
   char *path_non_absolute = argv[1];
   char path[FILENAME_MAX];
   cwk_path_get_absolute(CWD, path_non_absolute, path, sizeof(path));

src/parser/number/number.c

@@ -8,7 +8,6 @@
 #include "../../memory.h"
 #include <ctype.h>
 #include <gmp.h>
-#include <gmp.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -180,7 +179,8 @@ ParsedValueReturn parse_number(Token *token, char *path) {
   mpq_init(*r_ptr);
   int err = mpq_set_decimal_str_exp(*r_ptr, token->value, token->length);
   if (err) {
-    free_parsed(parsedValue);
+    mpq_clear(*r_ptr);
+    free(r_ptr);
     free(parsedValue);
     return (ParsedValueReturn){create_err(token->line, token->column,
                                           token->length, path, "Parsing Error",
@@ -189,4 +189,5 @@ ParsedValueReturn parse_number(Token *token, char *path) {
   }
   parsedValue->data = r_ptr;
   return (ParsedValueReturn){no_err, parsedValue};
-}
+}
+

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[1] == ARGON_TRUE;
-  bool check_field = argv[2] == 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,6 +348,12 @@ 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) {

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

@@ -0,0 +1,273 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+#include "./lexer/lexer.h"
+#include "./runtime/call/call.h"
+#include "./runtime/objects/functions/functions.h"
+#include "./runtime/objects/term/term.h"
+#include "./runtime/runtime.h"
+#include "./translator/translator.h"
+#include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#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;
+  }
+
+  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;
+  printf("\nBye :)\n");
+  exit(0);
+}
+
+int execute_code(FILE *stream, char *path, Stack *scope,
+                 RuntimeState *runtime_state) {
+  if (!stream) {
+    perror("fmemopen");
+    return 1;
+  }
+
+  ArErr err;
+
+  DArray tokens;
+  darray_init(&tokens, sizeof(Token));
+  LexerState state = {path, stream, 0, 0, &tokens};
+  err = lexer(state);
+  if (err.exists) {
+    darray_free(&tokens, free_token);
+    output_err(err);
+    return 1;
+  }
+
+  DArray ast;
+
+  darray_init(&ast, sizeof(ParsedValue));
+
+  err = parser(path, &ast, &tokens, false);
+  darray_free(&tokens, free_token);
+  if (err.exists) {
+    darray_free(&ast, free_parsed);
+    output_err(err);
+    return 1;
+  }
+  Translated __translated = init_translator(path);
+  err = translate(&__translated, &ast);
+  darray_free(&ast, free_parsed);
+  if (err.exists) {
+    darray_free(&__translated.bytecode, NULL);
+    free(__translated.constants.data);
+    hashmap_free(__translated.constants.hashmap, NULL);
+    output_err(err);
+    return 1;
+  }
+
+  hashmap_free(__translated.constants.hashmap, NULL);
+  Translated translated = {
+      __translated.registerCount, NULL, {}, {}, __translated.path};
+  translated.bytecode.data = ar_alloc(__translated.bytecode.capacity);
+  memcpy(translated.bytecode.data, __translated.bytecode.data,
+         __translated.bytecode.capacity);
+  translated.bytecode.element_size = __translated.bytecode.element_size;
+  translated.bytecode.size = __translated.bytecode.size;
+  translated.bytecode.resizable = false;
+  translated.bytecode.capacity =
+      __translated.bytecode.size * __translated.bytecode.element_size;
+  translated.constants.data = ar_alloc(__translated.constants.capacity);
+  memcpy(translated.constants.data, __translated.constants.data,
+         __translated.constants.capacity);
+  translated.constants.size = __translated.constants.size;
+  translated.constants.capacity = __translated.constants.capacity;
+  darray_free(&__translated.bytecode, NULL);
+  free(__translated.constants.data);
+  *runtime_state = init_runtime_state(translated, path);
+  err = runtime(translated, *runtime_state, scope);
+  if (err.exists) {
+    output_err(err);
+    return 1;
+  }
+  return 0;
+}
+
+// Simple input function
+char *input(const char *prompt) {
+#if defined(_WIN32) || defined(_WIN64)
+  printf("%s", prompt);
+  fflush(stdout);
+
+  char *buffer = NULL;
+  size_t size = 0;
+  ssize_t len = getline(&buffer, &size, stdin);
+
+  if (len == -1) {
+    free(buffer);
+    return NULL;
+  }
+
+  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;
+}
+
+char *read_all_stdin(size_t *out_len) {
+  size_t size = 1024;
+  size_t len = 0;
+  char *buffer = malloc(size);
+  if (!buffer)
+    exit(1);
+
+  int c;
+  while ((c = fgetc(stdin)) != EOF) {
+    if (len + 1 >= size) {
+      size *= 2;
+      buffer = realloc(buffer, size);
+      if (!buffer)
+        exit(1);
+    }
+    buffer[len++] = (char)c;
+  }
+
+  *out_len = len;
+  return buffer;
+}
+
+int shell() {
+
+  Stack *main_scope = create_scope(Global_Scope);
+
+  if (!isatty(STDIN_FILENO)) {
+    RuntimeState runtime_state;
+    size_t len;
+    char *data = read_all_stdin(&len);
+    FILE *file = fmemopen(data, len, "r");
+    int resp = execute_code(file, "<stdin>", main_scope, &runtime_state);
+    fclose(file);
+    free(data);
+    return resp;
+  }
+
+  signal(SIGINT, handle_sigint);
+
+  printf("Welcome to the Argon shell!\n\n");
+
+  ArgonObject *output_object = create_argon_native_function("log", term_log);
+  char *totranslate = NULL;
+  size_t totranslatelength = 0;
+
+  while (true) {
+#if defined(__linux__)
+    malloc_trim(0);
+#endif
+    if (totranslate) {
+      free(totranslate);
+      totranslate = NULL;
+      totranslatelength = 0;
+    };
+    int indent = 0;
+    char textBefore[] = ">>> ";
+
+    // Dynamic array of lines
+
+    do {
+      // indent string
+      size_t isz = (size_t)indent * 4;
+      char *indentStr = (char *)malloc(isz + 1);
+      if (!indentStr)
+        exit(1);
+      memset(indentStr, ' ', isz);
+      indentStr[isz] = '\0';
+
+      // prompt
+      size_t p_len = strlen(textBefore) + isz;
+      char *prompt = (char *)malloc(p_len + 1);
+      if (!prompt)
+        exit(1);
+      memcpy(prompt, textBefore, strlen(textBefore));
+      memcpy(prompt + strlen(textBefore), indentStr, isz + 1);
+
+      char *inp = input(prompt);
+      free(prompt);
+
+      if (!inp) {
+        printf("\nBye :)\n");
+        // Free previously collected lines
+        free(inp);
+        free(totranslate);
+        free(indentStr);
+        return 0;
+      }
+
+      // Append line to totranslate
+      size_t length = strlen(inp);
+      totranslate = realloc(totranslate, totranslatelength + isz + length + 1);
+      memcpy(totranslate + totranslatelength, indentStr, isz);
+      memcpy(totranslate + totranslatelength + isz, inp, length);
+      totranslatelength += isz + length + 1;
+      totranslate[totranslatelength - 1] = '\n';
+
+      char *trimmed = inp;
+      while (*trimmed == ' ' || *trimmed == '\t')
+        trimmed++;
+
+      size_t len = strlen(trimmed);
+      if (len >= 2 && strcmp(trimmed + len - 2, "do") == 0) {
+        indent++;
+      } else if (len == 0 && indent > 0) {
+        indent--;
+      }
+      free(inp);
+      strcpy(textBefore, "... ");
+      free(indentStr);
+
+    } while (indent > 0);
+    totranslate = realloc(totranslate, totranslatelength + 1);
+    totranslate[totranslatelength] = '\0';
+    RuntimeState runtime_state;
+    FILE *file = fmemopen((void *)totranslate, totranslatelength, "r");
+    int resp = execute_code(file, "<shell>", main_scope, &runtime_state);
+    fclose(file);
+    if (resp) {
+      continue;
+    }
+    ArErr err;
+    argon_call(output_object, 1, (ArgonObject *[]){runtime_state.registers[0]},
+               &err, &runtime_state);
+    totranslatelength = 0;
+  }
+
+  return 0;
+}

src/shell.h

@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#ifndef ARGON_SHELL_H
+#define ARGON_SHELL_H
+
+int shell();
+
+#endif // ARGON_SHELL_H

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);