From 30cd26a861956f9f402e970eb5f11bd3fbbd78fd Mon Sep 17 00:00:00 2001 From: fennecdjay Date: Mon, 6 May 2024 18:20:22 +0200 Subject: [PATCH] :art: this commit is to big --- include/env/type.h | 7 +- src/emit/emit.c | 20 +-- src/env/func.c | 6 +- src/env/type.c | 6 +- src/gwion_parse.c | 97 ++++++++++++ src/import/import_checker.c | 6 +- src/import/import_internals.c | 4 +- src/lib/vector.c | 288 ++++++++++++++++++++++++++++++++++ src/parse/type_decl.c | 2 +- 9 files changed, 408 insertions(+), 28 deletions(-) create mode 100644 src/gwion_parse.c create mode 100644 src/lib/vector.c diff --git a/include/env/type.h b/include/env/type.h index ac4f6208..be29078a 100644 --- a/include/env/type.h +++ b/include/env/type.h @@ -50,9 +50,10 @@ struct Type_ { m_str name; Nspc nspc; struct TypeInfo_ *info; - uint32_t size; - uint32_t actual_size; - uint32_t array_depth; // TODO: encode in array type + uint64_t size; + uint64_t actual_size; +// struct Vector_ effects; // pre-ctor effects + uint32_t array_depth; uint16_t ref; uint16_t weight; ae_flag flag; diff --git a/src/emit/emit.c b/src/emit/emit.c index d1d1642d..b4564bb3 100644 --- a/src/emit/emit.c +++ b/src/emit/emit.c @@ -255,12 +255,7 @@ ANN void emit_pop_scope(const Emitter emit) { ANN void emit_push_scope(const Emitter emit) { frame_push(emit->code->frame); vector_add(&emit->info->pure, 0); - //if (emit->info->debug) emit_add_instr(emit, DebugPush); - if (emit->info->debug) { - - const Instr instr = emit_add_instr(emit, DebugPush); - instr->m_val = emit->status.line; - } + if (emit->info->debug) emit_add_instr(emit, DebugPush); } ANN m_uint emit_code_offset(const Emitter emit) { @@ -989,11 +984,9 @@ static INSTR(UsedBy) { } ANN static void used_by(const Emitter emit, const Value v) { -puts("emit used by"); MP_Vector *vec = new_mp_vector(emit->gwion->mp, Func, 0); for(uint32_t i = 0; i < v->used_by->len; i++) { const Func f = *mp_vector_at(v->used_by, Func, i); - if(f->_wait) puts("Adding to wait list"); if(f->_wait) mp_vector_add(emit->gwion->mp, &vec, Func, f); } free_mp_vector(emit->gwion->mp, Func, v->used_by); @@ -1922,13 +1915,11 @@ ANN2(1) /*static */ bool emit_exp(const Emitter emit, /* const */ Exp* e) { Exp* exp = e; do { if (emit->info->debug){ - -printf("debug line: %i\n", e->loc.first.line); if(emit->status.line < e->loc.first.line) { - const Instr instr = emit_add_instr(emit, DebugLine); - instr->m_val = emit->status.line = e->loc.first.line; - } - emit->status.line = e->loc.first.line; + const Instr instr = emit_add_instr(emit, DebugLine); + instr->m_val = emit->status.line = e->loc.first.line; + } + emit->status.line = e->loc.first.line; } CHECK_B(emit_exp_func[exp->exp_type](emit, &exp->d)); if (exp->cast_to) CHECK_B(emit_implicit_cast(emit, exp, exp->cast_to)); @@ -2615,7 +2606,6 @@ ANN static bool emit_exp_dot(const Emitter emit, const Exp_Dot *member) { ANN static inline void emit_func_def_init(const Emitter emit, const Func func) { emit_push_code(emit, func->name); if(mp_vector_len(func->_wait)) { -puts("wait"); const Instr instr = emit_add_instr(emit, FuncWait); instr->m_val = (m_uint) func; } diff --git a/src/env/func.c b/src/env/func.c index f5556215..a6d80cf0 100644 --- a/src/env/func.c +++ b/src/env/func.c @@ -61,10 +61,10 @@ ANN void builtin_func(const Gwion gwion, const Func f, void *func_ptr) { ANN void print_signature(const Gwion gwion, const Func f) { struct GwfmtState ls = {.minimize=true, .ppa = gwion->ppa}; -// gwfmt_state_init(&ls); + gwfmt_state_init(&ls); text_init(&ls.text, gwion->mp); - Gwfmt l = {.mp = gwion->mp, .st = gwion->st, .ls = &ls, .line = 1, .last = cht_nl }; - gwfmt_func_def(&l, f->def); + Gwfmt gwfmter = {.mp = gwion->mp, .st = gwion->st, .ls = &ls, .line = 1, .last = cht_nl }; + gwfmt_func_def(&gwfmter, f->def); gwlog_related_from(ls.text.str, f->value_ref->from); text_release(&ls.text); } diff --git a/src/env/type.c b/src/env/type.c index ffd2f39c..704f1399 100644 --- a/src/env/type.c +++ b/src/env/type.c @@ -35,7 +35,10 @@ Type new_type(MemPool p, const m_str name, const Type parent) { type->name = name; type->info = mp_calloc(p, TypeInfo); type->info->parent = parent; - if (parent) type->size = parent->size; + if (parent) { + type->size = parent->size; + type->actual_size = parent->actual_size; + } type->ref = 1; return type; } @@ -43,6 +46,7 @@ Type new_type(MemPool p, const m_str name, const Type parent) { ANN Type type_copy(MemPool p, const Type type) { const Type a = new_type(p, type->name, type->info->parent); a->size = type->size; + a->actual_size = type->actual_size; a->array_depth = type->array_depth; a->info->gack = type->info->gack; return a; diff --git a/src/gwion_parse.c b/src/gwion_parse.c new file mode 100644 index 00000000..3e4d6f9e --- /dev/null +++ b/src/gwion_parse.c @@ -0,0 +1,97 @@ +#include "gwion_util.h" +#include "gwion_ast.h" +#include "gwion_env.h" +#include "vm.h" +#include "gwion.h" +#include "gwion_parse.h" + +ANN Ast gwion_parse_ast(const Gwion gwion, const char *data) { + FILE *file = fmemopen((void*)data, strlen(data), "r"); + struct AstGetter_ arg = {gwion->env->name, file, gwion->st, .ppa = gwion->ppa}; + return parse(&arg); +} + + +ANN static Ast gwion_parse_ast1(const Gwion gwion, const char *data, const loc_t loc) { + DECL_O(const Ast, ast, = gwion_parse_ast(gwion, data)); + if(ast->len != 1) { + gwlog_error("more than one section", NULL, gwion->env->name, loc, 0); + free_ast(gwion->mp, ast); + return NULL; + } + return ast; +} + +ANN Func_Def gwion_parse_func_def(const Gwion gwion, const char *data, const loc_t loc) { + DECL_O(const Ast, ast, = gwion_parse_ast1(gwion, data, loc)); + Section *section = mp_vector_at(ast, Section, 0); + if(section->section_type != ae_section_func) { + gwlog_error("invalid section type", NULL, gwion->env->name, loc, 0); + free_ast(gwion->mp, ast); + return NULL; + } + Func_Def fdef = section->d.func_def; + free_ast(gwion->mp, ast); + return fdef; +} + +ANN Stmt_List gwion_parse_stmt_list(const Gwion gwion, const char *data, const loc_t loc) { + DECL_O(const Ast, ast, = gwion_parse_ast1(gwion, data, loc)); + Section *section = mp_vector_at(ast, Section, 0); + if(section->section_type != ae_section_stmt) { + gwlog_error("invalid section type", NULL, gwion->env->name, loc, 0); + free_ast(gwion->mp, ast); + return NULL; + } + Stmt_List stmts = section->d.stmt_list; + free_mp_vector(gwion->mp, Section, ast); + return stmts; +} + +ANN Exp *gwion_parse_expression(const Gwion gwion, const char *data, const loc_t loc) { + char* str = NULL; + gw_asprintf(gwion->mp, &str, "%s;", data); + Stmt_List stmts = gwion_parse_stmt_list(gwion, str, loc); + free_mstr(gwion->mp, str); + if(!stmts) return NULL; + if(stmts->len != 1) { + gwlog_error("invalid number of statements", NULL, gwion->env->name, loc, 0); + return NULL; + } + Stmt *stmt = mp_vector_at(stmts, Stmt, 0); + if(stmt->stmt_type != ae_stmt_exp) { + gwlog_error("invalid statement type", NULL, gwion->env->name, loc, 0); + return NULL; + } + Exp *exp = stmt->d.stmt_exp.val; + free_mp_vector(gwion->mp, Stmt, stmts); + return exp; +} + +ANN Type_Decl *gwion_parse_type_decl(const Gwion gwion, const char *data, const loc_t loc) { + char* str = NULL; + gw_asprintf(gwion->mp, &str, "var %s A;", data); + Stmt_List stmts = gwion_parse_stmt_list(gwion, str, loc); + if(!stmts) { + return NULL; + } +// free_mstr(gwion->mp, str); + if(stmts->len != 1) { + gwlog_error("invalid number of statements", NULL, gwion->env->name, loc, 0); + return NULL; + } + Stmt *stmt = mp_vector_at(stmts, Stmt, 0); + if(stmt->stmt_type != ae_stmt_exp) { + gwlog_error("invalid statement type", NULL, gwion->env->name, loc, 0); + return NULL; + } + Exp *exp = stmt->d.stmt_exp.val; + free_mp_vector(gwion->mp, Stmt, stmts); + if(exp->exp_type != ae_exp_decl) { + gwlog_error("invalid expression type", NULL, gwion->env->name, loc, 0); + return NULL; + } + Type_Decl *td = cpy_type_decl(gwion->mp, exp->d.exp_decl.var.td); + free_exp(gwion->mp, exp); + return td; +} diff --git a/src/import/import_checker.c b/src/import/import_checker.c index e299f5c0..9ea38f16 100644 --- a/src/import/import_checker.c +++ b/src/import/import_checker.c @@ -359,10 +359,10 @@ ANEW ANN m_str type2str(const Gwion gwion, const Type t, ANEW ANN m_str tl2str(const Gwion gwion, const TmplArg_List tl, const loc_t loc NUSED) { struct GwfmtState ls = {.minimize=true, .ppa = gwion->ppa}; -// gwfmt_state_init(&ls); + gwfmt_state_init(&ls); text_init(&ls.text, gwion->mp); - Gwfmt l = {.mp = gwion->mp, .st = gwion->st, .ls = &ls, .line = 1, .last = cht_nl }; - struct td_info info = {.tl = tl, .fmt = &l }; + Gwfmt gwfmter = {.mp = gwion->mp, .st = gwion->st, .ls = &ls, .line = 1, .last = cht_nl }; + struct td_info info = {.tl = tl, .fmt = &gwfmter }; CHECK_O(td_info_run(gwion->env, &info)); return ls.text.str; } diff --git a/src/import/import_internals.c b/src/import/import_internals.c index a4a00cd7..d2e0965b 100644 --- a/src/import/import_internals.c +++ b/src/import/import_internals.c @@ -31,9 +31,9 @@ ANN void gwi_reset(const Gwi gwi) { ANN static bool run_with_doc(const Gwi gwi, bool (*f)(const Gwi)) { struct GwfmtState ls = {.builtin = true, .nindent = 4}; -// gwfmt_state_init(&ls); + gwfmt_state_init(&ls); text_init(&ls.text, gwi->gwion->mp); - Gwfmt gwfmter = {.mp = gwi->gwion->mp, .ls = &ls, .st = gwi->gwion->st }; + Gwfmt gwfmter = {.mp = gwi->gwion->mp, .ls = &ls, .st = gwi->gwion->st }; gwfmt_indent(&gwfmter); gwfmt_util(&gwfmter, "{-}#!+ %s{0}\n", gwi->gwion->env->name); gwi->gwfmt = &gwfmter; diff --git a/src/lib/vector.c b/src/lib/vector.c new file mode 100644 index 00000000..d6b5953b --- /dev/null +++ b/src/lib/vector.c @@ -0,0 +1,288 @@ +#include "gwion_util.h" +#include "gwion_ast.h" +#include "gwion_env.h" +#include "vm.h" +#include "gwion.h" +#include "instr.h" +#include "object.h" +#include "array.h" +#include "emit.h" +#include "operator.h" +#include "import.h" +#include "traverse.h" +#include "parse.h" +#include "gwi.h" +#include "emit.h" + +ANN static inline m_uint Vector_size(const Type t) { + return *(m_uint*)t->nspc->class_data; +} + +static DTOR(vector_dtor) { + const m_uint size = Vector_size(o->type_ref); + const Type base = o->type_ref->info->base_type; + const m_uint base_size = base->size; + for (m_uint i = 0; i < size; ++i) + compound_release(shred, base, o->data + i * base_size); +} + +// TODO: use one of the memcpy functions? +static MFUN(vector_new) { + const m_uint size = Vector_size(o->type_ref); + const Type base = o->type_ref->info->base_type; + const m_uint base_size = base->size; + memcpy(o->data, shred->mem + SZ_INT, size * base_size); + *(M_Object*)RETURN = o; +} + +ANN Type check_array_access(const Env env, const Array_Sub array); + +static OP_CHECK(opck_vector_access) { + const Array_Sub array = (Array_Sub)data; + const Type index_t = (Type)map_at(&array->type->nspc->info->type->map, 0); + CHECK_B(check_implicit(env, array->exp, index_t)); + if(is_prim_int(array->exp)) { + const m_uint num = array->exp->d.prim.d.gwint.num; + // haha. can't have signed numbers with the grammar + // that said. + // we could make gwint.num signed + // and compile time resolve unary minus and stuff + // but that would need to be in the validation pass + if(num >= Vector_size(array->type)) { + gwlog_error("index out of bounds", "requested index to big for vector", + env->name, array->exp->loc, 0); + //return false; + return env->gwion->type[et_error]; + } + } // TODO: else add effect!!! + const Type t = array->type->info->base_type; + if (array->depth == 1) + return array->type->info->base_type; + struct Array_Sub_ next = {array->exp->next, array->type->info->base_type, + array->depth - t->array_depth}; + return check_array_access(env, &next) ?: env->gwion->type[et_error]; +} + +static INSTR(VectorAccess) { + const M_Object o = *(M_Object*)(shred->reg); + const m_uint idx = *(m_uint*)(shred->reg + SZ_INT); + memcpy(shred->reg, o->data + (instr->m_val * idx), instr->m_val); +} + +static INSTR(VectorAccessRef) { + const M_Object o = *(M_Object*)(shred->reg - SZ_INT); + const m_uint idx = *(m_uint*)(shred->reg); + *(m_bit**)(shred->reg - SZ_INT) = (o->data + (instr->m_val * idx)); +} + +static ANN bool emit_dynamic_access(const Emitter emit, Exp *exp, + const Type base, const bool is_var) { + CHECK_B(emit_exp(emit, exp)); + if(!is_var) { + // TODO: we could have logical->goto opcodes + emit_regmove(emit, -2 * SZ_INT); + const Instr instr = emit_add_instr(emit, VectorAccess); + instr->m_val = base->size; +// instr->m_val2 = Vector_size(info->array.type); + emit_regmove(emit, base->size); + } else { + emit_regmove(emit, -SZ_INT); + const Instr instr = emit_add_instr(emit, VectorAccessRef); + instr->m_val = base->size; + } + return true; +} + + +static OP_EMIT(opem_vector_access) { + struct ArrayAccessInfo *const info = (struct ArrayAccessInfo *)data; + const Type base = info->array.type->info->base_type; + const bool is_var = !info->array.exp->next && info->is_var; + Exp *next = info->array.exp->next; + if(is_prim_int(info->array.exp)) { + // TODO: have a function to retrieve ints + const m_uint num = info->array.exp->d.prim.d.gwint.num; + emit_dotmember(emit, base->size * num, base->size, is_var); + } else { + info->array.exp->next = NULL; + emit_dynamic_access(emit, info->array.exp, base, is_var); + info->array.exp->next = next; + } + if(!next) return true; + info->array.type = base; + info->array.exp = next; + return emit_array_access(emit, info); +} + +/*! build arg_list for `new` * + * `N` arguments with Type_Decl `td` * + * where `td` points to the base type */ +static Arg_List new_args(const MemPool mp, const Type_Decl *td, + const m_uint N) { + Arg_List args = new_mp_vector(mp, Arg, N); + for(uint32_t i = 0; i < N; i++) { + Arg arg = { .var = { .td = cpy_type_decl(mp, td) }}; + mp_vector_set(args, Arg, i, arg); + } + return args; +} + +static Type check_vector(const Env env, const Class_Def cdef, + const Type base, const m_uint N) { + if(type_global(env, base)) + SET_FLAG(cdef, global); + CHECK_ON(scan0_class_def(env, cdef)); // error + const Type t = cdef->base.type; + t->nspc->offset = N * base->size; + t->info->base_type = base; + CHECK_B(traverse_cdef(env, t)); +// CHECK_B(emit_class_def(env, cdef)); + *(m_uint*)t->nspc->class_data = N; + //set_tflag(t, tflag_emit); + set_tflag(t, tflag_cdef); + SET_FLAG(t, final); + SET_FLAG(t, abstract); + return t; +} + +static OP_CHECK(opck_vector_scan) { + struct TemplateScan *ts = (struct TemplateScan *)data; + m_str name = tdpp(env->gwion->mp, env->gwion->st, ts->td, true, true); + const Symbol sym = insert_symbol(name); + free_mstr(env->gwion->mp, name); + // TODO: this should be in some other upper function + const Type exist = nspc_lookup_type1(env->curr, sym); + if (exist) return exist; + const Class_Def c= ts->t->info->cdef; + Type_Decl *base_td = mp_vector_at(ts->td->types, TmplArg, 0)->d.td; + DECL_ON(const Type, base, = known_type(env, base_td)); + + // TODO: this is basically the same as in Array + // and possibly Dict and Ref + // make it in a function + if (base->size == 0) { + gwlog_error("Can't use type of size 0 as vector base", NULL, + env->name, ts->td->tag.loc, 0); + env_set_error(env, true); + return env->gwion->type[et_error]; + } + if (tflag(base, tflag_infer) || tflag(base, tflag_noret)) { + gwlog_error("invalid type for vector", base->name, + env->name, ts->td->tag.loc, 0); + env_set_error(env, true); + return env->gwion->type[et_error]; + } + const TmplArg *ta = mp_vector_at(ts->td->types, TmplArg, 1); + const m_uint size = ta->d.exp->d.prim.d.gwint.num; + const Class_Def cdef = cpy_class_def(env->gwion->mp, c); + cdef->base.ext = type2td(env->gwion, ts->t, ts->td->tag.loc); + cdef->base.tag.sym = sym; + cdef->base.tmpl->call = cpy_tmplarg_list(env->gwion->mp, ts->td->types); + Func_Def fdef = mp_vector_at(cdef->body, Section, 0)->d.func_def; + fdef->base->args = new_args(env->gwion->mp, base_td, size); + + struct EnvSet es = { + .env = env, + .data = env, + .scope = env->scope->depth + }; + envset_pushv(&es, base->info->value); + const Type t = check_vector(env, cdef, base, size); + + struct Op_Func opfunc = { + .ck = opck_vector_access, + .em = opem_vector_access, + //.effect + }; + struct Op_Import opi = { + // .lhs = tdef->type, + .lhs = env->gwion->type[et_int], + .rhs = cdef->base.type, + .ret = base, + .op = insert_symbol("[]"), + .func = &opfunc, + .loc = ts->td->tag.loc, + }; + add_op(env->gwion, &opi); + + envset_popv(&es, base->info->value); + + if(!t) return NULL; + if (tflag(base, tflag_release)) + mk_dtor(env->gwion->mp, t, vector_dtor); + return t; +} + +static OP_CHECK(opck_vector_new) { + Exp *e = data; + Exp_Call *call = &e->d.exp_call; + Exp *arg = call->args; + const uint32_t nargs = exp_count(arg); + if(!nargs) { + gwlog_error("invalid 0 size for Vector", NULL, + env->name, e->loc, 0); + return NULL; + } + CHECK_B(check_exp(env, arg)); + TmplArg_List tl = new_mp_vector(env->gwion->mp, TmplArg, 2); + mp_vector_set(tl, TmplArg, 0, MK_TMPLARG_TD( + type2td(env->gwion, arg->type, arg->loc))); + mp_vector_set(tl, TmplArg, 1, MK_TMPLARG_EXP( + new_prim_int(env->gwion->mp, nargs, e->loc))); + call->tmpl = new_tmpl_call(env->gwion->mp, tl); + Type_Decl *td = new_type_decl(env->gwion->mp, + insert_symbol("Vector"), call->func->d.exp_dot.base->loc); + td->types = call->tmpl->call; + const Type owner = known_type(env, td); + td->types = NULL; + call->tmpl->list = owner->info->cdef->base.tmpl->list; + free_type_decl(env->gwion->mp, td); + call->func->d.exp_dot.base->type = owner; + call->func->type = NULL; + return check_exp(env, e); +} + +GWION_IMPORT(vector) { + const Type t_vector = gwi_class_ini(gwi, "Vector:[T, const int N]", "Object"); + GWI_B(gwi_func_ini(gwi, "auto", "new")); + GWI_B(gwi_func_end(gwi, vector_new, ae_flag_none)); + GWI_B(gwi_item_ini(gwi, "T", "N")); + GWI_B(gwi_item_end(gwi, ae_flag_static, num, 0)); + + GWI_B(gwi_typedef_ini(gwi, "int", "index_t")); + //GWI_B(gwi_typedef_exp(gwi, "self >= 0 && self < N")); + GWI_B(gwi_typedef_exp(gwi, "self >= 0 && self < N")); + GWI_B(gwi_typedef_end(gwi, ae_flag_none)); + + GWI_B(gwi_class_end(gwi)); + /* + puts("before traverse"); + unset_tflag(t_vector, tflag_check); + traverse_class_def(gwi->gwion->env, t_vector->info->cdef); + puts("after traverse"); + */ + const Env env = gwi->gwion->env; + Func_Def fdef = mp_vector_at(t_vector->info->cdef->body, Section, 0)->d.func_def; + env_push_type(env, t_vector); + traverse_func_def(env, fdef); + env_pop(env, 0); + struct Op_Func opfunc = { + .ck = opck_vector_new, + }; + add_op_func_check(gwi->gwion->env, t_vector, &opfunc, 0); +/* + Type_Def tdef = mp_vector_at(t_vector->info->cdef->body, Section, 2)->d.type_def; + env_push_type(env, t_vector); + traverse_type_def(env, tdef); + env_pop(env, 0); + + GWI_B(gwi_oper_ini(gwi, "Vector.index_t", "Vector", NULL)); + GWI_B(gwi_oper_add(gwi, opck_vector_access)); + GWI_B(gwi_oper_emi(gwi, opem_vector_access)); + GWI_B(gwi_oper_end(gwi, "[]", NULL)); +*/ + GWI_B(gwi_oper_ini(gwi, "Vector", NULL, NULL)); + GWI_B(gwi_oper_add(gwi, opck_vector_scan)); + GWI_B(gwi_oper_end(gwi, "class", NULL)); + return true; +} diff --git a/src/parse/type_decl.c b/src/parse/type_decl.c index cc0da546..81920a32 100644 --- a/src/parse/type_decl.c +++ b/src/parse/type_decl.c @@ -120,7 +120,7 @@ ANN static Type resolve(const Env env, Type_Decl *td) { ANN m_str tdpp(MemPool mp, SymTable *st, const Type_Decl *td, const bool no_color, const bool minimize) { struct GwfmtState ls = { .minimize = minimize,}; -// gwfmt_state_init(&ls); + gwfmt_state_init(&ls); text_init(&ls.text, mp); Gwfmt gwfmter = {.mp = mp, .ls = &ls, .st = st }; bool has_color = tcol_has_color(); -- 2.43.0