From 712bc9a45a55529604589ee41e3b7f360e52d52d Mon Sep 17 00:00:00 2001 From: Brendan Hansen Date: Mon, 25 Oct 2021 12:29:26 -0500 Subject: [PATCH] cleaned up trying operator overloads --- core/sync/barrier.onyx | 2 +- core/sync/mutex.onyx | 11 ++++++++-- modules/wasm_utils/parser.onyx | 5 +++-- modules/wasm_utils/types.onyx | 4 ++-- src/checker.c | 37 +++++++++++++++++++--------------- 5 files changed, 36 insertions(+), 23 deletions(-) diff --git a/core/sync/barrier.onyx b/core/sync/barrier.onyx index 8e7e8425..b31fc696 100644 --- a/core/sync/barrier.onyx +++ b/core/sync/barrier.onyx @@ -41,4 +41,4 @@ barrier_wait :: (b: ^Barrier) { b.generation += 1; condition_broadcast(^b.cond); return; -} \ No newline at end of file +} diff --git a/core/sync/mutex.onyx b/core/sync/mutex.onyx index 1211ecf4..19cc3894 100644 --- a/core/sync/mutex.onyx +++ b/core/sync/mutex.onyx @@ -31,7 +31,14 @@ mutex_destroy :: (m: ^Mutex) { mutex_lock :: (m: ^Mutex) { while __atomic_cmpxchg(^m.lock, 0, 1) == 1 { if m.owner == context.thread_id do return; - __atomic_wait(^m.lock, 1); + + @ThreadingCleanup // You cannot wait on the main thread in + // a web browser, for kind of obvious reasons. However, this + // makes waiting for a mutex expensive because the only option + // is to do a spin-lock. Ugh. + if context.thread_id != 0 { + __atomic_wait(^m.lock, 1); + } } m.owner = context.thread_id; @@ -59,4 +66,4 @@ critical_section :: macro (m: ^Mutex, body: Code) -> i32 { #insert body; return 0; -} \ No newline at end of file +} diff --git a/modules/wasm_utils/parser.onyx b/modules/wasm_utils/parser.onyx index 5cd73321..1b509e27 100644 --- a/modules/wasm_utils/parser.onyx +++ b/modules/wasm_utils/parser.onyx @@ -295,8 +295,9 @@ parse_code_section :: (use bin: ^WasmBinary, allocator := context.allocator) -> } #private -parse_vector :: (reader: ^io.Reader, bin: ^WasmBinary, - read: (^io.Reader, ^WasmBinary) -> $T) -> [] T { +parse_vector :: macro (reader: ^io.Reader, bin: ^WasmBinary, + read: (^io.Reader, ^WasmBinary) -> $T) -> [] T { + wasm_allocator :: wasm_allocator; n := cast(u32) read_uleb128(reader); result := memory.make_slice(T, n, allocator=wasm_allocator); diff --git a/modules/wasm_utils/types.onyx b/modules/wasm_utils/types.onyx index 7812005d..d290d8ef 100644 --- a/modules/wasm_utils/types.onyx +++ b/modules/wasm_utils/types.onyx @@ -63,9 +63,9 @@ WasmImport :: struct { module_name : str; import_name : str; - type : WasmForeignType; + type : WasmForeignType; - use __: struct #union { + use _: struct #union { index : u32; limits : WasmLimits; }; diff --git a/src/checker.c b/src/checker.c index f0c2c4b7..8be7267d 100644 --- a/src/checker.c +++ b/src/checker.c @@ -598,33 +598,29 @@ static AstCall* binaryop_try_operator_overload(AstBinaryOp* binop, AstTyped* thi args.values = (AstTyped **) &value_buffer[sizeof(bh__arr)]; bh_arr_set_length(args.values, third_argument ? 3 : 2); - args.values[0] = (AstTyped *) make_argument(context.ast_alloc, binop->left); - args.values[1] = (AstTyped *) make_argument(context.ast_alloc, binop->right); - if (third_argument != NULL) args.values[2] = (AstTyped *) make_argument(context.ast_alloc, third_argument); - - u32 current_all_checks_are_final = all_checks_are_final; - all_checks_are_final = 0; - u32 current_checking_level_store = current_checking_level; - bh_arr_each(AstTyped *, v, args.values) check_argument((AstArgument **) v); - current_checking_level = current_checking_level_store; - all_checks_are_final = current_all_checks_are_final; - if (binop_is_assignment(binop->operation)) { args.values[0] = (AstTyped *) make_address_of(context.ast_alloc, binop->left); + u32 current_all_checks_are_final = all_checks_are_final; + all_checks_are_final = 0; u32 current_checking_level_store = current_checking_level; CheckStatus cs = check_address_of((AstAddressOf **) &args.values[0]); current_checking_level = current_checking_level_store; + all_checks_are_final = current_all_checks_are_final; - if (cs == Check_Yield_Macro) return (AstCall *) &node_that_signals_a_yield; - if (cs == Check_Error) return NULL; + if (cs == Check_Yield_Macro) return (AstCall *) &node_that_signals_a_yield; + if (cs == Check_Error) return NULL; args.values[0] = (AstTyped *) make_argument(context.ast_alloc, args.values[0]); - current_checking_level_store = current_checking_level; - check_argument((AstArgument **) &args.values[0]); - current_checking_level = current_checking_level_store; + + } else { + args.values[0] = (AstTyped *) make_argument(context.ast_alloc, binop->left); } + + args.values[1] = (AstTyped *) make_argument(context.ast_alloc, binop->right); + if (third_argument != NULL) args.values[2] = (AstTyped *) make_argument(context.ast_alloc, third_argument); + b32 should_yield = 0; AstTyped* overload = find_matching_overload_by_arguments(operator_overloads[binop->operation], &args, &should_yield); if (should_yield) return (AstCall *) &node_that_signals_a_yield; @@ -863,6 +859,14 @@ CheckStatus check_binaryop(AstBinaryOp** pbinop) { if (binop->flags & Ast_Flag_Has_Been_Checked) return Check_Success; if (binop->operation == Binary_Op_Assign && binop->left->kind == Ast_Kind_Subscript && bh_arr_length(operator_overloads[Binary_Op_Subscript_Equals]) > 0) { + AstSubscript* sub = (AstSubscript *) binop->left; + + u32 current_checking_level_store = current_checking_level; + CHECK(expression, &sub->addr); + CHECK(expression, &sub->expr); + CHECK(expression, &binop->right); + current_checking_level = current_checking_level_store; + AstBinaryOp op; op.kind = Ast_Kind_Binary_Op; op.token = binop->token; @@ -879,6 +883,7 @@ CheckStatus check_binaryop(AstBinaryOp** pbinop) { CHECK(call, (AstCall **) pbinop); return Check_Success; } + } u32 current_checking_level_store = current_checking_level; -- 2.25.1