Open-Argon/Chloride
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
William Bell
2025-09-02 02:59:47 +01:00
parent fd5b237dfe
commit f5ee0f6fc8
7 changed files with 272 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
anonymous-function-test.ar
View File

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

12
src/main.c
View File

@@ -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;
darray_free(&translated.bytecode, NULL);
gc_translated.constants.capacity = translated.constants.size * translated.bytecode.element_size;
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,

4
src/parser/operations/operations.c
View File

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

23
src/runtime/objects/number/number.c
View File

@@ -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].as_bool = i;
small_ints[i].value.as_number.n.i64 = n;
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) {
return &small_ints[i64];
if (is_int64 && i64 >= small_ints_min && i64 <= small_ints_max) {
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) {
return &small_ints[(int8_t)n];
if (d == 1 && n >= small_ints_min && n <= small_ints_max) {
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) {
return &small_ints[(int8_t)i64];
if (is_int64 && i64 >= small_ints_min && i64 <= small_ints_max) {
return &small_ints[i64-small_ints_min];
}
ArgonObject *object = new_object();
add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);

2
src/runtime/objects/string/string.c
View File

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

169
src/runtime/runtime.c
View File

@@ -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);
void *data = ar_alloc_atomic(length);
memcpy(data, arena_get(&translated->constants, offset), length);
ArgonObject *object = new_string_object(data, length, 0, 0);
printf("offset %zu\n", offset);
ArgonObject *object = new_string_object(arena_get(&translated->constants, offset), 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:
if (unlikely(state->head >= translated->bytecode.size || err->exists))
return;
goto *dispatch_table[pop_byte(translated, state)];
state.head = 0;
StackFrame *currentStackFrame =
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);
goto START;
load_argon_function(translated, state, currentStackFrame->stack);
continue;
DO_IDENTIFIER:
load_variable(translated, state, *stack, err);
goto START;
load_variable(translated, state, currentStackFrame->stack, err);
continue;
DO_DECLARE:
runtime_declaration(translated, state, *stack, err);
goto START;
runtime_declaration(translated, state, currentStackFrame->stack, err);
continue;
DO_ASSIGN:
runtime_assignment(translated, state, *stack);
goto START;
runtime_assignment(translated, state, currentStackFrame->stack);
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);
goto START;
state->registers[to_register] =
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);
goto START;
currentStackFrame->stack = create_scope(currentStackFrame->stack);
continue;
DO_EMPTY_SCOPE:
clear_hashmap_GC((*stack)->scope);
goto START;
clear_hashmap_GC(currentStackFrame->stack->scope);
continue;
DO_POP_SCOPE:
*stack = (*stack)->prev;
goto START;
currentStackFrame->stack = currentStackFrame->stack->prev;
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),
pop_bytecode(translated, state),
state->source_location = (SourceLocation){
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;
goto START;
state->registers[0] =
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);
goto START;
state->registers[registerC] =
ARGON_ADDITION_FUNCTION(2, args, err, state);
continue;
}
DO_SUBTRACTION: {
uint8_t registerA = pop_byte(translated, state);
uint64_t registerB = pop_byte(translated, state);
uint64_t registerC = pop_byte(translated, state);
uint8_t registerB = 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);
goto START;
state->registers[registerC] =
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;
}
}

2
testing.ar
View File

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