diff --git a/Makefile b/Makefile index 830cc35..ad28320 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/app.py b/app.py index 3a5094d..9b55f89 100644 --- a/app.py +++ b/app.py @@ -1,3 +1,4 @@ i = 1000000 while i: + print(i) i=i-1 \ No newline at end of file diff --git a/src/arobject.h b/src/arobject.h index fb05f2b..d889538 100644 --- a/src/arobject.h +++ b/src/arobject.h @@ -49,6 +49,9 @@ typedef struct { struct string_struct { char *data; + uint64_t prehash; + uint64_t hash; + bool hash_computed; size_t length; }; diff --git a/src/hash_data/hash_data.c b/src/hash_data/hash_data.c index 6ad661a..a434bb1 100644 --- a/src/hash_data/hash_data.c +++ b/src/hash_data/hash_data.c @@ -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; } \ No newline at end of file diff --git a/src/main.c b/src/main.c index 3389cae..6a15811 100644 --- a/src/main.c +++ b/src/main.c @@ -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; diff --git a/src/runtime/access/access.c b/src/runtime/access/access.c index caeacf0..3e72a37 100644 --- a/src/runtime/access/access.c +++ b/src/runtime/access/access.c @@ -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, diff --git a/src/runtime/assignment/assignment.c b/src/runtime/assignment/assignment.c index d000923..761630f 100644 --- a/src/runtime/assignment/assignment.c +++ b/src/runtime/assignment/assignment.c @@ -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; } \ No newline at end of file diff --git a/src/runtime/assignment/assignment.h b/src/runtime/assignment/assignment.h index 78fdcde..b37e1b3 100644 --- a/src/runtime/assignment/assignment.h +++ b/src/runtime/assignment/assignment.h @@ -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 \ No newline at end of file diff --git a/src/runtime/call/call.c b/src/runtime/call/call.c index 1c2954a..bee7245 100644 --- a/src/runtime/call/call.c +++ b/src/runtime/call/call.c @@ -19,8 +19,8 @@ #ifndef _WIN32_WINNT #define _WIN32_WINNT 0x0602 #endif -#include #include +#include 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, diff --git a/src/runtime/call/call.h b/src/runtime/call/call.h index 0db770d..5d26347 100644 --- a/src/runtime/call/call.h +++ b/src/runtime/call/call.h @@ -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 \ No newline at end of file diff --git a/src/runtime/declaration/declaration.c b/src/runtime/declaration/declaration.c index e249bc6..87c3800 100644 --- a/src/runtime/declaration/declaration.c +++ b/src/runtime/declaration/declaration.c @@ -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); } \ No newline at end of file diff --git a/src/runtime/declaration/declaration.h b/src/runtime/declaration/declaration.h index f90a4cb..e7acaec 100644 --- a/src/runtime/declaration/declaration.h +++ b/src/runtime/declaration/declaration.h @@ -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 \ No newline at end of file diff --git a/src/runtime/objects/functions/functions.c b/src/runtime/objects/functions/functions.c index 7ab6906..365b48e 100644 --- a/src/runtime/objects/functions/functions.c +++ b/src/runtime/objects/functions/functions.c @@ -7,38 +7,43 @@ #include "../../runtime.h" #include "../object.h" #include "../string/string.h" -#include #include #include +#include #include 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; } \ No newline at end of file diff --git a/src/runtime/objects/number/number.c b/src/runtime/objects/number/number.c index fa266ab..1c63918 100644 --- a/src/runtime/objects/number/number.c +++ b/src/runtime/objects/number/number.c @@ -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; diff --git a/src/runtime/objects/object.c b/src/runtime/objects/object.c index 6071e32..e85509c 100644 --- a/src/runtime/objects/object.c +++ b/src/runtime/objects/object.c @@ -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); } \ No newline at end of file diff --git a/src/runtime/objects/object.h b/src/runtime/objects/object.h index 1785b14..4b097f8 100644 --- a/src/runtime/objects/object.h +++ b/src/runtime/objects/object.h @@ -9,27 +9,59 @@ #include "../internals/hashmap/hashmap.h" #include "../runtime.h" #include +#include + +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 \ No newline at end of file diff --git a/src/runtime/objects/string/string.c b/src/runtime/objects/string/string.c index d643ed8..19c9fa6 100644 --- a/src/runtime/objects/string/string.c +++ b/src/runtime/objects/string/string.c @@ -4,28 +4,32 @@ * SPDX-License-Identifier: GPL-3.0-or-later */ +#include "string.h" +#include "../number/number.h" #include "../object.h" #include #include -#include #include -#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); } \ No newline at end of file diff --git a/src/runtime/objects/string/string.h b/src/runtime/objects/string/string.h index 9ef4c0f..f093741 100644 --- a/src/runtime/objects/string/string.h +++ b/src/runtime/objects/string/string.h @@ -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 \ No newline at end of file diff --git a/src/runtime/objects/term/term.c b/src/runtime/objects/term/term.c index c86a6f3..8666b2c 100644 --- a/src/runtime/objects/term/term.c +++ b/src/runtime/objects/term/term.c @@ -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 = diff --git a/src/runtime/runtime.c b/src/runtime/runtime.c index 0084e34..b3cbfe5 100644 --- a/src/runtime/runtime.c +++ b/src/runtime/runtime.c @@ -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 = ¤tStackFrame; - ArErr err = no_err; while (currentStackFrame) { - while (currentStackFrame->state.head < - currentStackFrame->translated.bytecode.size && - !err.exists) { - err = - run_instruction(¤tStackFrame->translated, - ¤tStackFrame->state, ¤tStackFrame->stack); + while (likely(currentStackFrame->state.head < + currentStackFrame->translated.bytecode.size && + !err->exists)) { + run_instruction(¤tStackFrame->translated, ¤tStackFrame->state, + ¤tStackFrame->stack, err); } currentStackFrame = currentStackFrame->previousStackFrame; } - return err; } \ No newline at end of file diff --git a/src/runtime/runtime.h b/src/runtime/runtime.h index 1408ea4..25ddacb 100644 --- a/src/runtime/runtime.h +++ b/src/runtime/runtime.h @@ -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 \ No newline at end of file diff --git a/src/shell.c b/src/shell.c index 3ab199d..43e490e 100644 --- a/src/shell.c +++ b/src/shell.c @@ -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; diff --git a/src/translator/translator.c b/src/translator/translator.c index b362283..cbba858 100644 --- a/src/translator/translator.c +++ b/src/translator/translator.c @@ -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); diff --git a/src/translator/translator.h b/src/translator/translator.h index 0657f9f..69322d0 100644 --- a/src/translator/translator.h +++ b/src/translator/translator.h @@ -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);