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

improve performance massively from 0.9 seconds to 0.38 seconds :)

Browse Source
This commit is contained in:
William Bell
2025-09-01 20:25:47 +01:00
parent 4f91bf48f3
commit 19268f3070
24 changed files with 479 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@@ -30,11 +30,11 @@ native: $(CFILES) $(LEXER_C) $(LEXER_H)
debug: $(CFILES) $(LEXER_C) $(LEXER_H)
mkdir -p bin
gcc -g -O3 -o $(BINARY) $(CFILES) $(CFLAGS)
gcc -g -O0 -o $(BINARY) $(CFILES) $(CFLAGS)
full-debug: $(CFILES) $(LEXER_C) $(LEXER_H)
mkdir -p bin
gcc -g -O0 -fsanitize=address -fno-omit-frame-pointer -o $(BINARY) $(CFILES) $(CFLAGS) ${LDFLAGS}
gcc -g -O3 -fsanitize=address -fno-omit-frame-pointer -o $(BINARY) $(CFILES) $(CFLAGS) ${LDFLAGS}
optimised: $(CFILES) $(LEXER_C) $(LEXER_H)
mkdir -p bin

1
app.py
View File

@@ -1,3 +1,4 @@
i = 1000000
while i:
print(i)
i=i-1

3
src/arobject.h
View File

