fix operations not performing correctly and trying to fix cached code not executing correctly

anonymous-function-test.ar

@@ -1,3 +1 @@
-let i = 1e7
+term.log(1+2+3-4+5-100+10)
-while (i) do
-  i=i-1

src/main.c

@@ -430,20 +430,20 @@ Translated load_argon_file(char *path, ArErr *err) {
   Translated gc_translated = {
       translated.registerCount, translated.registerAssignment, NULL, {}, {},
       translated.path};
-  gc_translated.bytecode.data = ar_alloc_atomic(translated.bytecode.capacity);
+  gc_translated.bytecode.data = ar_alloc_atomic(translated.bytecode.size);
   memcpy(gc_translated.bytecode.data, translated.bytecode.data,
-         translated.bytecode.capacity);
+         translated.bytecode.size);
   gc_translated.bytecode.element_size = translated.bytecode.element_size;
   gc_translated.bytecode.size = translated.bytecode.size;
   gc_translated.bytecode.resizable = false;
   gc_translated.bytecode.capacity =
       translated.bytecode.size * translated.bytecode.element_size;
-  gc_translated.constants.data = ar_alloc_atomic(translated.constants.capacity);
+  gc_translated.constants.data = ar_alloc_atomic(translated.constants.size);
   memcpy(gc_translated.constants.data, translated.constants.data,
-         translated.constants.capacity);
+         translated.constants.size);
   gc_translated.constants.size = translated.constants.size;
