From de0b35ac1211ebd505121ab4a45adbb81824dc2c Mon Sep 17 00:00:00 2001 From: fennecdjay Date: Mon, 8 Aug 2022 15:51:00 +0200 Subject: [PATCH] :art: Update --- include/instr.h | 2 ++ src/emit/emit.c | 9 +++------ src/emit/emitter.c | 9 +++++++-- src/lib/object_op.c | 1 - src/parse/check.c | 46 ++++++++++++++++++++++++++++++++++++++++----- src/parse/scan1.c | 12 ++++++------ src/parse/scan2.c | 6 ++---- src/vm/shreduler.c | 15 +++++++++++---- src/vm/vm.c | 8 ++++---- 9 files changed, 76 insertions(+), 32 deletions(-) diff --git a/include/instr.h b/include/instr.h index 8a7466bd..d85e5962 100644 --- a/include/instr.h +++ b/include/instr.h @@ -35,6 +35,8 @@ struct Instr_ { }; #define BYTECODE_SZ (SZ_INT * 4) +__attribute__((returns_nonnull)) ANN2(1) Instr +new_instr(const MemPool mp, const f_instr f); ANN void free_instr(const Gwion, const Instr); INSTR(EOC); INSTR(DTOR_EOC); diff --git a/src/emit/emit.c b/src/emit/emit.c index 0958be8a..077a39c4 100644 --- a/src/emit/emit.c +++ b/src/emit/emit.c @@ -2351,12 +2351,9 @@ ANN static m_bool emit_stmt_loop(const Emitter emit, const Stmt_Loop stmt) { ANN static m_bool emit_type_def(const Emitter emit, const Type_Def tdef) { if (tdef->when_def) CHECK_BB(emit_func_def(emit, tdef->when_def)); - - if (tflag(tdef->type, tflag_cdef)) { - if(!tflag(tdef->type->info->parent, tflag_emit)) - return emit_class_def(emit, tdef->type->info->parent->info->cdef); - } - return tdef->type->info->cdef ? emit_class_def(emit, tdef->type->info->cdef) : GW_OK; + if (tflag(tdef->type, tflag_cdef)) + return emit_class_def(emit, tdef->type->info->cdef); + return GW_OK; } ANN static m_bool emit_enum_def(const Emitter emit NUSED, const Enum_Def edef) { diff --git a/src/emit/emitter.c b/src/emit/emitter.c index d15592e8..b3473321 100644 --- a/src/emit/emitter.c +++ b/src/emit/emitter.c @@ -36,14 +36,19 @@ ANN void free_emitter(MemPool p, Emitter a) { } __attribute__((returns_nonnull)) ANN2(1) Instr -emit_add_instr(const Emitter emit, const f_instr f) { - const Instr instr = mp_calloc(emit->gwion->mp, Instr); +new_instr(const MemPool mp, const f_instr f) { + const Instr instr = mp_calloc(mp, Instr); if ((m_uint)f < 255) instr->opcode = (m_uint)f; else { instr->opcode = eOP_MAX; instr->execute = f; } + return instr; +} +__attribute__((returns_nonnull)) ANN2(1) Instr +emit_add_instr(const Emitter emit, const f_instr f) { + const Instr instr = new_instr(emit->gwion->mp, f); vector_add(&emit->code->instr, (vtype)instr); return instr; } diff --git a/src/lib/object_op.c b/src/lib/object_op.c index 30c44658..3266bbce 100644 --- a/src/lib/object_op.c +++ b/src/lib/object_op.c @@ -477,6 +477,5 @@ GWION_IMPORT(object_op) { GWI_BB(gwi_oper_ini(gwi, "@Compound", NULL, NULL)) GWI_BB(gwi_oper_add(gwi, opck_struct_scan)) GWI_BB(gwi_oper_end(gwi, "@scan", NULL)) - return GW_OK; } diff --git a/src/parse/check.c b/src/parse/check.c index ff80ee37..ef7db50f 100644 --- a/src/parse/check.c +++ b/src/parse/check.c @@ -669,8 +669,32 @@ ANN static Type_List check_template_args(const Env env, Exp_Call *exp, const bool spread = is_spread_tmpl(fdef->base->tmpl); const uint32_t len = sl->len - spread; Type_List tl = new_mp_vector(env->gwion->mp, Type_Decl*, len); - m_uint args_number = 0; + + if(exp->other) { + for(uint32_t i = 0; i < len; i++) { + Specialized *spec = mp_vector_at(sl, Specialized, i); + if (spec->xid == fdef->base->td->xid) { // check no next? + CHECK_OO(check_exp(env, exp->other)); + if(!is_func(env->gwion, exp->other->type)) { + Type_Decl *td = type2td(env->gwion, exp->other->type, fdef->base->pos); + mp_vector_set(tl, Type_Decl*, 0, td); + } else { + Func func = exp->other->type->info->func; + do { + if(mp_vector_len(func->def->base->args) == 1) { + Arg *arg = mp_vector_at(func->def->base->args, Arg, 0); + Type_Decl *td = cpy_type_decl(env->gwion->mp, arg->td); + mp_vector_set(tl, Type_Decl*, 0, td); + break; + } + } while((func = func->next)); + } + ++args_number; + break; + } + } + } for(uint32_t i = 0; i < len; i++) { Specialized *spec = mp_vector_at(sl, Specialized, i); Arg_List args = fdef->base->args; @@ -913,8 +937,13 @@ ANN Type check_exp_call1(const Env env, Exp_Call *const exp) { } ANN static Type check_exp_binary(const Env env, const Exp_Binary *bin) { + if(bin->lhs->exp_type == ae_exp_call && !bin->lhs->d.exp_call.tmpl) { + CHECK_OO(check_exp(env, bin->lhs->d.exp_call.func)); + // check is template? + bin->lhs->d.exp_call.other = bin->rhs; + } CHECK_OO(check_exp(env, bin->lhs)); - const m_bool is_auto = bin->op == insert_symbol(":=>") && + const m_bool is_auto = //bin->op == insert_symbol(":=>") && bin->rhs->exp_type == ae_exp_decl && bin->rhs->d.exp_decl.type == env->gwion->type[et_auto]; if (is_auto) bin->rhs->d.exp_decl.type = bin->lhs->type; @@ -930,12 +959,19 @@ ANN static Type check_exp_binary(const Env env, const Exp_Binary *bin) { e->exp_type = ae_exp_unary; unary->unary_type = unary_td; unary->op = insert_symbol("new"); - unary->ctor.td = cpy_type_decl(env->gwion->mp, bin->rhs->d.exp_unary.ctor.td); + unary->ctor.td = new_type_decl(env->gwion->mp, insert_symbol("auto"), bin->rhs->d.exp_unary.ctor.td->pos); unary->ctor.exp = lhs; free_exp(env->gwion->mp, rhs); return check_exp(env, e); } + if(bin->rhs->exp_type == ae_exp_call && !bin->rhs->d.exp_call.tmpl) + bin->rhs->d.exp_call.other = bin->lhs; + const m_uint scope = env->scope->depth; + if(bin->op == insert_symbol(">=>")) + env_push_type(env, bin->lhs->type); CHECK_OO(check_exp(env, bin->rhs)); + if(bin->op == insert_symbol(">=>")) + env_pop(env, scope); if (is_auto) { assert(bin->rhs->type == bin->lhs->type); set_vflag(bin->rhs->d.exp_decl.vd.value, vflag_assigned); @@ -1115,8 +1151,6 @@ ANN static Type check_exp_dot(const Env env, Exp_Dot *member) { } ANN m_bool check_type_def(const Env env, const Type_Def tdef) { - if(tdef->ext->array && tdef->ext->array->exp) - CHECK_OB(check_exp(env, tdef->type->info->cdef->base.ext->array->exp)); if (tdef->when) { set_tflag(tdef->type, tflag_contract); struct Var_Decl_ decl = { .xid = insert_symbol("self"), .pos = tdef->when->pos }; @@ -1169,6 +1203,8 @@ ANN m_bool check_type_def(const Env env, const Type_Def tdef) { mp_vector_set(fdef->d.code->d.stmt_code.stmt_list, struct Stmt_, 1, ret); ret_id->type = tdef->type; } + if (tflag(tdef->type, tflag_cdef)) + return check_class_def(env, tdef->type->info->cdef); return GW_OK; } diff --git a/src/parse/scan1.c b/src/parse/scan1.c index 11590445..627379f4 100644 --- a/src/parse/scan1.c +++ b/src/parse/scan1.c @@ -190,6 +190,8 @@ ANN static inline m_bool scan1_prim(const Env env, const Exp_Primary *prim) { if (prim->prim_type == ae_prim_array && prim->d.array->exp) return scan1_exp(env, prim->d.array->exp); if (prim->prim_type == ae_prim_range) return scan1_range(env, prim->d.range); + if (env->func && prim->prim_type == ae_prim_perform && env->scope->depth <= 2) + env->func->memoize = 1; return GW_OK; } @@ -465,12 +467,10 @@ ANN m_bool scan1_fptr_def(const Env env, const Fptr_Def fptr) { } ANN m_bool scan1_type_def(const Env env, const Type_Def tdef) { - if (!tdef->type) tdef->type = nspc_lookup_type0(env->curr, tdef->xid); + //if (!tdef->type) tdef->type = nspc_lookup_type0(env->curr, tdef->xid); if (tdef->when) CHECK_BB(scan1_exp(env, tdef->when)); - if (!tflag(tdef->type, tflag_cdef)) { - if(!tflag(tdef->type->info->parent, tflag_scan1)) - return scan1_class_def(env, tdef->type->info->parent->info->cdef); - } + if (tflag(tdef->type, tflag_cdef)) + return scan1_class_def(env, tdef->type->info->cdef); return tdef->type->info->cdef ? scan1_cdef(env, tdef->type) : GW_OK; } @@ -682,7 +682,7 @@ ANN static m_bool _scan1_func_def(const Env env, const Func_Def fdef) { fdef->base->ret_type != env->gwion->type[et_void] && fdef->d.code && !fake.memoize) ERR_B(fdef->base->td->pos, - _("missing return statement in a non void function %u"), fake.memoize); + _("missing return statement in a non void function")); if (fdef->base->xid == insert_symbol("@gack") && !fake.weight) { gwerr_basic(_("`@gack` operator does not print anything"), NULL, _("use `<<<` `>>>` in the function"), env->name, fdef->base->pos, 0); diff --git a/src/parse/scan2.c b/src/parse/scan2.c index 876cc82d..4536842c 100644 --- a/src/parse/scan2.c +++ b/src/parse/scan2.c @@ -87,10 +87,8 @@ ANN m_bool scan2_fptr_def(const Env env NUSED, const Fptr_Def fptr) { ANN static m_bool scan2_func_def_op(const Env env, const Func_Def f); ANN m_bool scan2_type_def(const Env env, const Type_Def tdef) { if (tdef->when) CHECK_BB(scan2_exp(env, tdef->when)); - if (tflag(tdef->type, tflag_cdef)) { - if(!tflag(tdef->type->info->parent, tflag_scan2)) - return scan2_class_def(env, tdef->type->info->parent->info->cdef); - } + if (tflag(tdef->type, tflag_cdef)) + return scan2_class_def(env, tdef->type->info->cdef); if (!tdef->type->info->cdef) return GW_OK; return tdef->type->info->cdef ? scan2_class_def(env, tdef->type->info->cdef) : GW_OK; } diff --git a/src/vm/shreduler.c b/src/vm/shreduler.c index 7e647175..bd793d97 100644 --- a/src/vm/shreduler.c +++ b/src/vm/shreduler.c @@ -76,11 +76,9 @@ ANN void shreduler_remove(const Shreduler s, const VM_Shred out, MUTEX_UNLOCK(s->mutex); } -ANN void shredule(const Shreduler s, const VM_Shred shred, +ANN void _shredule(const Shreduler s, struct ShredTick_ *tk, const m_float wake_time) { - struct ShredTick_ *tk = shred->tick; if(tk->prev == (struct ShredTick_*)-1) return; - MUTEX_LOCK(s->mutex); const m_float time = wake_time + (m_float)s->bbq->pos; tk->wake_time = time; if (s->list) { @@ -100,6 +98,13 @@ ANN void shredule(const Shreduler s, const VM_Shred shred, } else s->list = tk; if (tk == s->curr) s->curr = NULL; +} + +ANN void shredule(const Shreduler s, const VM_Shred shred, + const m_float wake_time) { + struct ShredTick_ *tk = shred->tick; + MUTEX_LOCK(s->mutex); + _shredule(s, tk, wake_time); MUTEX_UNLOCK(s->mutex); } @@ -112,8 +117,10 @@ ANN void shreduler_ini(const Shreduler s, const VM_Shred shred) { ANN void shreduler_add(const Shreduler s, const VM_Shred shred) { shreduler_ini(s, shred); shred->tick->xid = ++s->shred_ids; + MUTEX_LOCK(s->mutex); vector_add(&s->active_shreds, (vtype)shred); - shredule(s, shred, GWION_EPSILON); + _shredule(s, shred->tick, GWION_EPSILON); + MUTEX_UNLOCK(s->mutex); } ANN Shreduler new_shreduler(const MemPool mp) { diff --git a/src/vm/vm.c b/src/vm/vm.c index 1f31a702..d14d07a4 100644 --- a/src/vm/vm.c +++ b/src/vm/vm.c @@ -59,7 +59,7 @@ ANN static void clean_values(const VM_Shred shred) { } } -ANN static uint16_t find_pc(const VM_Shred shred, const Symbol effect, const m_uint size) { +ANN static uint16_t find_pc(const VM_Shred shred, const Symbol effect) { const VM_Code code = shred->code; const m_uint start = vector_at(&shred->info->frame, vector_size(&shred->info->frame) - 2); if (start > shred->pc) return true; @@ -76,8 +76,8 @@ ANN static uint16_t find_pc(const VM_Shred shred, const Symbol effect, const m_u return 0; } -ANN static inline bool find_handle(const VM_Shred shred, const Symbol effect, const m_uint size) { - const uint16_t pc = find_pc(shred, effect, size); +ANN static inline bool find_handle(const VM_Shred shred, const Symbol effect) { + const uint16_t pc = find_pc(shred, effect); if (!pc) return false; // outside of a try statement shred->reg = // restore reg (m_bit *)VPTR(&shred->info->frame, VLEN(&shred->info->frame) - 1); @@ -94,7 +94,7 @@ ANN bool unwind(const VM_Shred shred, const Symbol effect, const m_uint size) { clean_values(shred); if (!size) return false; if (code->handlers.ptr) - return find_handle(shred, effect, size); + return find_handle(shred, effect); // there might be no more stack to unwind if (shred->mem == (m_bit *)shred + sizeof(struct VM_Shred_) + SIZEOF_REG) return false; -- 2.43.0