fix for winblows

.github/workflows/release.yml

@@ -10,8 +10,8 @@ on:
       - '*' # Any tag
 
 jobs:
-  build-linux:
+  build-linux-x86_64:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest # build both architectures
     steps:
       - uses: actions/checkout@v3
         with:
@@ -51,18 +51,17 @@ jobs:
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
-          name: linux-artifact
+          name: linux-x86_64-artifact
           path: ${{ env.TAR_NAME }}
-
+  build-linux-arm64:
-  build-macos:
+    runs-on: ubuntu-22.04-arm # build both architectures
-    runs-on: macos-latest
     steps:
       - uses: actions/checkout@v3
         with:
           submodules: recursive
 
       - name: Install build tools
-        run: brew install flex bison
+        run: sudo apt-get update && sudo apt-get install -y flex bison
 
       - name: Setup Python
         uses: actions/setup-python@v4
@@ -95,7 +94,74 @@ jobs:
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
-          name: macos-artifact
+          name: linux-arm64-artifact
+          path: ${{ env.TAR_NAME }}
+
+  build-macos:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        arch: [x86_64, arm64]   # build both architectures
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Install build tools
+        run: brew install 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
+          if [ "${{ matrix.arch }}" = "x86_64" ] && [ "$(uname -m)" = "arm64" ]; then
+            arch -x86_64 conan profile detect
+          else
+            conan profile detect
+          fi
+
+      - name: Build
+        run: |
+          BUILD_DIR="build_${{ matrix.arch }}"
+          mkdir -p "$BUILD_DIR"
+          cd "$BUILD_DIR"
+
+          # Use Rosetta for x86_64 builds on Apple Silicon
+          if [ "${{ matrix.arch }}" = "x86_64" ] && [ "$(uname -m)" = "arm64" ]; then
+            arch -x86_64 bash -c "
+              export CMAKE_OSX_ARCHITECTURES=x86_64
+              conan install .. --build=missing
+              conan build ..
+            "
+          else
+            export CMAKE_OSX_ARCHITECTURES="${{ matrix.arch }}"
+            conan install .. --build=missing
+            conan build ..
+          fi
+
+          cd ..
+
+      - name: Package
+        run: |
+          TAG=${GITHUB_REF##refs/tags/}
+          OS="macos"
+          ARCH="${{ matrix.arch }}"
+          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: macos-${{ matrix.arch }}-artifact
           path: ${{ env.TAR_NAME }}
 
   build-windows:
@@ -130,20 +196,20 @@ jobs:
 
       - name: Build Project
         run: |
-          conan install . --profile mingw-profile.txt --build=missing
+          conan install . --profile windows-profile.txt --build=missing
-          conan build .
+          conan build . --profile windows-profile.txt
 
       - name: Package
         run: |
-          $TAG = $env:GITHUB_REF -replace 'refs/tags/', ''
+          TAG=${GITHUB_REF##refs/tags/}
-          $ARCH = if ([Environment]::Is64BitOperatingSystem) { 'x64' } else { 'x86' }
+          OS="windows"
-          $FOLDER = "chloride-$TAG-windows-$ARCH"
+          ARCH=$(uname -m)
-          $ZIP = "$FOLDER.zip"
+          FOLDER="chloride-$TAG-$OS-$ARCH"
-          Rename-Item build/bin $FOLDER
+          TAR="$FOLDER.tar.gz"
-          Copy-Item LICENSE.txt $FOLDER
+          mv build/bin "$FOLDER"
-          Compress-Archive -Path $FOLDER -DestinationPath $ZIP
+          cp LICENSE.txt "$FOLDER"
-          echo "TAR_NAME=$ZIP" >> $env:GITHUB_ENV
+          tar -czf "$TAR" "$FOLDER"
-        shell: pwsh
+          echo "TAR_NAME=$TAR" >> $GITHUB_ENV
 
       - name: Upload artifact
         uses: actions/upload-artifact@v4
@@ -153,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)
@@ -57,6 +65,7 @@ target_link_libraries(argon PRIVATE
     BDWgc::BDWgc
     gmp::gmp
     m
+    $<$<PLATFORM_ID:Windows>:bcrypt>
 )
 
 target_include_directories(argon PRIVATE

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
@@ -14,10 +14,6 @@ LEXER_H = src/lexer/lex.yy.h
 CFLAGS = $(ARCHFLAGS) -lm -lgc -lgmp -Wall -Wextra -Wno-unused-function -Werror=unused-result -Iexternal/cwalk/include -Iexternal/libdye/include
 LDFLAGS = -lgc -lgmp -lm
 
-ifeq ($(MAKECMDGOALS),windows)
-	LDFLAGS = -Wl,-Bstatic -lgc -lgmp -Wl,-Bdynamic -lm
-endif
-
 all: $(BINARY)
 
 
@@ -28,14 +24,6 @@ $(BINARY): $(CFILES) $(LEXER_C) $(LEXER_H)
 	mkdir -p bin
 	gcc -O3 -o $(BINARY) $(CFILES) $(CFLAGS) ${LDFLAGS} -s
 
-windows: $(CFILES) $(LEXER_C) $(LEXER_H)
-	(echo -n "external/xxhash/xxhash.c " ; \
-	 echo -n "external/cwalk/src/cwalk.c " ; \
-	 echo -n "external/libdye/src/dye.c " ; \
-	 find src -name '*.c' -print0 | xargs -0 echo -n) > sources.txt
-	mkdir -p bin
-	gcc -O3 -march=native -o $(BINARY) @sources.txt $(CFLAGS) -lbcrypt
-
 native: $(CFILES) $(LEXER_C) $(LEXER_H)
 	mkdir -p bin
 	gcc -O3 -march=native -o $(BINARY) $(CFILES) $(CFLAGS) ${LDFLAGS}

src/main.c

@@ -11,6 +11,8 @@
 #include "lexer/token.h"
 #include "memory.h"
 #include "parser/parser.h"
+#include "returnTypes.h"
+#include "shell.h"
 #include "runtime/runtime.h"
 #include "translator/translator.h"
 
@@ -66,8 +68,9 @@ static inline uint64_t htole64(uint64_t x) { return x; }
 #define htole64(x) OSSwapHostToLittleInt64(x)
 #define le64toh(x) OSSwapLittleToHostInt64(x)
 // Add others as needed
-#else
+#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
-#error "Unsupported platform"
+#include <stdlib.h>
+#include <sys/endian.h>
 #endif
 
 char *get_current_directory() {
@@ -277,18 +280,20 @@ FAILED:
   return 1;
 }
 
-Execution execute(char *path, Stack *stack) {
+Translated load_argon_file(char *path, ArErr *err) {
   clock_t start, end;
+  clock_t beginning = clock();
   double time_spent, total_time_spent = 0;
 
   const char *basename_ptr;
   size_t basename_length;
   cwk_path_get_basename(path, &basename_ptr, &basename_length);
 
-  if (!basename_ptr)
+  if (!basename_ptr) {
-    return (Execution){create_err(0, 0, 0, NULL, "Path Error",
+    *err = create_err(0, 0, 0, NULL, "Path Error", "path has no basename '%s'",
-                                  "path has no basename '%s'", path),
+                      path);
-                       (Stack){NULL, NULL}};
+    return (Translated){};
+  }
 
   char basename[FILENAME_MAX];
   memcpy(basename, basename_ptr, basename_length);
@@ -312,9 +317,9 @@ Execution execute(char *path, Stack *stack) {
 
   FILE *file = fopen(path, "r");
   if (!file) {
-    return (Execution){create_err(0, 0, 0, NULL, "File Error",
+    *err = create_err(0, 0, 0, NULL, "File Error", "Unable to open file '%s'",
-                                  "Unable to open file '%s'", path),
+                      path);
-                       (Stack){NULL, NULL}};
+    return (Translated){};
   }
 
   XXH3_state_t *hash_state = XXH3_createState();
@@ -338,14 +343,13 @@ Execution execute(char *path, Stack *stack) {
 
     LexerState state = {path, file, 0, 0, &tokens};
     start = clock();
-    ArErr err = lexer(state);
+    *err = lexer(state);
-    if (err.exists) {
+    if (err->exists) {
       darray_free(&tokens, free_token);
-      return (Execution){err, (Stack){NULL, NULL}};
+      return (Translated){};
     }
     end = clock();
     time_spent = (double)(end - start) / CLOCKS_PER_SEC;
-    total_time_spent += time_spent;
     fprintf(stderr, "Lexer time taken: %f seconds\n", time_spent);
     fclose(state.file);
 
@@ -354,35 +358,30 @@ Execution execute(char *path, Stack *stack) {
     darray_init(&ast, sizeof(ParsedValue));
 
     start = clock();
-    err = parser(path, &ast, &tokens, false);
+    *err = parser(path, &ast, &tokens, false);
-    if (err.exists) {
     darray_free(&tokens, free_token);
+    if (err->exists) {
       darray_free(&ast, free_parsed);
-      return (Execution){err, (Stack){NULL, NULL}};
+      return (Translated){};
     }
     end = clock();
     time_spent = (double)(end - start) / CLOCKS_PER_SEC;
-    total_time_spent += time_spent;
     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);
+    *err = translate(&translated, &ast);
-    if (err.exists) {
+    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){};
-      return (Execution){err, (Stack){NULL, NULL}};
     }
     end = clock();
     time_spent = (double)(end - start) / CLOCKS_PER_SEC;
-    total_time_spent += time_spent;
     fprintf(stderr, "Translation time taken: %f seconds\n", time_spent);
-
-    darray_free(&ast, free_parsed);
 #if defined(__linux__)
     malloc_trim(0);
 #endif
@@ -444,18 +443,10 @@ Execution execute(char *path, Stack *stack) {
   gc_translated.constants.capacity = translated.constants.capacity;
   darray_free(&translated.bytecode, NULL);
   free(translated.constants.data);
-
+  total_time_spent = (double)(clock() - beginning) / CLOCKS_PER_SEC;
-  start = clock();
+  fprintf(stderr, "total time taken loading file (%s): %f seconds\n", path,
-  RuntimeState state = init_runtime_state(gc_translated, path);
+          total_time_spent);
-  Stack *main_scope = create_scope(stack);
+  return gc_translated;
-  ArErr err = runtime(gc_translated, state, main_scope);
-  end = clock();
-  time_spent = (double)(end - start) / CLOCKS_PER_SEC;
-  total_time_spent += time_spent;
-  fprintf(stderr,"Execution time taken: %f seconds\n", time_spent);
-  fprintf(stderr,"total time taken: %f seconds\n", total_time_spent);
-
-  return (Execution){err, *main_scope};
 }
 
 int main(int argc, char *argv[]) {
@@ -465,18 +456,32 @@ 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));
   free(CWD);
-  Execution resp = execute(path, Global_Scope);
+  ArErr err;
+  Translated translated = load_argon_file(path, &err);
+  if (err.exists) {
+    output_err(err);
+    return 1;
+  }
+  clock_t start = clock(), end;
+  RuntimeState state = init_runtime_state(translated, path);
+  Stack *main_scope = create_scope(Global_Scope);
+  err = runtime(translated, state, main_scope);
+
+  end = clock();
+  double time_spent = (double)(end - start) / CLOCKS_PER_SEC;
+  fprintf(stderr, "Execution time taken: %f seconds\n", time_spent);
+
   if (runtime_hash_table)
     hashmap_free(runtime_hash_table, NULL);
-  if (resp.err.exists) {
+  if (err.exists) {
-    output_err(resp.err);
+    output_err(err);
     return 1;
   }
   // Your main thread code

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",
@@ -190,3 +190,4 @@ ParsedValueReturn parse_number(Token *token, char *path) {
   parsedValue->data = r_ptr;
   return (ParsedValueReturn){no_err, parsedValue};
 }
+

src/returnTypes.h

@@ -20,9 +20,4 @@ typedef struct ArErr {
   char type[32];
   char message[ERR_MSG_MAX_LEN];
 } ArErr;
-
-typedef struct Execution {
-  ArErr err;
-  Stack stack;
-} Execution;
 #endif // RETURN_TYPES_

src/shell.c

@@ -0,0 +1,281 @@
+/*
+ * 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
+
+volatile sig_atomic_t interrupted = 0;
+
+// Ctrl+C handler
+void handle_sigint(int sig) {
+  (void)sig;
+  interrupted = 1;
+}
+
+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;
+}
+
+#if defined(_WIN32) || defined(_WIN64)
+// Simple input function
+char *input(const char *prompt) {
+  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;
+  }
+
+  // Remove trailing newline
+  if (len > 0 && buffer[len - 1] == '\n') {
+    buffer[len - 1] = '\0';
+  }
+
+  return buffer;
+}
+#endif
+
+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);
+
+#if defined(_WIN32) || defined(_WIN64)
+      char *inp = input(prompt);
+#else
+      char *inp = linenoise(prompt);
+#endif
+      free(prompt);
+
+      if (!inp) {
+        printf("\nBye :)\n");
+        // Free previously collected lines
+        free(inp);
+        free(totranslate);
+        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);
+      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

testing.ar

@@ -8,3 +8,8 @@ let say_hi(name) = do
     return "hello "+u+", how are you?"
 
 term.log(say_hi("william"))
+
+let a = 9
+let b = 10
+
+term.log(string(a)+'+'+string(b)+'='+string(a+b))