-  gc_translated.constants.capacity = translated.constants.capacity;
+  gc_translated.constants.capacity = translated.constants.size * translated.bytecode.element_size;
-  darray_free(&translated.bytecode, NULL);
+  free(translated.bytecode.data);
   free(translated.constants.data);
   total_time_spent = (double)(clock() - beginning) / CLOCKS_PER_SEC;
   fprintf(stderr, "total time taken loading file (%s): %f seconds\n", path,

src/parser/operations/operations.c

@@ -12,8 +12,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-struct operation {};
-
 ParsedValue convert_to_operation(DArray *to_operate_on, DArray *operations) {
   if (to_operate_on->size == 1) {
     return *((ParsedValue *)darray_get(to_operate_on, 0));
@@ -31,8 +29,10 @@ ParsedValue convert_to_operation(DArray *to_operate_on, DArray *operations) {
       operation = *current_operation;
       darray_init(&positions, sizeof(size_t));
     }
+    if (operation_type == current_operation->type) {
       darray_push(&positions, &i);
     }
+  }
   ParsedValue parsedValue;
   parsedValue.type = AST_OPERATION;
   ParsedOperation *operationStruct = checked_malloc(sizeof(ParsedOperation));

src/runtime/objects/number/number.c

@@ -412,17 +412,20 @@ ArgonObject *ARGON_NUMBER_TYPE___string__(size_t argc, ArgonObject **argv,
   return result;
 }
 
-ArgonObject small_ints[UINT8_MAX * 2];
+#define small_ints_min -256
+#define small_ints_max 256
+ArgonObject small_ints[small_ints_max-small_ints_min+1];
 
 void init_small_ints() {
-  for (uint64_t i = 0; i < UINT8_MAX * 2; i++) {
+  for (int64_t i = 0; i <= small_ints_max-small_ints_min; i++) {
+    int64_t n = i+small_ints_min;
     small_ints[i].type = TYPE_NUMBER;
     small_ints[i].dict = createHashmap_GC();
     add_builtin_field(&small_ints[i], __class__, ARGON_NUMBER_TYPE);
     add_builtin_field(&small_ints[i], __base__, BASE_CLASS);
     small_ints[i].value.as_number.is_int64 = true;
-    small_ints[i].value.as_number.n.i64 = i;
+    small_ints[i].value.as_number.n.i64 = n;
-    small_ints[i].as_bool = i;
+    small_ints[i].as_bool = n;
   }
 }
 
@@ -530,8 +533,8 @@ bool double_to_int64(double x, int64_t *out) {
 ArgonObject *new_number_object(mpq_t number) {
   int64_t i64 = 0;
   bool is_int64 = mpq_to_int64(number, &i64);
-  if (is_int64 && i64 >= INT8_MIN * 2 && i64 <= INT8_MAX * 2) {
+  if (is_int64 && i64 >= small_ints_min && i64 <= small_ints_max) {
-    return &small_ints[i64];
+    return &small_ints[i64-small_ints_min];
   }
   ArgonObject *object = new_object();
   add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
@@ -548,8 +551,8 @@ ArgonObject *new_number_object(mpq_t number) {
 }
 
 ArgonObject *new_number_object_from_num_and_den(int64_t n, uint64_t d) {
-  if (d == 1 && n >= INT8_MIN && n <= INT8_MAX) {
+  if (d == 1 && n >= small_ints_min && n <= small_ints_max) {
-    return &small_ints[(int8_t)n];
+    return &small_ints[n-small_ints_min];
   }
   ArgonObject *object = new_object();
   add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
@@ -573,8 +576,8 @@ ArgonObject *new_number_object_from_num_and_den(int64_t n, uint64_t d) {
 ArgonObject *new_number_object_from_double(double d) {
   int64_t i64 = 0;
   bool is_int64 = double_to_int64(d, &i64);
-  if (is_int64 && i64 >= INT8_MIN && i64 <= INT8_MAX) {
+  if (is_int64 && i64 >= small_ints_min && i64 <= small_ints_max) {
-    return &small_ints[(int8_t)i64];
+    return &small_ints[i64-small_ints_min];
   }
   ArgonObject *object = new_object();
   add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);

src/runtime/objects/string/string.c

@@ -21,6 +21,8 @@ ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash,
                     new_number_object_from_num_and_den(length, 1));
   object->type = TYPE_STRING;
   object->value.as_str.data = ar_alloc_atomic(length);
+  printf("%zu, %p\n", length,data);
+  printf("%.*s\n", (int)length,data);
   memcpy(object->value.as_str.data, data, length);
   object->value.as_str.prehash = prehash;
   object->value.as_str.hash_computed = hash;

src/runtime/runtime.c

@@ -626,10 +626,8 @@ static inline void load_const(Translated *translated, RuntimeState *state) {
   uint64_t to_register = pop_byte(translated, state);
   size_t length = pop_bytecode(translated, state);
   uint64_t offset = pop_bytecode(translated, state);
-
+  printf("offset %zu\n", offset);
-  void *data = ar_alloc_atomic(length);
+  ArgonObject *object = new_string_object(arena_get(&translated->constants, offset), length, 0, 0);
-  memcpy(data, arena_get(&translated->constants, offset), length);
-  ArgonObject *object = new_string_object(data, length, 0, 0);
   state->registers[to_register] = object;
 }
 
@@ -671,8 +669,28 @@ static inline void load_variable(Translated *translated, RuntimeState *state,
                     arena_get(&translated->constants, offset));
   return;
 }
-static inline void run_instructions(Translated *translated, RuntimeState *state,
+
-                                    struct Stack **stack, ArErr *err) {
+RuntimeState init_runtime_state(Translated translated, char *path) {
+  RuntimeState runtime = {
+      ar_alloc(translated.registerCount * sizeof(ArgonObject *)),
+      0,
+      path,
+      NULL,
+      NULL,
+      {0, 0, 0},
+      {}};
+  return runtime;
+}
+
+Stack *create_scope(Stack *prev) {
+  Stack *stack = ar_alloc(sizeof(Stack));
+  stack->scope = createHashmap_GC();
+  stack->prev = prev;
+  return stack;
+}
+
+void runtime(Translated translated, RuntimeState state, Stack *stack,
+             ArErr *err) {
   static void *dispatch_table[] = {
       [OP_LOAD_STRING] = &&DO_LOAD_STRING,
       [OP_DECLARE] = &&DO_DECLARE,
@@ -696,41 +714,53 @@ static inline void run_instructions(Translated *translated, RuntimeState *state,
       [OP_ADDITION] = &&DO_ADDITION,
       [OP_SUBTRACTION] = &&DO_SUBTRACTION,
       [OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION};
-START:
+  state.head = 0;
-  if (unlikely(state->head >= translated->bytecode.size || err->exists))
+
-    return;
+  StackFrame *currentStackFrame =
-  goto *dispatch_table[pop_byte(translated, state)];
+      ar_alloc(sizeof(StackFrame) * STACKFRAME_CHUNKS);
+  *currentStackFrame = (StackFrame){translated, state, stack, NULL, 0};
+  currentStackFrame->state.currentStackFramePointer = &currentStackFrame;
+  while (currentStackFrame) {
+    while (likely(currentStackFrame->state.head <
+                      currentStackFrame->translated.bytecode.size &&
+                  !err->exists)) {
+      Translated *translated = &currentStackFrame->translated;
+      RuntimeState *state = &currentStackFrame->state;
+      uint8_t instruction = pop_byte(translated, state);
+      printf("opcode: %d\n",instruction);
+      goto *dispatch_table[instruction];
     DO_LOAD_NULL:
       state->registers[pop_byte(translated, state)] = ARGON_NULL;
-  goto START;
+      continue;
     DO_LOAD_STRING:
       load_const(translated, state);
-  goto START;
+      continue;
     DO_LOAD_NUMBER:
       load_number(translated, state);
-  goto START;
+      continue;
     DO_LOAD_FUNCTION:
-  load_argon_function(translated, state, *stack);
+      load_argon_function(translated, state, currentStackFrame->stack);
-  goto START;
+      continue;
     DO_IDENTIFIER:
-  load_variable(translated, state, *stack, err);
+      load_variable(translated, state, currentStackFrame->stack, err);
-  goto START;
+      continue;
     DO_DECLARE:
-  runtime_declaration(translated, state, *stack, err);
+      runtime_declaration(translated, state, currentStackFrame->stack, err);
-  goto START;
+      continue;
     DO_ASSIGN:
-  runtime_assignment(translated, state, *stack);
+      runtime_assignment(translated, state, currentStackFrame->stack);
-  goto START;
+      continue;
     DO_BOOL: {
       uint8_t to_register = pop_byte(translated, state);
       if (likely(state->registers[0]->type != TYPE_OBJECT)) {
         state->registers[to_register] =
             state->registers[0]->as_bool ? ARGON_TRUE : ARGON_FALSE;
-    goto START;
+        continue;
       }
       ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]};
-  state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, err, state);
+      state->registers[to_register] =
-  goto START;
+          ARGON_BOOL_TYPE___new__(2, args, err, state);
+      continue;
     }
     DO_JUMP_IF_FALSE: {
       uint8_t from_register = pop_byte(translated, state);
@@ -738,20 +768,20 @@ DO_JUMP_IF_FALSE: {
       if (state->registers[from_register] == ARGON_FALSE) {
         state->head = to;
       }
-  goto START;
+      continue;
     }
     DO_JUMP:
       state->head = pop_bytecode(translated, state);
-  goto START;
+      continue;
     DO_NEW_SCOPE:
-  *stack = create_scope(*stack);
+      currentStackFrame->stack = create_scope(currentStackFrame->stack);
-  goto START;
+      continue;
     DO_EMPTY_SCOPE:
-  clear_hashmap_GC((*stack)->scope);
+      clear_hashmap_GC(currentStackFrame->stack->scope);
-  goto START;
+      continue;
     DO_POP_SCOPE:
-  *stack = (*stack)->prev;
+      currentStackFrame->stack = currentStackFrame->stack->prev;
-  goto START;
+      continue;
     DO_INIT_CALL: {
       size_t length = pop_bytecode(translated, state);
       call_instance call_instance = {state->call_instance, state->registers[0],
@@ -759,34 +789,35 @@ DO_INIT_CALL: {
                                      length};
       state->call_instance = ar_alloc(sizeof(call_instance));
       *state->call_instance = call_instance;
-  goto START;
+      continue;
     }
     DO_INSERT_ARG:;
       size_t index = pop_bytecode(translated, state);
       state->call_instance->args[index] = state->registers[0];
-  goto START;
+      continue;
     DO_CALL: {
       run_call(state->call_instance->to_call, state->call_instance->args_length,
                state->call_instance->args, state, false, err);
       state->call_instance = (*state->call_instance).previous;
-  goto START;
+      continue;
     }
     DO_SOURCE_LOCATION:
-  state->source_location = (SourceLocation){pop_bytecode(translated, state),
+      state->source_location = (SourceLocation){
-                                            pop_bytecode(translated, state),
+          pop_bytecode(translated, state), pop_bytecode(translated, state),
           pop_bytecode(translated, state)};
-  goto START;
+      continue;
     DO_LOAD_BOOL:
-  state->registers[0] = pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE;
+      state->registers[0] =
-  goto START;
+          pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE;
+      continue;
     DO_LOAD_ACCESS_FUNCTION:
       state->registers[0] = ACCESS_FUNCTION;
-  goto START;
+      continue;
     DO_COPY_TO_REGISTER: {
       uint8_t from_register = pop_byte(translated, state);
       uint64_t to_register = pop_byte(translated, state);
       state->registers[to_register] = state->registers[from_register];
-  goto START;
+      continue;
     }
     DO_ADDITION: {
       uint8_t registerA = pop_byte(translated, state);
@@ -806,7 +837,7 @@ DO_ADDITION: {
           if (!gonna_overflow) {
             state->registers[registerC] =
                 new_number_object_from_num_and_den(a + b, 1);
-        goto START;
+            continue;
           }
           mpq_t a_GMP, b_GMP;
           mpq_init(a_GMP);
@@ -841,17 +872,18 @@ DO_ADDITION: {
           mpq_clear(a_GMP);
           mpq_clear(b_GMP);
         }
-    goto START;
+        continue;
       }
 
       ArgonObject *args[] = {valueA, valueB};
-  state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, err, state);
+      state->registers[registerC] =
-  goto START;
+          ARGON_ADDITION_FUNCTION(2, args, err, state);
+      continue;
     }
     DO_SUBTRACTION: {
       uint8_t registerA = pop_byte(translated, state);
-  uint64_t registerB = pop_byte(translated, state);
+      uint8_t registerB = pop_byte(translated, state);
-  uint64_t registerC = pop_byte(translated, state);
+      uint8_t registerC = pop_byte(translated, state);
 
       ArgonObject *valueA = state->registers[registerA];
       ArgonObject *valueB = state->registers[registerB];
@@ -867,7 +899,7 @@ DO_SUBTRACTION: {
           if (!gonna_overflow) {
             state->registers[registerC] =
                 new_number_object_from_num_and_den(a - b, 1);
-        goto START;
+            continue;
           }
           mpq_t a_GMP, b_GMP;
           mpq_init(a_GMP);
@@ -902,46 +934,15 @@ DO_SUBTRACTION: {
           mpq_clear(a_GMP);
           mpq_clear(b_GMP);
         }
-    goto START;
+        continue;
       }
 
       ArgonObject *args[] = {valueA, valueB};
-  state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, err, state);
+      state->registers[registerC] =
-  goto START;
+          ARGON_ADDITION_FUNCTION(2, args, err, state);
+      continue;
     }
-  goto START;
     }
-
-RuntimeState init_runtime_state(Translated translated, char *path) {
-  RuntimeState runtime = {
-      ar_alloc(translated.registerCount * sizeof(ArgonObject *)),
-      0,
-      path,
-      NULL,
-      NULL,
-      {0, 0, 0},
-      {}};
-  return runtime;
-}
-
-Stack *create_scope(Stack *prev) {
-  Stack *stack = ar_alloc(sizeof(Stack));
-  stack->scope = createHashmap_GC();
-  stack->prev = prev;
-  return stack;
-}
-
-void runtime(Translated translated, RuntimeState state, Stack *stack,
-             ArErr *err) {
-  state.head = 0;
-
-  StackFrame *currentStackFrame =
-      ar_alloc(sizeof(StackFrame) * STACKFRAME_CHUNKS);
-  *currentStackFrame = (StackFrame){translated, state, stack, NULL, 0};
-  currentStackFrame->state.currentStackFramePointer = &currentStackFrame;
-  while (currentStackFrame) {
-    run_instructions(&currentStackFrame->translated, &currentStackFrame->state,
-                     &currentStackFrame->stack, err);
     currentStackFrame = currentStackFrame->previousStackFrame;
   }
 }

testing.ar

@@ -39,7 +39,7 @@ term.log(
 )
 call(()=do
     term.log((
-            (x)=x*x*x*x*x*x*x*x*x*x*x*x
+            (x)=x
         )(
             10000675435574942378423458324823473205237523053278452368578032472390453275238558438905348905894035890348905349805345485843578934268954328902589607469328905490832678934728969834689057843267854736890256743928563256749016078596789416895657435690769013674516750941765438576867893726789543789345678576846715416789058903890549045839804538905389045890435890349580348905894035890435784785236523656237985678342523678
         )