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

add not and or, while also improving performance.

Browse Source
This commit is contained in:
William Bell
2025-09-07 21:03:57 +01:00
parent 57728af0b6
commit 23c4a7ebd1
36 changed files with 201 additions and 458 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/runtime/assignment/assignment.c
View File

@@ -21,6 +21,7 @@ void runtime_assignment(Translated *translated, RuntimeState *state,
if (exists) {
hashmap_insert_GC(current_stack->scope, hash, key,
state->registers[from_register], 0);
return;
}
}
hashmap_insert_GC(stack->scope, hash, key, state->registers[from_register],

3
src/runtime/call/call.c
View File

@@ -6,7 +6,6 @@
#include "call.h"
#include "../../hash_data/hash_data.h"
#include "../objects/literals/literals.h"
#include "../objects/string/string.h"
#include <inttypes.h>
#include <math.h>
@@ -156,7 +155,7 @@ void run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
*state->currentStackFramePointer,
(*state->currentStackFramePointer)->depth + 1};
for (size_t i = 0; i < new_stackFrame.translated.registerCount; i++) {
new_stackFrame.state.registers[i] = ARGON_NULL;
new_stackFrame.state.registers[i] = NULL;
}
if (CStackFrame) {
runtime(new_stackFrame.translated, new_stackFrame.state,

19
src/runtime/internals/hashmap/hashmap.c
View File

@@ -15,18 +15,19 @@
#include <string.h>
struct hashmap_GC *createHashmap_GC() {
size_t size = 8;
struct hashmap_GC *t =
(struct hashmap_GC *)ar_alloc(sizeof(struct hashmap_GC));
t->size = size;
t->order = 1;
t->list = (struct node_GC **)ar_alloc(sizeof(struct node_GC *) * size);
memset(t->list, 0, sizeof(struct node_GC *) * size);
t->count = 0;
return t;
size_t size = 8;
struct hashmap_GC *t =
(struct hashmap_GC *)ar_alloc(sizeof(struct hashmap_GC) + sizeof(struct node_GC *) * size);
t->size = size;
t->order = 1;
t->list = (struct node_GC **)((char*)t + sizeof(struct hashmap_GC));
memset(t->list, 0, sizeof(struct node_GC *) * size);
t->count = 0;
return t;
}
void clear_hashmap_GC(struct hashmap_GC *t) {
if (!t->count) return;
t->order = 1;
t->count = 0;
memset(t->list, 0, sizeof(struct node_GC *) * t->size);

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

@@ -7,7 +7,6 @@
#include "number.h"
#include "../functions/functions.h"
#include "../string/string.h"
#include <gmp-x86_64.h>
#include <gmp.h>
#include <inttypes.h>
#include <stdio.h>

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

@@ -13,15 +13,14 @@
ArgonObject *ARGON_STRING_TYPE = NULL;
ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash,
ArgonObject *new_string_object_without_memcpy(char *data, size_t length, uint64_t prehash,
uint64_t hash) {
ArgonObject *object = new_object();
add_builtin_field(object, __class__, ARGON_STRING_TYPE);
add_builtin_field(object, field_length,
new_number_object_from_int64(length));
object->type = TYPE_STRING;
object->value.as_str.data = ar_alloc_atomic(length);
memcpy(object->value.as_str.data, data, length);
object->value.as_str.data = data;
object->value.as_str.prehash = prehash;
object->value.as_str.hash_computed = hash;
object->value.as_str.hash = hash;
@@ -30,6 +29,13 @@ ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash,
return object;
}
ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash,
uint64_t hash) {
char*data_copy = ar_alloc_atomic(length);
memcpy(data_copy, data, length);
return new_string_object_without_memcpy(data_copy,length, prehash, hash);
}
ArgonObject *new_string_object_null_terminated(char *data) {
return new_string_object(data, strlen(data), 0, 0);
}

3
src/runtime/objects/string/string.h
View File

@@ -10,6 +10,9 @@
extern ArgonObject *ARGON_STRING_TYPE;
ArgonObject *new_string_object_without_memcpy(char *data, size_t length, uint64_t prehash,
uint64_t hash);
ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash, uint64_t hash);
ArgonObject *new_string_object_null_terminated(char*data);

49
src/runtime/runtime.c
View File

@@ -359,12 +359,11 @@ ArgonObject *ARGON_STRING_TYPE___add__(size_t argc, ArgonObject **argv,
return ARGON_NULL;
}
size_t length = argv[0]->value.as_str.length + argv[1]->value.as_str.length;
char *concat = malloc(length);
char *concat = ar_alloc_atomic(length);
memcpy(concat, argv[0]->value.as_str.data, argv[0]->value.as_str.length);
memcpy(concat + argv[0]->value.as_str.length, argv[1]->value.as_str.data,
argv[1]->value.as_str.length);
ArgonObject *object = new_string_object(concat, length, 0, 0);
free(concat);
ArgonObject *object = new_string_object_without_memcpy(concat, length, 0, 0);
return object;
}
@@ -485,6 +484,7 @@ void bootstrap_types() {
ARGON_NULL_TYPE = new_object();
add_builtin_field(ARGON_NULL_TYPE, __base__, BASE_CLASS);
ARGON_NULL = new_object();
ARGON_NULL->type = TYPE_NULL;
add_builtin_field(ARGON_NULL, __class__, ARGON_NULL_TYPE);
ARGON_NULL->as_bool = false;
@@ -681,22 +681,27 @@ RuntimeState init_runtime_state(Translated translated, char *path) {
NULL,
{0, 0, 0},
{}};
for (size_t i = 0;i<translated.registerCount;i++) {
runtime.registers[i] = ARGON_NULL;
for (size_t i = 0; i < translated.registerCount; i++) {
runtime.registers[i] = NULL;
}
return runtime;
}
Stack *create_scope(Stack *prev) {
Stack *stack = ar_alloc(sizeof(Stack));
stack->scope = createHashmap_GC();
stack->prev = prev;
return stack;
if (!prev || prev->scope->count) {
Stack *stack = ar_alloc(sizeof(Stack));
stack->fake_new_scopes = 0;
stack->scope = createHashmap_GC();
stack->prev = prev;
return stack;
}
prev->fake_new_scopes++;
return prev;
}
void runtime(Translated _translated, RuntimeState _state, Stack *stack,
ArErr *err) {
static void *dispatch_table[] = {
static void *const dispatch_table[] = {
[OP_LOAD_STRING] = &&DO_LOAD_STRING,
[OP_DECLARE] = &&DO_DECLARE,
[OP_LOAD_NULL] = &&DO_LOAD_NULL,
@@ -720,7 +725,8 @@ void runtime(Translated _translated, RuntimeState _state, Stack *stack,
[OP_SUBTRACTION] = &&DO_SUBTRACTION,
[OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION,
[OP_MULTIPLICATION] = &&DO_MULTIPLICATION,
[OP_DIVISION] = &&DO_DIVISION};
[OP_DIVISION] = &&DO_DIVISION,
[OP_NOT] = &&DO_NOT};
_state.head = 0;
StackFrame *currentStackFrame = ar_alloc(sizeof(StackFrame));
@@ -756,15 +762,16 @@ void runtime(Translated _translated, RuntimeState _state, Stack *stack,
runtime_assignment(translated, state, currentStackFrame->stack);
continue;
DO_BOOL: {
uint8_t to_register = pop_byte(translated, state);
if (likely(state->registers[to_register]->type != TYPE_OBJECT)) {
state->registers[to_register] =
state->registers[to_register]->as_bool ? ARGON_TRUE : ARGON_FALSE;
if (state->registers[0] == ARGON_TRUE ||
state->registers[0] == ARGON_FALSE)
continue;
if (likely(state->registers[0]->type != TYPE_OBJECT)) {
state->registers[0] =
state->registers[0]->as_bool ? ARGON_TRUE : ARGON_FALSE;
continue;
}
ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]};
state->registers[to_register] =
ARGON_BOOL_TYPE___new__(2, args, err, state);
state->registers[0] = ARGON_BOOL_TYPE___new__(2, args, err, state);
continue;
}
DO_JUMP_IF_FALSE: {
@@ -775,6 +782,10 @@ void runtime(Translated _translated, RuntimeState _state, Stack *stack,
}
continue;
}
DO_NOT:
state->registers[0] =
state->registers[0] == ARGON_FALSE ? ARGON_TRUE : ARGON_FALSE;
continue;
DO_JUMP:
state->head = pop_bytecode(translated, state);
continue;
@@ -785,6 +796,10 @@ void runtime(Translated _translated, RuntimeState _state, Stack *stack,
clear_hashmap_GC(currentStackFrame->stack->scope);
continue;
DO_POP_SCOPE:
if (currentStackFrame->stack->fake_new_scopes) {
currentStackFrame->stack->fake_new_scopes--;
goto DO_EMPTY_SCOPE;
}
currentStackFrame->stack = currentStackFrame->stack->prev;
continue;
DO_INIT_CALL: {