@@ -49,6 +49,9 @@ typedef struct {
struct string_struct {
char *data;
uint64_t prehash;
uint64_t hash;
bool hash_computed;
size_t length;
};

8
src/hash_data/hash_data.c
View File

@@ -39,10 +39,6 @@ uint64_t siphash64_bytes(const void *data, size_t len,const uint8_t hash_key[16]
uint8_t out[8];
if (siphash(data, len, hash_key, out, sizeof(out)) != 0)
return 0;
uint64_t hash = 0;
for (int i = 0; i < 8; ++i)
hash |= ((uint64_t)out[i]) << (8 * i);
return hash;
return *(uint64_t *)out;
}

11
src/main.c
View File

@@ -12,8 +12,9 @@
#include "memory.h"
#include "parser/parser.h"
#include "returnTypes.h"
#include "shell.h"
#include "runtime/objects/object.h"
#include "runtime/runtime.h"
#include "shell.h"
#include "translator/translator.h"
#include "../external/xxhash/xxhash.h"
@@ -427,7 +428,8 @@ Translated load_argon_file(char *path, ArErr *err) {
}
hashmap_free(translated.constants.hashmap, NULL);
Translated gc_translated = {
translated.registerCount, translated.registerAssignment,NULL, {}, {}, translated.path};
translated.registerCount, translated.registerAssignment, NULL, {}, {},
translated.path};
gc_translated.bytecode.data = ar_alloc_atomic(translated.bytecode.capacity);
memcpy(gc_translated.bytecode.data, translated.bytecode.data,
translated.bytecode.capacity);
@@ -454,6 +456,7 @@ int main(int argc, char *argv[]) {
ar_memory_init();
generate_siphash_key(siphash_key);
init_built_in_field_hashes();
bootstrap_types();
bootstrap_globals();
if (argc <= 1)
@@ -463,7 +466,7 @@ int main(int argc, char *argv[]) {
char path[FILENAME_MAX];
cwk_path_get_absolute(CWD, path_non_absolute, path, sizeof(path));
free(CWD);
ArErr err=no_err;
ArErr err = no_err;
Translated translated = load_argon_file(path, &err);
if (err.exists) {
output_err(err);
@@ -472,7 +475,7 @@ int main(int argc, char *argv[]) {
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);
runtime(translated, state, main_scope, &err);
end = clock();
double time_spent = (double)(end - start) / CLOCKS_PER_SEC;

17
src/runtime/access/access.c
View File

@@ -18,12 +18,23 @@ ArgonObject *ARGON_TYPE_TYPE___get_attr__(size_t argc, ArgonObject **argv,
bool check_field = argv[1] == ARGON_TRUE;
if (check_field) {
ArgonObject *access = argv[2];
ArgonObject *value = get_field_l(to_access, access->value.as_str.data,
uint64_t hash;
if (access->value.as_str.hash_computed) {
hash = access->value.as_str.hash;
} else {
hash =
runtime_hash(access->value.as_str.data, access->value.as_str.length,
access->value.as_str.prehash);
access->value.as_str.hash = hash;
access->value.as_str.hash_computed = true;
}
ArgonObject *value = get_field_l(to_access, access->value.as_str.data, hash,
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);
ArgonObject *name = get_builtin_field_for_class(
get_builtin_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,

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

@@ -6,16 +6,15 @@
#include "assignment.h"
ArErr runtime_assignment(Translated *translated, RuntimeState *state,
void runtime_assignment(Translated *translated, RuntimeState *state,
struct Stack *stack) {
int64_t length = pop_bytecode(translated, state);
int64_t offset = pop_bytecode(translated, state);
int64_t prehash = pop_bytecode(translated, state);
int64_t from_register = pop_byte(translated, state);
uint64_t hash =
runtime_hash(arena_get(&translated->constants, offset), length, prehash);
ArgonObject *key =
new_string_object(arena_get(&translated->constants, offset), length);
void *data = arena_get(&translated->constants, offset);
uint64_t hash = runtime_hash(data, length, prehash);
ArgonObject *key = new_string_object(data, length, prehash, hash);
for (Stack *current_stack = stack; current_stack;
current_stack = current_stack->prev) {
ArgonObject *exists = hashmap_lookup_GC(current_stack->scope, hash);
@@ -26,5 +25,4 @@ ArErr runtime_assignment(Translated *translated, RuntimeState *state,
}
hashmap_insert_GC(stack->scope, hash, key, state->registers[from_register],
0);
return no_err;
}

4
src/runtime/assignment/assignment.h
View File

@@ -9,7 +9,7 @@
#include "../runtime.h"
#include "../objects/string/string.h"
ArErr runtime_assignment(Translated *translated, RuntimeState *state,
struct Stack *stack);
void runtime_assignment(Translated *translated, RuntimeState *state,
struct Stack *stack);
#endif // runtime_assignment_H

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

@@ -19,8 +19,8 @@
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0602
#endif
#include <windows.h>
#include <psapi.h>
#include <windows.h>
double get_memory_usage_mb() {
PROCESS_MEMORY_COUNTERS pmc;
@@ -75,27 +75,28 @@ double get_memory_usage_mb() {
ArgonObject *argon_call(ArgonObject *original_object, size_t argc,
ArgonObject **argv, ArErr *err, RuntimeState *state) {
*err = run_call(original_object, argc, argv, state, true);
run_call(original_object, argc, argv, state, true, err);
return state->registers[0];
}
ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
RuntimeState *state, bool CStackFrame) {
void run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
RuntimeState *state, bool CStackFrame, ArErr *err) {
ArgonObject *object = original_object;
if (object->type != TYPE_FUNCTION && object->type != TYPE_NATIVE_FUNCTION &&
object->type != TYPE_METHOD) {
ArgonObject *call_method =
get_field_for_class(get_field(object, "__class__", false, false),
"__call__", original_object);
ArgonObject *call_method = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __call__,
original_object);
if (call_method) {
object = call_method;
}
}
if (object->type == TYPE_METHOD) {
ArgonObject *binding_object =
get_field(object, "__binding__", false, false);
get_builtin_field(object, __binding__, false, false);
if (binding_object) {
ArgonObject **new_call_args = ar_alloc(sizeof(ArgonObject *) * (argc + 1));
ArgonObject **new_call_args =
ar_alloc(sizeof(ArgonObject *) * (argc + 1));
new_call_args[0] = binding_object;
if (argc > 0) {
memcpy(new_call_args + 1, argv, argc * sizeof(ArgonObject *));
@@ -104,18 +105,18 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
argc++;
}
ArgonObject *function_object =
get_field(object, "__function__", false, false);
get_builtin_field(object, __function__, false, false);
if (function_object)
object = function_object;
}
if (object->type == TYPE_FUNCTION) {
if (argc != object->value.argon_fn.number_of_parameters) {
ArgonObject *type_object_name =
get_field_for_class(get_field(object, "__class__", false, false),
"__name__", original_object);
ArgonObject *type_object_name = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __name__,
original_object);
ArgonObject *object_name =
get_field_for_class(object, "__name__", original_object);
return create_err(
get_builtin_field_for_class(object, __name__, original_object);
*err = create_err(
state->source_location.line, state->source_location.column,
state->source_location.length, state->path, "Type Error",
"%.*s %.*s takes %" PRIu64 " argument(s) but %" PRIu64 " was given",
@@ -130,11 +131,12 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
ArgonObject *value = argv[i];
uint64_t hash = siphash64_bytes(key.data, key.length, siphash_key);
hashmap_insert_GC(scope->scope, hash,
new_string_object(key.data, key.length), value, 0);
new_string_object(key.data, key.length, 0, hash), value,
0);
}
StackFrame new_stackFrame = {
{object->value.argon_fn.translated.registerCount,
object->value.argon_fn.translated.registerAssignment,
object->value.argon_fn.translated.registerAssignment,
NULL,
{object->value.argon_fn.bytecode, sizeof(uint8_t),
object->value.argon_fn.bytecode_length,
@@ -152,7 +154,8 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
*state->currentStackFramePointer,
(*state->currentStackFramePointer)->depth + 1};
if (CStackFrame) {
return runtime(new_stackFrame.translated, new_stackFrame.state, new_stackFrame.stack);
runtime(new_stackFrame.translated, new_stackFrame.state,
new_stackFrame.stack, err);
} else {
if (((*state->currentStackFramePointer)->depth + 1) % STACKFRAME_CHUNKS ==
0) {
@@ -180,23 +183,22 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
}
}
};
return no_err;
return;
}
} else if (object->type == TYPE_NATIVE_FUNCTION) {
ArErr err = no_err;
state->registers[0] = object->value.native_fn(argc, argv, &err, state);
if (err.exists && strlen(err.path) == 0) {
err.line = state->source_location.line;
err.column = state->source_location.column;
err.length = state->source_location.length;
err.path = state->path;
state->registers[0] = object->value.native_fn(argc, argv, err, state);
if (err->exists && strlen(err->path) == 0) {
err->line = state->source_location.line;
err->column = state->source_location.column;
err->length = state->source_location.length;
err->path = state->path;
}
return err;
return;
}
ArgonObject *type_object_name =
get_field_for_class(get_field(original_object, "__class__", false, false),
"__name__", original_object);
return create_err(state->source_location.line, state->source_location.column,
ArgonObject *type_object_name = get_builtin_field_for_class(
get_builtin_field(original_object, __class__, false, false), __name__,
original_object);
*err = create_err(state->source_location.line, state->source_location.column,
state->source_location.length, state->path, "Type Error",
"'%.*s' object is not callable",
(int)type_object_name->value.as_str.length,

4
src/runtime/call/call.h
View File

@@ -11,7 +11,7 @@
ArgonObject *argon_call(ArgonObject *original_object, size_t argc,
ArgonObject **argv, ArErr *err, RuntimeState *state);
ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
RuntimeState *state, bool CStackFrame);
void run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
RuntimeState *state, bool CStackFrame, ArErr *err);
#endif // runtime_call_H

21
src/runtime/declaration/declaration.c
View File

@@ -6,18 +6,23 @@
#include "declaration.h"
ArErr runtime_declaration(Translated *translated, RuntimeState *state,
struct Stack *stack) {
void runtime_declaration(Translated *translated, RuntimeState *state,
struct Stack *stack, ArErr *err) {
int64_t length = pop_bytecode(translated, state);
int64_t offset = pop_bytecode(translated, state);
int64_t prehash = pop_bytecode(translated, state);
int64_t from_register = pop_byte(translated, state);
uint64_t hash = runtime_hash(arena_get(&translated->constants, offset), length, prehash);
ArgonObject * exists = hashmap_lookup_GC(stack->scope, hash);
void *data = arena_get(&translated->constants, offset);
uint64_t hash = runtime_hash(data, length, prehash);
ArgonObject *exists = hashmap_lookup_GC(stack->scope, hash);
if (exists) {
return create_err(state->source_location.line, state->source_location.column, state->source_location.length, state->path, "Runtime Error", "Identifier '%.*s' has already been declared in the current scope", length, arena_get(&translated->constants, offset));
*err = create_err(
state->source_location.line, state->source_location.column,
state->source_location.length, state->path, "Runtime Error",
"Identifier '%.*s' has already been declared in the current scope",
length, arena_get(&translated->constants, offset));
}
ArgonObject * key = new_string_object(arena_get(&translated->constants, offset), length);
hashmap_insert_GC(stack->scope, hash, key, state->registers[from_register], 0);
return no_err;
ArgonObject *key = new_string_object(data, length, prehash, hash);
hashmap_insert_GC(stack->scope, hash, key, state->registers[from_register],
0);
}

4
src/runtime/declaration/declaration.h
View File

@@ -9,7 +9,7 @@
#include "../runtime.h"
#include "../objects/string/string.h"
ArErr runtime_declaration(Translated *translated, RuntimeState *state,
struct Stack *stack);
void runtime_declaration(Translated *translated, RuntimeState *state,
struct Stack *stack, ArErr *err);
#endif // runtime_declaration_H

25
src/runtime/objects/functions/functions.c
View File

@@ -7,38 +7,43 @@
#include "../../runtime.h"
#include "../object.h"
#include "../string/string.h"
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
ArgonObject *ARGON_FUNCTION_TYPE = NULL;
ArgonObject *create_argon_native_function(char*name, native_fn native_fn) {
ArgonObject *create_argon_native_function(char *name, native_fn native_fn) {
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_FUNCTION_TYPE);
add_builtin_field(object, __class__, ARGON_FUNCTION_TYPE);
object->type = TYPE_NATIVE_FUNCTION;
add_field(object, "__name__", new_string_object(name, strlen(name)));
add_builtin_field(object, __name__,
new_string_object(name, strlen(name), 0, 0));
object->value.native_fn = native_fn;
return object;
}
void load_argon_function(Translated *translated, RuntimeState *state,
struct Stack *stack) {
struct Stack *stack) {
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_FUNCTION_TYPE);
add_builtin_field(object, __class__, ARGON_FUNCTION_TYPE);
object->type = TYPE_FUNCTION;
uint64_t offset = pop_bytecode(translated, state);
uint64_t length = pop_bytecode(translated, state);
add_field(object, "__name__", new_string_object(arena_get(&translated->constants, offset), length));
add_builtin_field(object, __name__,
new_string_object(arena_get(&translated->constants, offset),
length, 0, 0));
object->value.argon_fn.translated = *translated;
object->value.argon_fn.number_of_parameters = pop_bytecode(translated, state);
object->value.argon_fn.parameters =
ar_alloc(object->value.argon_fn.number_of_parameters * sizeof(struct string_struct));
ar_alloc(object->value.argon_fn.number_of_parameters *
sizeof(struct string_struct));
for (size_t i = 0; i < object->value.argon_fn.number_of_parameters; i++) {
offset = pop_bytecode(translated, state);
length = pop_bytecode(translated, state);
object->value.argon_fn.parameters[i].data = arena_get(&translated->constants, offset);
object->value.argon_fn.parameters[i].data =
arena_get(&translated->constants, offset);
object->value.argon_fn.parameters[i].length = length;
}
offset = pop_bytecode(translated, state);
@@ -46,5 +51,5 @@ void load_argon_function(Translated *translated, RuntimeState *state,
object->value.argon_fn.bytecode = arena_get(&translated->constants, offset);
object->value.argon_fn.bytecode_length = length;
object->value.argon_fn.stack = stack;
state->registers[0]=object;
state->registers[0] = object;
}

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

@@ -37,8 +37,8 @@ ArgonObject *ARGON_NUMBER_TYPE___new__(size_t argc, ArgonObject **argv,
ArgonObject *object = argv[1];
self->type = TYPE_STRING;
ArgonObject *boolean_convert_method = get_field_for_class(
get_field(object, "__class__", false, false), "__number__", object);
ArgonObject *boolean_convert_method = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __number__, object);
if (boolean_convert_method) {
ArgonObject *boolean_object =
argon_call(boolean_convert_method, 0, NULL, err, state);
@@ -46,8 +46,8 @@ ArgonObject *ARGON_NUMBER_TYPE___new__(size_t argc, ArgonObject **argv,
return ARGON_NULL;
return boolean_object;
}
ArgonObject *type_name = get_field_for_class(
get_field(object, "__class__", false, false), "__name__", object);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __name__, object);
*err = create_err(
0, 0, 0, "", "Runtime Error", "cannot convert type '%.*s' to number",
type_name->value.as_str.length, type_name->value.as_str.data);
@@ -85,8 +85,8 @@ ArgonObject *ARGON_NUMBER_TYPE___add__(size_t argc, ArgonObject **argv,
return ARGON_NULL;
}
if (argv[1]->type != TYPE_NUMBER) {
ArgonObject *type_name = get_field_for_class(
get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"__add__ cannot perform addition between a number and %.*s",
@@ -150,8 +150,8 @@ ArgonObject *ARGON_NUMBER_TYPE___subtract__(size_t argc, ArgonObject **argv,
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]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"__subtract__ cannot perform subtraction between number and %.*s",
@@ -216,8 +216,8 @@ ArgonObject *ARGON_NUMBER_TYPE___multiply__(size_t argc, ArgonObject **argv,
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]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_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",
@@ -241,8 +241,8 @@ ArgonObject *ARGON_NUMBER_TYPE___division__(size_t argc, ArgonObject **argv,
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]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_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",
@@ -418,8 +418,8 @@ void init_small_ints() {
for (uint64_t i = 0; i < UINT8_MAX * 2; i++) {
small_ints[i].type = TYPE_NUMBER;
small_ints[i].dict = createHashmap_GC();
add_field(&small_ints[i], "__class__", ARGON_NUMBER_TYPE);
add_field(&small_ints[i], "__base__", BASE_CLASS);
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;
@@ -428,28 +428,28 @@ void init_small_ints() {
void create_ARGON_NUMBER_TYPE() {
ARGON_NUMBER_TYPE = new_object();
add_field(ARGON_NUMBER_TYPE, "__name__",
add_builtin_field(ARGON_NUMBER_TYPE, __name__,
new_string_object_null_terminated("number"));
add_field(
ARGON_NUMBER_TYPE, "__string__",
add_builtin_field(
ARGON_NUMBER_TYPE, __string__,
create_argon_native_function("__string__", ARGON_NUMBER_TYPE___string__));
add_field(ARGON_NUMBER_TYPE, "__new__",
add_builtin_field(ARGON_NUMBER_TYPE, __new__,
create_argon_native_function("__new__", ARGON_NUMBER_TYPE___new__));
add_field(
ARGON_NUMBER_TYPE, "__number__",
add_builtin_field(
ARGON_NUMBER_TYPE, __number__,
create_argon_native_function("__number__", ARGON_NUMBER_TYPE___number__));
add_field(ARGON_NUMBER_TYPE, "__boolean__",
add_builtin_field(ARGON_NUMBER_TYPE, __boolean__,
create_argon_native_function("__boolean__",
ARGON_NUMBER_TYPE___boolean__));
add_field(ARGON_NUMBER_TYPE, "__add__",
add_builtin_field(ARGON_NUMBER_TYPE, __add__,
create_argon_native_function("__add__", ARGON_NUMBER_TYPE___add__));
add_field(ARGON_NUMBER_TYPE, "__subtract__",
add_builtin_field(ARGON_NUMBER_TYPE, __subtract__,
create_argon_native_function("__subtract__",
ARGON_NUMBER_TYPE___subtract__));
add_field(ARGON_NUMBER_TYPE, "__multiply__",
add_builtin_field(ARGON_NUMBER_TYPE, __multiply__,
create_argon_native_function("__multiply__",
ARGON_NUMBER_TYPE___multiply__));
add_field(ARGON_NUMBER_TYPE, "__division__",
add_builtin_field(ARGON_NUMBER_TYPE, __division__,
create_argon_native_function("__division__",
ARGON_NUMBER_TYPE___division__));
init_small_ints();
@@ -534,7 +534,7 @@ ArgonObject *new_number_object(mpq_t number) {
return &small_ints[i64];
}
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_NUMBER_TYPE);
add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
object->type = TYPE_NUMBER;
object->value.as_number.n.i64 = i64;
object->value.as_number.is_int64 = is_int64;
@@ -552,7 +552,7 @@ ArgonObject *new_number_object_from_num_and_den(int64_t n, uint64_t d) {
return &small_ints[(int8_t)n];
}
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_NUMBER_TYPE);
add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
object->type = TYPE_NUMBER;
if (d == 1) {
object->value.as_number.is_int64 = true;
@@ -577,7 +577,7 @@ ArgonObject *new_number_object_from_double(double d) {
return &small_ints[(int8_t)i64];
}
ArgonObject *object = new_object();
add_field(object, "__class__", ARGON_NUMBER_TYPE);
add_builtin_field(object, __class__, ARGON_NUMBER_TYPE);
object->type = TYPE_NUMBER;
object->value.as_number.n.i64 = i64;
object->value.as_number.is_int64 = is_int64;

104
src/runtime/objects/object.c
View File

@@ -15,42 +15,62 @@
ArgonObject *BASE_CLASS = NULL;
const char *built_in_field_names[BUILT_IN_FIELDS_COUNT] = {
"__base__", "__class__", "__name__", "__add__",
"__string__", "__subtract__", "__multiply__", "__division__",
"__new__", "__init__", "__boolean__", "__get_attr__",
"__binding__", "__function__", "address", "__call__",
"__number__", "log"};
uint64_t built_in_field_hashes[BUILT_IN_FIELDS_COUNT];
ArgonObject *new_object() {
ArgonObject *object = ar_alloc(sizeof(ArgonObject));
object->type = TYPE_OBJECT;
object->dict = createHashmap_GC();
add_field(object, "__class__", ARGON_TYPE_TYPE);
add_field(object, "__base__", BASE_CLASS);
add_builtin_field(object, __class__, ARGON_TYPE_TYPE);
add_builtin_field(object, __base__, BASE_CLASS);
object->as_bool = true;
return object;
}
void add_field(ArgonObject *target, char *name, ArgonObject *object) {
hashmap_insert_GC(target->dict,
siphash64_bytes(name, strlen(name), siphash_key), name,
object, 0);
void init_built_in_field_hashes() {
for (int i = 0; i < BUILT_IN_FIELDS_COUNT; i++) {
built_in_field_hashes[i] = siphash64_bytes(
built_in_field_names[i], strlen(built_in_field_names[i]), siphash_key);
}
}
void add_builtin_field(ArgonObject *target, built_in_fields field,
ArgonObject *object) {
hashmap_insert_GC(target->dict, built_in_field_hashes[field],
(char *)built_in_field_names[field], object, 0);
}
void add_field(ArgonObject *target, char *name, uint64_t hash,
ArgonObject *object) {
hashmap_insert_GC(target->dict, hash, name, object, 0);
}
ArgonObject *bind_object_to_function(ArgonObject *object,
ArgonObject *function) {
ArgonObject *bound_method_wrapper = new_object();
bound_method_wrapper->type = TYPE_METHOD;
add_field(bound_method_wrapper, "__class__", ARGON_METHOD_TYPE);
add_field(bound_method_wrapper, "__binding__", object);
add_field(bound_method_wrapper, "__function__", function);
ArgonObject *function_name = get_field(function, "__name__", false, false);
add_builtin_field(bound_method_wrapper, __class__, ARGON_METHOD_TYPE);
add_builtin_field(bound_method_wrapper, __binding__, object);
add_builtin_field(bound_method_wrapper, __function__, function);
ArgonObject *function_name =
get_builtin_field(function, __name__, false, false);
if (function_name)
add_field(bound_method_wrapper, "__name__", function_name);
add_builtin_field(bound_method_wrapper, __name__, function_name);
return bound_method_wrapper;
}
ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
size_t length, ArgonObject *binding_object) {
char *field = "__base__";
size_t field_size = strlen(field);
uint64_t hash, size_t length,
ArgonObject *binding_object) {
while (target) {
ArgonObject *object = get_field_l(target, name, length, false, false);
ArgonObject *object = get_field_l(target, name, hash, length, false, false);
if (object) {
if ((object->type == TYPE_FUNCTION ||
object->type == TYPE_NATIVE_FUNCTION) &&
@@ -59,35 +79,53 @@ ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
}
return object;
}
target = get_field_l(target, field, field_size, false, false);
target = get_builtin_field(target, __base__, false, false);
}
return NULL;
}
ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
bool recursive, bool disable_method_wrapper) {
if(!target|| !target->dict) return NULL;
char *field = "__class__";
size_t field_size = strlen(field);
ArgonObject *object = hashmap_lookup_GC(
target->dict, siphash64_bytes(name, length, siphash_key));
ArgonObject *get_field_l(ArgonObject *target, char *name, uint64_t hash,
size_t length, bool recursive,
bool disable_method_wrapper) {
ArgonObject *object = hashmap_lookup_GC(target->dict, hash);
if (!recursive || object)
return object;
ArgonObject *binding = target;
if (disable_method_wrapper)
binding = NULL;
return get_field_for_class_l(
hashmap_lookup_GC(target->dict,
siphash64_bytes(field, field_size, siphash_key)),
name, length, binding);
hashmap_lookup_GC(target->dict, built_in_field_hashes[__class__]), name,
hash, length, binding);
}
ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
bool disable_method_wrapper) {
return get_field_l(target, name, strlen(name), recursive,
disable_method_wrapper);
ArgonObject *get_builtin_field_for_class(ArgonObject *target,
built_in_fields field,
ArgonObject *binding_object) {
while (target) {
ArgonObject *object = get_builtin_field(target, field, false, false);
if (object) {
if ((object->type == TYPE_FUNCTION ||
object->type == TYPE_NATIVE_FUNCTION) &&
binding_object) {
object = bind_object_to_function(binding_object, object);
}
return object;
}
target = get_builtin_field(target, __base__, false, false);
}
return NULL;
}
ArgonObject *get_field_for_class(ArgonObject *target, char *name,
ArgonObject *binding_object) {
return get_field_for_class_l(target, name, strlen(name), binding_object);
ArgonObject *get_builtin_field(ArgonObject *target, built_in_fields field,
bool recursive, bool disable_method_wrapper) {
ArgonObject *object =
hashmap_lookup_GC(target->dict, built_in_field_hashes[field]);
if (!recursive || object)
return object;
ArgonObject *binding = target;
if (disable_method_wrapper)
binding = NULL;
return get_builtin_field_for_class(
hashmap_lookup_GC(target->dict, built_in_field_hashes[__class__]), field,
binding);
}

48
src/runtime/objects/object.h
View File

@@ -9,27 +9,59 @@
#include "../internals/hashmap/hashmap.h"
#include "../runtime.h"
#include <stdbool.h>
#include <string.h>
typedef enum {
__base__,
__class__,
__name__,
__add__,
__string__,
__subtract__,
__multiply__,
__division__,
__new__,
__init__,
__boolean__,
__get_attr__,
__binding__,
__function__,
field__address,
__call__,
__number__,
field_log,
BUILT_IN_FIELDS_COUNT
} built_in_fields;
void init_built_in_field_hashes();
extern ArgonObject *BASE_CLASS;
typedef struct ArgonObject ArgonObject;
ArgonObject *new_object();
void add_field(ArgonObject *target, char *name, ArgonObject *object);
void add_builtin_field(ArgonObject *target, built_in_fields field,
ArgonObject *object);
void add_field(ArgonObject *target, char *name, uint64_t hash,
ArgonObject *object);
ArgonObject *bind_object_to_function(ArgonObject *object,
ArgonObject *function);
ArgonObject *get_field_for_class_l(ArgonObject *target, char *name,
size_t length, ArgonObject *binding_object);
uint64_t hash, size_t length,
ArgonObject *binding_object);
ArgonObject *get_field_l(ArgonObject *target, char *name, size_t length,
bool recursive, bool disable_method_wrapper);
ArgonObject *get_field_l(ArgonObject *target, char *name, uint64_t hash,
size_t length, bool recursive,
bool disable_method_wrapper);
ArgonObject *get_field_for_class(ArgonObject *target, char *name,
ArgonObject *binding_object);
ArgonObject *get_builtin_field_for_class(ArgonObject *target,
built_in_fields field,
ArgonObject *binding_object);
ArgonObject *get_field(ArgonObject *target, char *name, bool recursive,
bool disable_method_wrapper);
ArgonObject *get_builtin_field(ArgonObject *target, built_in_fields field,
bool recursive, bool disable_method_wrapper);
#endif // OBJECT_H

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

@@ -4,28 +4,32 @@
* SPDX-License-Identifier: GPL-3.0-or-later
*/
#include "string.h"
#include "../number/number.h"
#include "../object.h"
#include <stdint.h>
#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include "string.h"
#include "../number/number.h"
ArgonObject *ARGON_STRING_TYPE = NULL;
ArgonObject *new_string_object(char*data, size_t length) {
ArgonObject * object = new_object();
add_field(object, "__class__", ARGON_STRING_TYPE);
add_field(object, "length", new_number_object_from_num_and_den(length, 1));
ArgonObject *new_string_object(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, length,
new_number_object_from_num_and_den(length, 1));
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.prehash = prehash;
object->value.as_str.hash_computed = hash;
object->value.as_str.hash = hash;
object->value.as_str.length = length;
object->as_bool = length;
return object;
}
ArgonObject *new_string_object_null_terminated(char*data) {
return new_string_object(data, strlen(data));
ArgonObject *new_string_object_null_terminated(char *data) {
return new_string_object(data, strlen(data), 0, 0);
}

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

@@ -10,7 +10,7 @@
extern ArgonObject *ARGON_STRING_TYPE;
ArgonObject *new_string_object(char*data, size_t length);
ArgonObject *new_string_object(char *data, size_t length, uint64_t prehash, uint64_t hash);
ArgonObject *new_string_object_null_terminated(char*data);
#endif // STRING_OBJ_H

4
src/runtime/objects/term/term.c
View File

@@ -13,8 +13,8 @@ ArgonObject *term_log(size_t argc, ArgonObject **argv, ArErr *err,
for (size_t i = 0; i < argc; i++) {
if (i != 0)
printf(" ");
ArgonObject *string_convert_method = get_field_for_class(
get_field(argv[i], "__class__", false, false), "__string__", argv[i]);
ArgonObject *string_convert_method = get_builtin_field_for_class(
get_builtin_field(argv[i], __class__, false, false), __string__, argv[i]);
if (string_convert_method) {
ArgonObject *string_object =

400
src/runtime/runtime.c
View File

@@ -52,17 +52,19 @@ ArgonObject *ARGON_ADDITION_FUNCTION(size_t argc, ArgonObject **argv,
}
ArgonObject *output = argv[0];
for (size_t i = 1; i < argc; i++) {
ArgonObject *__add__ = get_field_for_class(
get_field(output, "__class__", false, false), "__add__", output);
if (!__add__) {
ArgonObject *cls___name__ = get_field(output, "__name__", true, false);
ArgonObject *object__add__ = get_builtin_field_for_class(
get_builtin_field(output, __class__, false, false), __add__, output);
if (!object__add__) {
ArgonObject *cls___name__ =
get_builtin_field(output, __name__, true, false);
*err = create_err(0, 0, 0, "", "Runtime Error",
"Object '%.*s' is missing __add__ method",
(int)cls___name__->value.as_str.length,
cls___name__->value.as_str.data);
return ARGON_NULL;
}
output = argon_call(__add__, 1, (ArgonObject *[]){argv[i]}, err, state);
output =
argon_call(object__add__, 1, (ArgonObject *[]){argv[i]}, err, state);
}
return output;
}
@@ -77,18 +79,20 @@ ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv,
}
ArgonObject *output = argv[0];
for (size_t i = 1; i < argc; i++) {
ArgonObject *__subtract__ = get_field_for_class(
get_field(output, "__class__", false, false), "__subtract__", output);
if (!__subtract__) {
ArgonObject *cls___name__ = get_field(output, "__name__", true, false);
ArgonObject *function__subtract__ = get_builtin_field_for_class(
get_builtin_field(output, __class__, false, false), __subtract__,
output);
if (!function__subtract__) {
ArgonObject *cls___name__ =
get_builtin_field(output, __name__, true, false);
*err = create_err(0, 0, 0, "", "Runtime Error",
"Object '%.*s' is missing __subtract__ method",
(int)cls___name__->value.as_str.length,
cls___name__->value.as_str.data);
return ARGON_NULL;
}
output =
argon_call(__subtract__, 1, (ArgonObject *[]){argv[i]}, err, state);
output = argon_call(function__subtract__, 1, (ArgonObject *[]){argv[i]},
err, state);
}
return output;
}
@@ -103,18 +107,20 @@ ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv,
}
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);
ArgonObject *function__multiply__ = get_builtin_field_for_class(
get_builtin_field(output, __class__, false, false), __multiply__,
output);
if (!function__multiply__) {
ArgonObject *cls___name__ =
get_builtin_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);
output = argon_call(function__multiply__, 1, (ArgonObject *[]){argv[i]},
err, state);
}
return output;
}
@@ -129,18 +135,20 @@ ArgonObject *ARGON_DIVISION_FUNCTION(size_t argc, ArgonObject **argv,
}
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);
ArgonObject *function__division__ = get_builtin_field_for_class(
get_builtin_field(output, __class__, false, false), __division__,
output);
if (!function__division__) {
ArgonObject *cls___name__ =
get_builtin_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);
output = argon_call(function__division__, 1, (ArgonObject *[]){argv[i]},
err, state);
}
return output;
}
@@ -156,14 +164,16 @@ ArgonObject *ARGON_TYPE_TYPE___call__(size_t argc, ArgonObject **argv,
}
ArgonObject *cls = argv[0];
if (cls == ARGON_TYPE_TYPE && argc == 2) {
ArgonObject *cls_class = get_field(argv[1], "__class__", true, false);
ArgonObject *cls_class = get_builtin_field(argv[1], __class__, true, false);
if (cls_class)
return cls_class;
return ARGON_NULL;
}
ArgonObject *cls___new__ = get_field_for_class(argv[0], "__new__", NULL);
ArgonObject *cls___new__ =
get_builtin_field_for_class(argv[0], __new__, NULL);
if (!cls___new__) {
ArgonObject *cls___name__ = get_field(argv[0], "__name__", true, false);
ArgonObject *cls___name__ =
get_builtin_field(argv[0], __name__, true, false);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"Object '%.*s' is missing __new__ method, so cannot be initialised",
@@ -181,9 +191,10 @@ ArgonObject *ARGON_TYPE_TYPE___call__(size_t argc, ArgonObject **argv,
ARGON_TYPE_TYPE___call___args, err, state);
if (new_object_class != ARGON_NULL && new_object_class == cls) {
ArgonObject *cls___init__ =
get_field_for_class(argv[0], "__init__", new_object);
get_builtin_field_for_class(argv[0], __init__, new_object);
if (!cls___init__) {
ArgonObject *cls___name__ = get_field(argv[0], "__name__", true, false);
ArgonObject *cls___name__ =
get_builtin_field(argv[0], __name__, true, false);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"Object '%.*s' is missing __init__ method, so cannot be initialised",
@@ -222,7 +233,7 @@ ArgonObject *BASE_CLASS___new__(size_t argc, ArgonObject **argv, ArErr *err,
return ARGON_NULL;
}
ArgonObject *new_obj = new_object();
add_field(new_obj, "__class__", argv[0]);
add_builtin_field(new_obj, __class__, argv[0]);
return new_obj;
}
@@ -245,9 +256,10 @@ ArgonObject *BASE_CLASS___string__(size_t argc, ArgonObject **argv, ArErr *err,
"__string__ expects 1 arguments, got %" PRIu64, argc);
}
ArgonObject *object_name = get_field_for_class(argv[0], "__name__", NULL);
ArgonObject *class_name = get_field_for_class(
get_field(argv[0], "__class__", false, false), "__name__", NULL);
ArgonObject *object_name =
get_builtin_field_for_class(argv[0], __name__, NULL);
ArgonObject *class_name = get_builtin_field_for_class(
get_builtin_field(argv[0], __class__, false, false), __name__, NULL);
char buffer[100];
if (class_name && object_name)
@@ -285,8 +297,8 @@ ArgonObject *ARGON_STRING_TYPE___init__(size_t argc, ArgonObject **argv,
self->value.as_str.data = NULL;
self->value.as_str.length = 0;
self->type = TYPE_STRING;
ArgonObject *string_convert_method = get_field_for_class(
get_field(object, "__class__", false, false), "__string__", object);
ArgonObject *string_convert_method = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __string__, object);
if (string_convert_method) {
ArgonObject *string_object =
argon_call(string_convert_method, 0, NULL, err, state);
@@ -312,8 +324,8 @@ ArgonObject *ARGON_BOOL_TYPE___new__(size_t argc, ArgonObject **argv,
ArgonObject *object = argv[1];
self->type = TYPE_STRING;
ArgonObject *boolean_convert_method = get_field_for_class(
get_field(object, "__class__", false, false), "__boolean__", object);
ArgonObject *boolean_convert_method = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __boolean__, object);
if (boolean_convert_method) {
ArgonObject *boolean_object =
argon_call(boolean_convert_method, 0, NULL, err, state);
@@ -321,8 +333,8 @@ ArgonObject *ARGON_BOOL_TYPE___new__(size_t argc, ArgonObject **argv,
return ARGON_NULL;
return boolean_object;
}
ArgonObject *type_name = get_field_for_class(
get_field(object, "__class__", false, false), "__name__", object);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(object, __class__, false, false), __name__, object);
*err = create_err(
0, 0, 0, "", "Runtime Error", "cannot convert type '%.*s' to bool",
type_name->value.as_str.length, type_name->value.as_str.data);
@@ -338,8 +350,8 @@ ArgonObject *ARGON_STRING_TYPE___add__(size_t argc, ArgonObject **argv,
return ARGON_NULL;
}
if (argv[1]->type != TYPE_STRING) {
ArgonObject *type_name = get_field_for_class(
get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
ArgonObject *type_name = get_builtin_field_for_class(
get_builtin_field(argv[1], __class__, false, false), __name__, argv[1]);
*err = create_err(
0, 0, 0, "", "Runtime Error",
"__add__ cannot perform concatenation between a string and %.*s",
@@ -351,7 +363,7 @@ ArgonObject *ARGON_STRING_TYPE___add__(size_t argc, ArgonObject **argv,
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);
ArgonObject *object = new_string_object(concat, length, 0, 0);
free(concat);
return object;
}
@@ -467,97 +479,104 @@ ArgonObject *ARGON_NULL_TYPE___string__(size_t argc, ArgonObject **argv,
void bootstrap_types() {
BASE_CLASS = new_object();
ARGON_TYPE_TYPE = new_object();
add_field(ARGON_TYPE_TYPE, "__base__", BASE_CLASS);
add_field(ARGON_TYPE_TYPE, "__class__", ARGON_TYPE_TYPE);
add_builtin_field(ARGON_TYPE_TYPE, __base__, BASE_CLASS);
add_builtin_field(ARGON_TYPE_TYPE, __class__, ARGON_TYPE_TYPE);
ARGON_NULL_TYPE = new_object();
add_field(ARGON_NULL_TYPE, "__base__", BASE_CLASS);
add_builtin_field(ARGON_NULL_TYPE, __base__, BASE_CLASS);
ARGON_NULL = new_object();
add_field(ARGON_NULL, "__class__", ARGON_NULL_TYPE);
add_builtin_field(ARGON_NULL, __class__, ARGON_NULL_TYPE);
ARGON_NULL->as_bool = false;
add_field(BASE_CLASS, "__base__", NULL);
add_field(BASE_CLASS, "__class__", ARGON_TYPE_TYPE);
add_builtin_field(BASE_CLASS, __base__, NULL);
add_builtin_field(BASE_CLASS, __class__, ARGON_TYPE_TYPE);
ARGON_BOOL_TYPE = new_object();
add_field(ARGON_BOOL_TYPE, "__base__", BASE_CLASS);
add_builtin_field(ARGON_BOOL_TYPE, __base__, BASE_CLASS);
ARGON_TRUE = new_object();
add_field(ARGON_TRUE, "__class__", ARGON_BOOL_TYPE);
add_builtin_field(ARGON_TRUE, __class__, ARGON_BOOL_TYPE);
ARGON_FALSE = new_object();
add_field(ARGON_FALSE, "__class__", ARGON_BOOL_TYPE);
add_builtin_field(ARGON_FALSE, __class__, ARGON_BOOL_TYPE);
ARGON_NULL->as_bool = false;
ARGON_STRING_TYPE = new_object();
add_field(ARGON_STRING_TYPE, "__base__", BASE_CLASS);
add_builtin_field(ARGON_STRING_TYPE, __base__, BASE_CLASS);
add_field(ARGON_STRING_TYPE, "__name__",
new_string_object_null_terminated("string"));
add_field(BASE_CLASS, "__name__",
new_string_object_null_terminated("object"));
add_field(ARGON_TYPE_TYPE, "__name__",
new_string_object_null_terminated("type"));
add_field(ARGON_NULL_TYPE, "__name__",
new_string_object_null_terminated("null_type"));
add_field(ARGON_BOOL_TYPE, "__name__",
new_string_object_null_terminated("boolean"));
add_builtin_field(ARGON_STRING_TYPE, __name__,
new_string_object_null_terminated("string"));
add_builtin_field(BASE_CLASS, __name__,
new_string_object_null_terminated("object"));
add_builtin_field(ARGON_TYPE_TYPE, __name__,
new_string_object_null_terminated("type"));
add_builtin_field(ARGON_NULL_TYPE, __name__,
new_string_object_null_terminated("null_type"));
add_builtin_field(ARGON_BOOL_TYPE, __name__,
new_string_object_null_terminated("boolean"));
ARGON_FUNCTION_TYPE = new_object();
add_field(ARGON_FUNCTION_TYPE, "__base__", BASE_CLASS);
add_field(ARGON_FUNCTION_TYPE, "__name__",
new_string_object_null_terminated("function"));
add_builtin_field(ARGON_FUNCTION_TYPE, __base__, BASE_CLASS);
add_builtin_field(ARGON_FUNCTION_TYPE, __name__,
new_string_object_null_terminated("function"));
ARGON_METHOD_TYPE = new_object();
add_field(ARGON_METHOD_TYPE, "__base__", BASE_CLASS);
add_field(ARGON_METHOD_TYPE, "__name__",
new_string_object_null_terminated("method"));
add_builtin_field(ARGON_METHOD_TYPE, __base__, BASE_CLASS);
add_builtin_field(ARGON_METHOD_TYPE, __name__,
new_string_object_null_terminated("method"));
create_ARGON_NUMBER_TYPE();
add_field(BASE_CLASS, "__new__",
create_argon_native_function("__new__", BASE_CLASS___new__));
add_field(BASE_CLASS, "address",
create_argon_native_function("address", BASE_CLASS_address));
add_field(BASE_CLASS, "__init__",
create_argon_native_function("__init__", BASE_CLASS___new__));
add_field(BASE_CLASS, "__string__",
create_argon_native_function("__string__", BASE_CLASS___string__));
add_field(ARGON_TYPE_TYPE, "__call__",
create_argon_native_function("__call__", ARGON_TYPE_TYPE___call__));
add_field(
ARGON_STRING_TYPE, "__init__",
add_builtin_field(
BASE_CLASS, __new__,
create_argon_native_function("__new__", BASE_CLASS___new__));
add_builtin_field(
BASE_CLASS, field__address,
create_argon_native_function("address", BASE_CLASS_address));
add_builtin_field(
BASE_CLASS, __init__,
create_argon_native_function("__init__", BASE_CLASS___new__));
add_builtin_field(
BASE_CLASS, __string__,
create_argon_native_function("__string__", BASE_CLASS___string__));
add_builtin_field(
ARGON_TYPE_TYPE, __call__,
create_argon_native_function("__call__", ARGON_TYPE_TYPE___call__));
add_builtin_field(
ARGON_STRING_TYPE, __init__,
create_argon_native_function("__init__", ARGON_STRING_TYPE___init__));
add_field(ARGON_STRING_TYPE, "__add__",
create_argon_native_function("__add__", ARGON_STRING_TYPE___add__));
add_field(
ARGON_STRING_TYPE, "__number__",
add_builtin_field(
ARGON_STRING_TYPE, __add__,
create_argon_native_function("__add__", ARGON_STRING_TYPE___add__));
add_builtin_field(
ARGON_STRING_TYPE, __number__,
create_argon_native_function("__number__", ARGON_STRING_TYPE___number__));
add_field(
ARGON_NULL_TYPE, "__boolean__",
add_builtin_field(
ARGON_NULL_TYPE, __boolean__,
create_argon_native_function("__boolean__", ARGON_NULL_TYPE___boolean__));
add_field(
ARGON_NULL_TYPE, "__string__",
add_builtin_field(
ARGON_NULL_TYPE, __string__,
create_argon_native_function("__string__", ARGON_NULL_TYPE___string__));
add_field(
ARGON_NULL_TYPE, "__number__",
add_builtin_field(
ARGON_NULL_TYPE, __number__,
create_argon_native_function("__number__", ARGON_NULL_TYPE___number__));
add_field(
ARGON_STRING_TYPE, "__string__",
add_builtin_field(
ARGON_STRING_TYPE, __string__,
create_argon_native_function("__string__", ARGON_STRING_TYPE___string__));
add_field(ARGON_BOOL_TYPE, "__new__",
create_argon_native_function("__new__", ARGON_BOOL_TYPE___new__));
add_field(
ARGON_BOOL_TYPE, "__boolean__",
add_builtin_field(
ARGON_BOOL_TYPE, __new__,
create_argon_native_function("__new__", ARGON_BOOL_TYPE___new__));
add_builtin_field(
ARGON_BOOL_TYPE, __boolean__,
create_argon_native_function("__boolean__", ARGON_BOOL_TYPE___boolean__));
add_field(ARGON_STRING_TYPE, "__boolean__",
create_argon_native_function("__boolean__",
ARGON_STRING_TYPE___boolean__));
add_field(
BASE_CLASS, "__boolean__",
add_builtin_field(ARGON_STRING_TYPE, __boolean__,
create_argon_native_function(
"__boolean__", ARGON_STRING_TYPE___boolean__));
add_builtin_field(
BASE_CLASS, __boolean__,
create_argon_native_function("__boolean__", BASE_CLASS___boolean__));
add_field(
ARGON_BOOL_TYPE, "__string__",
add_builtin_field(
ARGON_BOOL_TYPE, __string__,
create_argon_native_function("__string__", ARGON_BOOL_TYPE___string__));
add_field(
ARGON_BOOL_TYPE, "__number__",
add_builtin_field(
ARGON_BOOL_TYPE, __number__,
create_argon_native_function("__number__", ARGON_BOOL_TYPE___number__));
ACCESS_FUNCTION = create_argon_native_function("__get_attr__",
ARGON_TYPE_TYPE___get_attr__);
@@ -569,13 +588,13 @@ void bootstrap_types() {
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);
add_builtin_field(BASE_CLASS, __get_attr__, ACCESS_FUNCTION);
}
void add_to_scope(Stack *stack, char *name, ArgonObject *value) {
size_t length = strlen(name);
uint64_t hash = siphash64_bytes(name, length, siphash_key);
ArgonObject *key = new_string_object(name, length);
ArgonObject *key = new_string_object(name, length, 0, 0);
hashmap_insert_GC(stack->scope, hash, key, value, 0);
}
@@ -591,8 +610,9 @@ void bootstrap_globals() {
add_to_scope(Global_Scope, "division", DIVISION_FUNCTION);
ArgonObject *argon_term = new_object();
add_field(argon_term, "__init__", ARGON_NULL);
add_field(argon_term, "log", create_argon_native_function("log", term_log));
add_builtin_field(argon_term, __init__, ARGON_NULL);
add_builtin_field(argon_term, field_log,
create_argon_native_function("log", term_log));
add_to_scope(Global_Scope, "term", argon_term);
}
@@ -609,7 +629,7 @@ static inline void load_const(Translated *translated, RuntimeState *state) {
void *data = ar_alloc_atomic(length);
memcpy(data, arena_get(&translated->constants, offset), length);
ArgonObject *object = new_string_object(data, length);
ArgonObject *object = new_string_object(data, length, 0, 0);
state->registers[to_register] = object;
}
@@ -618,7 +638,7 @@ struct hashmap *runtime_hash_table = NULL;
uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash) {
if (!runtime_hash_table) {
runtime_hash_table = createHashmap();
} else {
} else if (prehash) {
void *result = hashmap_lookup(runtime_hash_table, prehash);
if (result) {
return (uint64_t)result;
@@ -629,8 +649,8 @@ uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash) {
return hash;
}
static inline ArErr load_variable(Translated *translated, RuntimeState *state,
struct Stack *stack) {
static inline void load_variable(Translated *translated, RuntimeState *state,
struct Stack *stack, ArErr *err) {
int64_t length = pop_bytecode(translated, state);
int64_t offset = pop_bytecode(translated, state);
uint64_t prehash = pop_bytecode(translated, state);
@@ -641,72 +661,70 @@ static inline ArErr load_variable(Translated *translated, RuntimeState *state,
ArgonObject *result = hashmap_lookup_GC(current_stack->scope, hash);
if (result) {
state->registers[0] = result;
return no_err;
return;
}
current_stack = current_stack->prev;
}
ArErr err =
create_err(state->source_location.line, state->source_location.column,
state->source_location.length, state->path, "Name Error",
"name '%.*s' is not defined", (int)length,
arena_get(&translated->constants, offset));
return err;
*err = create_err(state->source_location.line, state->source_location.column,
state->source_location.length, state->path, "Name Error",
"name '%.*s' is not defined", (int)length,
arena_get(&translated->constants, offset));
return;
}
static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
struct Stack **stack) {
static void *dispatch_table[] = {[OP_LOAD_STRING] = &&DO_LOAD_STRING,
[OP_DECLARE] = &&DO_DECLARE,
[OP_LOAD_NULL] = &&DO_LOAD_NULL,
[OP_LOAD_FUNCTION] = &&DO_LOAD_FUNCTION,
[OP_IDENTIFIER] = &&DO_IDENTIFIER,
[OP_BOOL] = &&DO_BOOL,
[OP_JUMP_IF_FALSE] = &&DO_JUMP_IF_FALSE,
[OP_JUMP] = &&DO_JUMP,
[OP_NEW_SCOPE] = &&DO_NEW_SCOPE,
[OP_POP_SCOPE] = &&DO_POP_SCOPE,
[OP_INIT_CALL] = &&DO_INIT_CALL,
[OP_INSERT_ARG] = &&DO_INSERT_ARG,
[OP_CALL] = &&DO_CALL,
[OP_SOURCE_LOCATION] = &&DO_SOURCE_LOCATION,
[OP_LOAD_BOOL] = &&DO_LOAD_BOOL,
[OP_LOAD_NUMBER] = &&DO_LOAD_NUMBER,
[OP_ASSIGN] = &&DO_ASSIGN,
[OP_COPY_TO_REGISTER] =
&&DO_COPY_TO_REGISTER,
[OP_ADDITION] = &&DO_ADDITION,
[OP_SUBTRACTION] = &&DO_SUBTRACTION,
[OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION};
static inline void run_instruction(Translated *translated, RuntimeState *state,
struct Stack **stack, ArErr *err) {
static void *dispatch_table[] = {
[OP_LOAD_STRING] = &&DO_LOAD_STRING,
[OP_DECLARE] = &&DO_DECLARE,
[OP_LOAD_NULL] = &&DO_LOAD_NULL,
[OP_LOAD_FUNCTION] = &&DO_LOAD_FUNCTION,
[OP_IDENTIFIER] = &&DO_IDENTIFIER,
[OP_BOOL] = &&DO_BOOL,
[OP_JUMP_IF_FALSE] = &&DO_JUMP_IF_FALSE,
[OP_JUMP] = &&DO_JUMP,
[OP_NEW_SCOPE] = &&DO_NEW_SCOPE,
[OP_POP_SCOPE] = &&DO_POP_SCOPE,
[OP_INIT_CALL] = &&DO_INIT_CALL,
[OP_INSERT_ARG] = &&DO_INSERT_ARG,
[OP_CALL] = &&DO_CALL,
[OP_SOURCE_LOCATION] = &&DO_SOURCE_LOCATION,
[OP_LOAD_BOOL] = &&DO_LOAD_BOOL,
[OP_LOAD_NUMBER] = &&DO_LOAD_NUMBER,
[OP_ASSIGN] = &&DO_ASSIGN,
[OP_COPY_TO_REGISTER] = &&DO_COPY_TO_REGISTER,
[OP_ADDITION] = &&DO_ADDITION,
[OP_SUBTRACTION] = &&DO_SUBTRACTION,
[OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION};
goto *dispatch_table[pop_byte(translated, state)];
DO_LOAD_NULL:
state->registers[pop_byte(translated, state)] = ARGON_NULL;
goto BREAK;
return;
DO_LOAD_STRING:
load_const(translated, state);
goto BREAK;
return;
DO_LOAD_NUMBER:
load_number(translated, state);
goto BREAK;
return;
DO_LOAD_FUNCTION:
load_argon_function(translated, state, *stack);
goto BREAK;
return;
DO_IDENTIFIER:
return load_variable(translated, state, *stack);
return load_variable(translated, state, *stack, err);
DO_DECLARE:
return runtime_declaration(translated, state, *stack);
return runtime_declaration(translated, state, *stack, err);
DO_ASSIGN:
return runtime_assignment(translated, state, *stack);
DO_BOOL: {
uint8_t to_register = pop_byte(translated, state);
if (state->registers[0]->type != TYPE_OBJECT) {
if (likely(state->registers[0]->type != TYPE_OBJECT)) {
state->registers[to_register] =
state->registers[0]->as_bool ? ARGON_TRUE : ARGON_FALSE;
goto BREAK;
return;
}
ArErr err = no_err;
ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]};
state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, &err, state);
return err;
state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, err, state);
return;
}
DO_JUMP_IF_FALSE: {
uint8_t from_register = pop_byte(translated, state);
@@ -714,17 +732,17 @@ DO_JUMP_IF_FALSE: {
if (state->registers[from_register] == ARGON_FALSE) {
state->head = to;
}
goto BREAK;
return;
}
DO_JUMP:
state->head = pop_bytecode(translated, state);
goto BREAK;
return;
DO_NEW_SCOPE:
*stack = create_scope(*stack);
goto BREAK;
return;
DO_POP_SCOPE:
*stack = (*stack)->prev;
goto BREAK;
return;
DO_INIT_CALL: {
size_t length = pop_bytecode(translated, state);
call_instance call_instance = {state->call_instance, state->registers[0],
@@ -732,35 +750,34 @@ DO_INIT_CALL: {
length};
state->call_instance = ar_alloc(sizeof(call_instance));
*state->call_instance = call_instance;
goto BREAK;
return;
}
DO_INSERT_ARG:;
size_t index = pop_bytecode(translated, state);
state->call_instance->args[index] = state->registers[0];
goto BREAK;
return;
DO_CALL: {
ArErr err =
run_call(state->call_instance->to_call, state->call_instance->args_length,
state->call_instance->args, state, false);
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;
return err;
return;
}
DO_SOURCE_LOCATION:
state->source_location = (SourceLocation){pop_bytecode(translated, state),
pop_bytecode(translated, state),
pop_bytecode(translated, state)};
goto BREAK;
return;
DO_LOAD_BOOL:
state->registers[0] = pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE;
goto BREAK;
return;
DO_LOAD_ACCESS_FUNCTION:
state->registers[0] = ACCESS_FUNCTION;
goto BREAK;
return;
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 BREAK;
return;
}
DO_ADDITION: {
uint8_t registerA = pop_byte(translated, state);
@@ -770,8 +787,9 @@ DO_ADDITION: {
ArgonObject *valueA = state->registers[registerA];
ArgonObject *valueB = state->registers[registerB];
if (valueA->type == TYPE_NUMBER && valueB->type == TYPE_NUMBER) {
if (valueA->value.as_number.is_int64 && valueB->value.as_number.is_int64) {
if (likely(valueA->type == TYPE_NUMBER && valueB->type == TYPE_NUMBER)) {
if (likely(valueA->value.as_number.is_int64 &&
valueB->value.as_number.is_int64)) {
int64_t a = valueA->value.as_number.n.i64;
int64_t b = valueB->value.as_number.n.i64;
bool gonna_overflow = (a > 0 && b > 0 && a > INT64_MAX - b) ||
@@ -779,7 +797,7 @@ DO_ADDITION: {
if (!gonna_overflow) {
state->registers[registerC] =
new_number_object_from_num_and_den(a + b, 1);
goto BREAK;
return;
}
mpq_t a_GMP, b_GMP;
mpq_init(a_GMP);
@@ -814,13 +832,12 @@ DO_ADDITION: {
mpq_clear(a_GMP);
mpq_clear(b_GMP);
}
goto BREAK;
return;
}
ArErr err = no_err;
ArgonObject *args[] = {valueA, valueB};
state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, &err, state);
return err;
state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, err, state);
return;
}
DO_SUBTRACTION: {
uint8_t registerA = pop_byte(translated, state);
@@ -830,8 +847,9 @@ DO_SUBTRACTION: {
ArgonObject *valueA = state->registers[registerA];
ArgonObject *valueB = state->registers[registerB];
if (valueA->type == TYPE_NUMBER && valueB->type == TYPE_NUMBER) {
if (valueA->value.as_number.is_int64 && valueB->value.as_number.is_int64) {
if (likely(valueA->type == TYPE_NUMBER && valueB->type == TYPE_NUMBER)) {
if (likely(valueA->value.as_number.is_int64 &&
valueB->value.as_number.is_int64)) {
int64_t a = valueA->value.as_number.n.i64;
int64_t b = valueB->value.as_number.n.i64;
int64_t neg_a = -a;
@@ -840,7 +858,7 @@ DO_SUBTRACTION: {
if (!gonna_overflow) {
state->registers[registerC] =
new_number_object_from_num_and_den(a - b, 1);
goto BREAK;
return;
}
mpq_t a_GMP, b_GMP;
mpq_init(a_GMP);
@@ -875,17 +893,13 @@ DO_SUBTRACTION: {
mpq_clear(a_GMP);
mpq_clear(b_GMP);
}
goto BREAK;
return;
}
ArErr err = no_err;
ArgonObject *args[] = {valueA, valueB};
state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, &err, state);
return err;
state->registers[registerC] = ARGON_ADDITION_FUNCTION(2, args, err, state);
return;
}
BREAK:
return no_err;
}
RuntimeState init_runtime_state(Translated translated, char *path) {
@@ -907,23 +921,21 @@ Stack *create_scope(Stack *prev) {
return stack;
}
ArErr runtime(Translated translated, RuntimeState state, Stack *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;
ArErr err = no_err;
while (currentStackFrame) {
while (currentStackFrame->state.head <
currentStackFrame->translated.bytecode.size &&
!err.exists) {
err =
run_instruction(&currentStackFrame->translated,
&currentStackFrame->state, &currentStackFrame->stack);
while (likely(currentStackFrame->state.head <
currentStackFrame->translated.bytecode.size &&
!err->exists)) {
run_instruction(&currentStackFrame->translated, &currentStackFrame->state,
&currentStackFrame->stack, err);
}
currentStackFrame = currentStackFrame->previousStackFrame;
}
return err;
}

28
src/runtime/runtime.h
View File

@@ -11,6 +11,9 @@
#include "internals/dynamic_array_armem/darray_armem.h"
#include "internals/hashmap/hashmap.h"
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
extern ArgonObject *ARGON_METHOD_TYPE;
extern Stack *Global_Scope;
@@ -64,26 +67,29 @@ uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash);
void bootstrap_globals();
static inline void *arena_get(ConstantArena *arena, size_t offset) {
return (char*)arena->data + offset;
}
static inline uint8_t pop_byte(Translated *translated, RuntimeState *state) {
return *((uint8_t *)darray_get(&translated->bytecode, state->head++));
return ((uint8_t *)(translated->bytecode.data))[state->head++];
}
static inline uint64_t pop_bytecode(Translated *translated,
RuntimeState *state) {
uint64_t value = 0;
for (int i = 0; i < 8; i++) {
value |= ((uint64_t)pop_byte(translated, state)) << (i * 8);
}
return value;
static inline uint64_t pop_bytecode(Translated *translated, RuntimeState *state) {
uint64_t *ptr = (uint64_t *)((uint8_t*)translated->bytecode.data + state->head);
uint64_t value = *ptr;
state->head += 8;
return value;
}
static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
struct Stack **stack);
static inline void run_instruction(Translated *translated, RuntimeState *state,
struct Stack **stack, ArErr*err);
RuntimeState init_runtime_state(Translated translated, char *path);
Stack *create_scope(Stack *prev);
ArErr runtime(Translated translated, RuntimeState state, Stack *stack);
void runtime(Translated translated, RuntimeState state, Stack *stack,
ArErr *err);
#endif // RUNTIME_H

2
src/shell.c
View File

@@ -108,7 +108,7 @@ int execute_code(FILE *stream, char *path, Stack *scope,
darray_free(&__translated.bytecode, NULL);
free(__translated.constants.data);
*runtime_state = init_runtime_state(translated, path);
err = runtime(translated, *runtime_state, scope);
runtime(translated, *runtime_state, scope, &err);
if (err.exists) {
output_err(err);
return 1;

4
src/translator/translator.c
View File

@@ -51,10 +51,6 @@ void arena_resize(ConstantArena *arena, size_t new_size) {
arena->capacity = new_capacity;
}
void *arena_get(ConstantArena *arena, size_t offset) {
return arena->data + offset;
}
size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
uint64_t hash = siphash64_bytes(data, length, siphash_key);

2
src/translator/translator.h
View File

@@ -40,8 +40,6 @@ typedef enum {
void arena_resize(ConstantArena *arena, size_t new_size);
void *arena_get(ConstantArena *arena, size_t offset);
size_t arena_push(ConstantArena *arena, const void *data, size_t length);
size_t push_instruction_byte(Translated *translator, uint8_t byte);