--- /dev/null
+#include <stdlib.h>
+#include <string.h>
+#include "gwion_util.h"
+#include "gwion_ast.h"
+#include "oo.h"
+#include "vm.h"
+#include "env.h"
+#include "type.h"
+#include "nspc.h"
+#include "value.h"
+#include "instr.h"
+#include "emit.h"
+#include "object.h"
+#include "array.h"
+#include "func.h"
+#include "traverse.h"
+#include "template.h"
+#include "escape.h"
+#include "parse.h"
+#include "memoize.h"
+#include "operator.h"
+#include "import.h"
+#include "switch.h"
+
+typedef struct Local_ {
+ m_uint size;
+ m_uint offset;
+ m_bool is_obj;
+} Local;
+
+static inline void emit_pop_type(const Emitter emit) { nspc_pop_type(emit->env->curr); }
+static inline void emit_pop(const Emitter emit, const m_uint scope) { env_pop(emit->env, scope); }
+static inline m_uint emit_push(const Emitter emit, const Type type, const Nspc nspc) {
+ return env_push(emit->env, type, nspc);
+}
+static inline m_uint emit_push_type(const Emitter emit, const Type type) {
+ return env_push_type(emit->env, type);
+}
+static inline m_uint emit_push_global(const Emitter emit) {
+ return env_push_global(emit->env);
+}
+
+ANEW static Frame* new_frame() {
+ Frame* frame = mp_alloc(Frame);
+ vector_init(&frame->stack);
+ vector_add(&frame->stack, (vtype)NULL);
+ return frame;
+}
+
+ANN static void free_frame(Frame* a) {
+ LOOP_OPTIM
+ for(vtype i = vector_size(&a->stack) + 1; --i;)
+ if(vector_at(&a->stack, i - 1))
+ mp_free(Local, (Local*)vector_at(&a->stack, i - 1));
+ vector_release(&a->stack);
+ mp_free(Frame, a);
+}
+
+ANN static Local* new_local(const m_uint size, const m_bool is_obj) {
+ Local* local = mp_alloc(Local);
+ local->size = size;
+ local->is_obj = is_obj;
+ return local;
+}
+
+ANN static m_uint frame_local(Frame* frame, const m_uint size, const m_bool is_obj) {
+ Local* local = new_local(size, is_obj);
+ local->offset = frame->curr_offset;
+ frame->curr_offset += size;
+ vector_add(&frame->stack, (vtype)local);
+ return local->offset;
+}
+
+ANN static inline void frame_push(Frame* frame) {
+ vector_add(&frame->stack, (vtype)NULL);
+}
+
+ANN static m_int frame_pop(Frame* frame) {
+ const Local* l = (Local*)vector_pop(&frame->stack);
+ CHECK_OB(l)
+ frame->curr_offset -= l->size;
+ return l->is_obj ? (m_int)l->offset : frame_pop(frame);
+}
+
+ANN static m_bool emit_exp(const Emitter emit, Exp exp, const m_bool add_ref);
+ANN static m_bool emit_stmt(const Emitter emit, const Stmt stmt, const m_bool pop);
+ANN static m_bool emit_stmt_list(const Emitter emit, Stmt_List list);
+ANN static m_bool emit_exp_dot(const Emitter emit, const Exp_Dot* member);
+ANN static m_bool emit_func_def(const Emitter emit, const Func_Def func_def);
+
+ANEW static Code* new_code(const Emitter emit, const m_str name) {
+ Code* code = mp_alloc(Code);
+ code->name = code_name_set(name, emit->env->name);
+ vector_init(&code->instr);
+ vector_init(&code->stack_break);
+ vector_init(&code->stack_cont);
+ vector_init(&code->stack_return);
+ code->frame = new_frame();
+ return code;
+}
+
+ANN static void free_code(Code* code) {
+ vector_release(&code->instr);
+ vector_release(&code->stack_break);
+ vector_release(&code->stack_cont);
+ vector_release(&code->stack_return);
+ free_frame(code->frame);
+ free(code->name);
+ mp_free(Code, code);
+}
+
+ANN static void emit_pop_scope(const Emitter emit) { GWDEBUG_EXE
+ m_int offset;
+ while((offset = frame_pop(emit->code->frame)) > -1) {
+ Instr instr = emit_add_instr(emit, ObjectRelease);
+ instr->m_val = (m_uint)offset;
+ }
+}
+
+ANN static inline void emit_push_code(const Emitter emit, const m_str name) {
+ vector_add(&emit->stack, (vtype)emit->code);
+ emit->code = new_code(emit, name);
+}
+
+ANN static inline void emit_pop_code(const Emitter emit) {
+ emit->code = (Code*)vector_pop(&emit->stack);
+}
+
+ANN static inline void emit_push_scope(const Emitter emit) {
+ frame_push(emit->code->frame);
+}
+
+ANN static inline m_uint emit_code_size(const Emitter emit) {
+ return vector_size(&emit->code->instr);
+}
+
+ANN static inline m_uint emit_code_offset(const Emitter emit) {
+ return emit->code->frame->curr_offset;
+}
+
+ANN static inline m_uint emit_local(const Emitter emit, const m_uint size, const m_bool is_obj) { GWDEBUG_EXE
+ return frame_local(emit->code->frame, size, is_obj);
+}
+
+ANN static void emit_pre_ctor(const Emitter emit, const Type type) { GWDEBUG_EXE
+ if(type->parent)
+ emit_pre_ctor(emit, type->parent);
+ if(type->nspc->pre_ctor)
+ emit_ext_ctor(emit, type->nspc->pre_ctor);
+ if(GET_FLAG(type, template) && GET_FLAG(type, builtin)) {
+ const Type t = template_parent(type);
+ if(t->nspc->pre_ctor)
+ emit_ext_ctor(emit, t->nspc->pre_ctor);
+ }
+}
+
+ANN static void emit_pre_constructor_array(const Emitter emit, const Type type) {
+ const m_uint start_index = emit_code_size(emit);
+ const Instr top = emit_add_instr(emit, ArrayTop);
+ top->m_val2 = (m_uint)type;
+ emit_pre_ctor(emit, type);
+ const Instr bottom = emit_add_instr(emit, ArrayBottom);
+ top->m_val = emit_code_size(emit);
+ bottom->m_val = start_index;
+ emit_add_instr(emit, ArrayPost);
+}
+
+ANN ArrayInfo* emit_array_extend_inner(const Emitter emit, const Type t, const Exp e) { GWDEBUG_EXE
+ CHECK_BO(emit_exp(emit, e, 0))
+ const Type base = array_base(t);
+ ArrayInfo* info = mp_alloc(ArrayInfo);
+ vector_init(&info->type);
+ for(m_uint i = 1; i < t->array_depth; ++i)
+ vector_add(&info->type, (vtype)array_type(base, i));
+ vector_add(&info->type, (vtype)t);
+ info->depth = (m_int)t->array_depth;
+ info->base = base;
+ const Instr alloc = emit_add_instr(emit, ArrayAlloc);
+ alloc->m_val = (m_uint)info;
+ if(isa(base, t_object) > 0) {
+ emit_pre_constructor_array(emit, base);
+ info->is_obj = 1;
+ }
+ return info;
+}
+
+ANN void emit_ext_ctor(const Emitter emit, const VM_Code code) { GWDEBUG_EXE
+ emit_add_instr(emit, RegDup);
+ const Instr push_f = emit_add_instr(emit, RegPushImm);
+ push_f->m_val = (m_uint)code;
+ const Instr offset = emit_add_instr(emit, RegSetImm);
+ offset->m_val = emit_code_offset(emit);
+ emit_add_instr(emit, !GET_FLAG(code, builtin) ? FuncUsr : FuncMember);
+}
+
+ANN m_bool emit_array_extend(const Emitter emit, const Type t, const Exp e) { GWDEBUG_EXE
+ CHECK_OB(emit_array_extend_inner(emit, t, e))
+ emit_add_instr(emit, PopArrayClass);
+ return 1;
+}
+
+ANN2(1,2) m_bool emit_instantiate_object(const Emitter emit, const Type type,
+ const Array_Sub array, const uint is_ref) {
+ if(type->array_depth) {
+ assert(array);
+ assert(array->exp);
+ ArrayInfo* info = emit_array_extend_inner(emit, type, array->exp);
+ CHECK_OB(info)
+ info->is_ref = !!is_ref;
+ } else if(!is_ref) {
+ const Instr instr = emit_add_instr(emit, ObjectInstantiate);
+ instr->m_val = (m_uint)type;
+ emit_pre_ctor(emit, type);
+ }
+ return GW_OK;
+}
+
+static inline enum Kind kindof(const m_uint size, const uint emit_var) {
+ if(emit_var)
+ return KIND_ADDR;
+ return size == SZ_INT ? KIND_INT : size == SZ_FLOAT ? KIND_FLOAT : KIND_OTHER;
+}
+
+ANN static Instr emit_kind(Emitter emit, const m_uint size, const uint addr, const f_instr func[]) {
+ const enum Kind kind = kindof(size, addr);
+ const Instr instr = emit_add_instr(emit, func[kind]);
+ instr->m_val2 = size;
+ return instr;
+}
+
+static const f_instr regpushimm[] = { RegPushImm, RegPushImm2, RegPushImm3, RegPushImm4 };
+static const f_instr regpushmem[] = { RegPushMem, RegPushMem2, RegPushMem3, RegPushMem4 };
+static const f_instr regpushbase[] = { RegPushBase, RegPushBase2, RegPushBase3, RegPushBase4 };
+static const f_instr dotstatic[] = { DotStatic, DotStatic2, DotStatic3, RegPushImm };
+static const f_instr dotmember[] = { DotMember, DotMember2, DotMember3, DotMember4 };
+static const f_instr allocmember[] = { RegPushImm, RegPushImm2, RegPushImm3, AllocMember4 };
+static const f_instr allocword[] = { AllocWord, AllocWord2, AllocWord3, AllocWord4 };
+
+ANN static m_bool emit_symbol_owned(const Emitter emit, const Exp_Primary* prim) { GWDEBUG_EXE
+ const Value v = prim->value;
+ const Exp exp = new_exp_prim_id(insert_symbol("this"), prim->self->pos);
+ const Exp dot = new_exp_dot(exp, prim->d.var);
+ exp->type = v->owner_class;
+ dot->d.exp_dot.t_base = v->owner_class;
+ dot->type = v->type;
+ dot->emit_var = prim->self->emit_var;
+ const m_bool ret = emit_exp_dot(emit, &dot->d.exp_dot);
+ free_exp(exp);
+ return ret;
+}
+
+ANN static m_bool emit_symbol_builtin(const Emitter emit, const Exp_Primary* prim) { GWDEBUG_EXE
+ const Value v = prim->value;
+ if(GET_FLAG(v, func)) {
+ const Instr instr = emit_add_instr(emit, RegPushImm);
+ instr->m_val = (m_uint)v->d.func_ref;
+ return GW_OK;
+ }
+ if(GET_FLAG(v, union)) {
+ const m_uint size = v->type->size;
+ const Instr instr = emit_kind(emit, size, prim->self->emit_var, dotstatic);
+ instr->m_val = (m_uint)v->d.ptr;
+ } else {
+ const m_uint size = v->type->size;
+ const Instr instr = emit_kind(emit, size, prim->self->emit_var, regpushimm);
+ if(!prim->self->emit_var && size == SZ_INT) {
+ if(isa(v->type, t_object) > 0) {
+ instr->execute = RegPushImm;
+ instr->m_val = (m_uint)v->d.ptr;
+ } else if(v->d.ptr)
+ instr->m_val = *(m_uint*)v->d.ptr;
+ } else if(v->d.ptr)
+ memcpy(&instr->m_val, v->d.ptr, v->type->size);
+ else
+ instr->m_val = (m_uint)v->d.ptr;
+ instr->m_val2 = size;
+ }
+ return GW_OK;
+}
+
+ANN static m_bool emit_symbol(const Emitter emit, const Exp_Primary* prim) { GWDEBUG_EXE
+ const Value v = prim->value;
+ if(v->owner_class)
+ return emit_symbol_owned(emit, prim);
+ if(GET_FLAG(v, builtin) || GET_FLAG(v, union))
+ return emit_symbol_builtin(emit, prim);
+ const m_uint size = v->type->size;
+ const Instr instr = emit_kind(emit, size, prim->self->emit_var, !GET_FLAG(v, global) ? regpushmem : regpushbase);
+ instr->m_val = v->offset;
+ return GW_OK;
+}
+
+ANEW ANN VM_Code emit_code(const Emitter emit) { GWDEBUG_EXE
+ Code* c = emit->code;
+ const VM_Code code = new_vm_code(&c->instr, c->stack_depth,
+ c->flag, c->name);
+ free_code(c);
+ return code;
+}
+
+ANN static VM_Code finalyze(const Emitter emit) {
+ emit_add_instr(emit, EOC);
+ const VM_Code code = emit_code(emit);
+ emit_pop_code(emit);
+ return code;
+}
+
+ANN static m_bool prim_array(const Emitter emit, const Exp_Primary * primary) {
+ const Array_Sub array = primary->d.array;
+ Exp e = array->exp;
+ CHECK_BB(emit_exp(emit, e, 0))
+ m_uint count = 0;
+ do ++count;
+ while((e = e->next));
+ const Type type = array->type;
+ const Type base = array_base(type);
+ const Instr push = emit_add_instr(emit, RegSetImm);
+ push->m_val = count;
+ const Instr instr = emit_add_instr(emit, ArrayInit);
+ instr->m_val = (m_uint)type;
+ instr->m_val2 = base->size;
+ emit_add_instr(emit, GcAdd);
+ return GW_OK;
+}
+
+ANN static m_uint get_depth(Type t) {
+ m_uint depth = 0;
+ do depth += t->array_depth;
+ while((t = t->parent));
+ return depth;
+}
+
+ANN static m_bool emit_exp_array(const Emitter emit, const Exp_Array* array) { GWDEBUG_EXE
+ const m_uint is_var = array->self->emit_var;
+ const m_uint depth = get_depth(array->base->type) - array->self->type->array_depth;
+ CHECK_BB(emit_exp(emit, array->base, 0))
+ CHECK_BB(emit_exp(emit, array->array->exp, 0))
+ if(depth == 1) {
+ const Instr instr = emit_add_instr(emit, ArrayAccess);
+ instr->m_val = is_var;
+ instr->m_val2 = is_var ? SZ_INT : array->self->type->size;
+ } else {
+ const Instr push = emit_add_instr(emit, RegSetImm);
+ push->m_val = depth;
+ const Instr instr = emit_add_instr(emit, ArrayAccessMulti);
+ instr->m_val = is_var || array->self->type->array_depth;
+ instr->m_val2 = (is_var || array->self->type->array_depth) ?
+ SZ_INT : array_base(array->base->type)->size;
+ }
+ return GW_OK;
+}
+
+ANN static m_bool prim_vec(const Emitter emit, const Exp_Primary * primary) { GWDEBUG_EXE
+ const Vec * vec = &primary->d.vec;
+ const ae_prim_t t = primary->primary_type;
+ CHECK_BB(emit_exp(emit, vec->exp, 0));
+ m_int n = (m_int)((t == ae_primary_vec ? 3 : 2) - vec->dim + 1);
+ while(--n > 0)
+ emit_add_instr(emit, RegPushImm2);
+ if(primary->self->emit_var) {
+ emit_local(emit, primary->self->type->size, 0);
+ const m_uint offset = emit_local(emit, SZ_INT, 0);
+ const Instr cpy = emit_add_instr(emit, VecCpy);
+ cpy->m_val = offset;
+ cpy->m_val2 = primary->self->type->size;
+ const Instr instr = emit_add_instr(emit, RegPushMem);
+ instr->m_val = offset;
+ }
+ return GW_OK;
+}
+
+ANN static m_bool prim_id(const Emitter emit, const Exp_Primary* prim) {
+ if(prim->d.var == insert_symbol("this"))
+ emit_add_instr(emit, RegPushMem);
+ else if(prim->d.var == insert_symbol("me"))
+ emit_add_instr(emit, RegPushMe);
+ else if(prim->d.var == insert_symbol("now"))
+ emit_add_instr(emit, RegPushNow);
+ else if(prim->d.var == insert_symbol("maybe"))
+ emit_add_instr(emit, RegPushMaybe);
+ else if(prim->d.var == insert_symbol("__func__")) {
+ const Instr instr = emit_add_instr(emit, RegPushStr);
+ instr->m_val = (m_uint)s_name(insert_symbol(emit->env->func ?
+ emit->env->func->name : emit->env->class_def ?
+ emit->env->class_def->name : emit->env->name));
+ } else
+ emit_symbol(emit, prim);
+ return GW_OK;
+}
+
+ANN static m_bool prim_num(const Emitter emit, const Exp_Primary * primary) {
+ const Instr instr = emit_add_instr(emit, RegPushImm);
+ instr->m_val = primary->d.num;
+ return GW_OK;
+}
+
+ANN static m_bool prim_float(const Emitter emit, const Exp_Primary* primary) {
+ const Instr instr = emit_add_instr(emit, RegPushImm2);
+ instr->f = primary->d.fnum;
+ return GW_OK;
+}
+
+ANN static m_bool prim_char(const Emitter emit, const Exp_Primary* prim) {
+ const m_int c = str2char(prim->d.chr, prim->self->pos);
+ CHECK_BB(c);
+ const Instr instr = emit_add_instr(emit, RegPushImm);
+ instr->m_val = (m_uint)c;
+ return GW_OK;
+}
+
+ANN static m_bool prim_str(const Emitter emit, const Exp_Primary* prim) { GWDEBUG_EXE
+ char c[strlen(prim->d.str)];
+ strcpy(c, prim->d.str);
+ CHECK_BB(escape_str(c, prim->self->pos));
+ const Instr instr = emit_add_instr(emit, RegPushStr);
+ instr->m_val = (m_uint)s_name(insert_symbol(c));
+ return GW_OK;
+}
+
+ANN static m_bool prim_gack(const Emitter emit, const Exp_Primary* primary) {
+ const Exp exp = primary->d.exp;
+ const Vector v = new_vector();
+ m_uint offset = 0;
+ Exp e = exp;
+ do {
+ vector_add(v, (vtype)e->type);
+ offset += e->type->size;
+ if(e->type != emit->env->class_def)
+ ADD_REF(e->type);
+ } while((e = e->next));
+ if(emit_exp(emit, exp, 0) < 0) {
+ free_vector(v);
+ ERR_B(exp->pos, "\t... in 'gack' expression.")
+ }
+ const Instr instr = emit_add_instr(emit, Gack);
+ instr->m_val = offset;
+ instr->m_val2 = (m_uint)v;
+ return GW_OK;
+}
+
+static const _exp_func prim_func[] = {
+ (_exp_func)prim_id, (_exp_func)prim_num, (_exp_func)prim_float, (_exp_func)prim_str,
+ (_exp_func)prim_array, (_exp_func)prim_gack, (_exp_func)prim_vec, (_exp_func)prim_vec,
+ (_exp_func)prim_vec, (_exp_func)prim_char, (_exp_func)dummy_func,
+};
+
+ANN static m_bool emit_exp_primary(const Emitter emit, const Exp_Primary* prim) { GWDEBUG_EXE
+ return prim_func[prim->primary_type](emit, prim);
+}
+
+ANN static m_bool emit_dot_static_data(const Emitter emit, const Value v, const uint emit_var) { GWDEBUG_EXE
+ const m_uint size = v->type->size;
+ const Instr instr = emit_kind(emit, size, emit_var, dotstatic);
+ instr->m_val = (m_uint)(v->owner_class->nspc->class_data + v->offset);
+ instr->m_val2 = size;
+ return GW_OK;
+}
+
+ANN static m_bool decl_static(const Emitter emit, const Var_Decl var_decl, const uint is_ref) {
+ const Value v = var_decl->value;
+ Code* code = emit->code;
+ emit->code = (Code*)vector_back(&emit->stack);
+ CHECK_BB(emit_instantiate_object(emit, v->type, var_decl->array, is_ref))
+ CHECK_BB(emit_dot_static_data(emit, v, 1))
+ emit_add_instr(emit, ObjectAssign);
+ emit->code = code;
+ return GW_OK;
+}
+
+ANN static m_bool emit_exp_decl_static(const Emitter emit, const Var_Decl var_decl, const uint is_ref) { GWDEBUG_EXE
+ const Value value = var_decl->value;
+ if(isa(value->type, t_object) > 0 && !is_ref)
+ CHECK_BB(decl_static(emit, var_decl, 0))
+ return emit_dot_static_data(emit, value, 1);
+}
+
+ANN static m_bool emit_exp_decl_non_static(const Emitter emit, const Var_Decl var_decl,
+ const uint is_ref, const uint emit_var) { GWDEBUG_EXE
+ const Value v = var_decl->value;
+ const Type type = v->type;
+ const Array_Sub array = var_decl->array;
+ const m_bool is_array = array && array->exp;
+ const m_bool is_obj = isa(type, t_object) > 0;
+ const uint emit_addr = ((is_ref && !array) || isa(type, t_object) < 0) ?
+ emit_var : 1;
+ if(is_obj && (is_array || !is_ref))
+ CHECK_BB(emit_instantiate_object(emit, type, array, is_ref))
+ f_instr *exec = (f_instr*)allocmember;
+ if(!GET_FLAG(v, member)) {
+ v->offset = emit_local(emit, v->type->size, is_obj);
+ exec = (f_instr*)(allocword);
+ }
+ const Instr instr = emit_kind(emit, v->type->size, emit_addr, exec);
+ instr->m_val = v->offset;
+ instr->m_val2 = v->type->size;
+ if(is_obj && (is_array || !is_ref)) {
+ const Instr assign = emit_add_instr(emit, ObjectAssign);
+ assign->m_val = (m_uint)emit_var;
+ if(is_array && !emit->env->scope)
+ ADD_REF(type)
+ }
+ return GW_OK;
+}
+
+ANN static m_bool emit_exp_decl_global(const Emitter emit, const Var_Decl var_decl,
+ const uint is_ref, const uint emit_var) { GWDEBUG_EXE
+ const Value v = var_decl->value;
+ const Type type = v->type;
+ const Array_Sub array = var_decl->array;
+ const m_bool is_array = array && array->exp;
+ const m_bool is_obj = isa(type, t_object) > 0;
+ const uint emit_addr = ((is_ref && !array) || isa(type, t_object) < 0) ?
+ emit_var : 1;
+ if(is_obj && (is_array || !is_ref))
+ CHECK_BB(emit_instantiate_object(emit, type, array, is_ref))
+ f_instr *exec = (f_instr*)dotstatic;
+ const Instr instr = emit_kind(emit, v->type->size, emit_addr, exec);
+ v->d.ptr = _mp_alloc(v->type->size);
+ SET_FLAG(v, union);
+ instr->m_val = (m_uint)v->d.ptr;
+ instr->m_val2 = v->type->size;
+ if(is_obj && (is_array || !is_ref)) {
+ const Instr assign = emit_add_instr(emit, ObjectAssign);
+ assign->m_val = (m_uint)emit_var;
+ if(is_array && !emit->env->scope)
+ ADD_REF(type)
+ const Instr instr = emit_add_instr(emit, RegAddRef);
+ instr->m_val = emit_var;
+ }
+ return GW_OK;
+}
+
+ANN static m_bool emit_class_def(const Emitter, const Class_Def);
+
+ANN static m_bool emit_exp_decl_template(const Emitter emit, const Exp_Decl* decl) { GWDEBUG_EXE
+ const Type t = typedef_base(decl->type);
+ if(!GET_FLAG(t, emit)) {
+ CHECK_BB(template_push_types(emit->env, t->def->tmpl->list.list, t->def->tmpl->base))
+ CHECK_BB(emit_class_def(emit, t->def))
+ emit_pop_type(emit);
+ }
+ return GW_OK;
+}
+
+ANN static m_bool emit_exp_decl(const Emitter emit, const Exp_Decl* decl) { GWDEBUG_EXE
+ Var_Decl_List list = decl->list;
+ const uint ref = GET_FLAG(decl->td, ref) || type_ref(decl->type);
+ const uint var = decl->self->emit_var;
+
+ if(GET_FLAG(decl->type, template))
+ CHECK_BB(emit_exp_decl_template(emit, decl))
+ m_uint scope;
+ const m_bool global = GET_FLAG(decl->td, global);
+ if(global)
+ scope = emit_push_global(emit);
+ do {
+ const uint r = (uint)(GET_FLAG(list->self->value, ref) + ref);
+ if(!GET_FLAG(list->self->value, used))
+ continue;
+ if(GET_FLAG(decl->td, static))
+ CHECK_BB(emit_exp_decl_static(emit, list->self, r))
+ else if(!global)
+ CHECK_BB(emit_exp_decl_non_static(emit, list->self, r, var))
+else
+ CHECK_BB(emit_exp_decl_global(emit, list->self, r, var))
+ } while((list = list->next));
+ if(global)
+ emit_pop(emit, scope);
+ return GW_OK;
+}
+
+ANN static m_uint vararg_size(const Exp_Call* exp_call, const Vector kinds) {
+ Exp e = exp_call->args;
+ Arg_List l = exp_call->m_func->def->arg_list;
+ m_uint size = 0;
+ while(e) {
+ if(!l) {
+ size += e->type->size;
+ vector_add(kinds, e->type->size);
+ } else
+ l = l->next;
+ e = e->next;
+ }
+ return size;
+}
+
+ANN static void emit_func_arg_vararg(const Emitter emit, const Exp_Call* exp_call) { GWDEBUG_EXE
+ const Instr instr = emit_add_instr(emit, VarargIni);
+ const Vector kinds = new_vector();
+ if((instr->m_val = vararg_size(exp_call, kinds)))
+ instr->m_val2 = (m_uint)kinds;
+ else {
+ instr->execute = VarargEmpty;
+ free_vector(kinds);
+ }
+}
+
+ANN static m_bool emit_func_args(const Emitter emit, const Exp_Call* exp_call) { GWDEBUG_EXE
+ if(exp_call->args)
+ CHECK_BB(emit_exp(emit, exp_call->args, 1))
+ if(GET_FLAG(exp_call->m_func->def, variadic))
+ emit_func_arg_vararg(emit, exp_call);
+ return GW_OK;
+}
+
+ANN static m_bool prepare_call(const Emitter emit, const Exp_Call* exp_call) { GWDEBUG_EXE
+ CHECK_BB(emit_func_args(emit, exp_call))
+ return emit_exp(emit, exp_call->func, 0);
+}
+
+ANN static inline m_int push_tmpl_func(const Emitter emit, const Func f,
+ const Type_List types) {
+ const Value v = f->value_ref;
+ const m_uint scope = emit_push(emit, v->owner_class, v->owner);
+ CHECK_BB(traverse_func_template(emit->env, f->def, types))
+ return (m_int)scope;
+}
+
+ANN static m_bool emit_exp_call_template(const Emitter emit, const Exp_Call* exp_call) {
+ if(emit->env->func && emit->env->func == exp_call->m_func)
+ return prepare_call(emit, exp_call);
+ const m_int scope = push_tmpl_func(emit, exp_call->m_func, exp_call->tmpl->types);
+ CHECK_BB(scope);
+ CHECK_BB(prepare_call(emit, exp_call))
+ emit_pop_type(emit);
+ emit_pop(emit, (m_uint)scope);
+ UNSET_FLAG(exp_call->m_func, checked);
+ return GW_OK;
+}
+
+ANN static m_bool emit_exp_call(const Emitter emit, const Exp_Call* exp_call) { GWDEBUG_EXE
+ if(!exp_call->tmpl)
+ CHECK_BB(prepare_call(emit, exp_call))
+ else
+ CHECK_BB(emit_exp_call_template(emit, exp_call))
+ return emit_exp_call1(emit, exp_call->m_func);
+}
+
+ANN static m_bool emit_binary_func(const Emitter emit, const Exp_Binary* bin) { GWDEBUG_EXE
+ const Exp_Call exp = { .func=bin->rhs, .args=bin->lhs, .m_func=bin->func, .tmpl=bin->tmpl, .self=bin->self };
+ return emit_exp_call(emit, &exp);
+}
+
+ANN static m_bool emit_exp_binary(const Emitter emit, const Exp_Binary* bin) { GWDEBUG_EXE
+ const Exp lhs = bin->lhs;
+ const Exp rhs = bin->rhs;
+ struct Op_Import opi = { .op=bin->op, .lhs=lhs->type, .rhs=rhs->type, .data = (uintptr_t)bin };
+ if(bin->op == op_chuck && isa(rhs->type, t_function) > 0)
+ return emit_binary_func(emit, bin);
+ CHECK_BB(emit_exp(emit, lhs, 1))
+ CHECK_BB(emit_exp(emit, rhs, 1))
+ return op_emit(emit, &opi);
+}
+
+ANN static m_bool emit_exp_cast(const Emitter emit, const Exp_Cast* cast) {
+ struct Op_Import opi = { .op=op_cast, .lhs=cast->exp->type, .rhs=cast->self->type, .data=(uintptr_t)cast};
+ CHECK_BB(emit_exp(emit, cast->exp, 0))
+ (void)op_emit(emit, &opi);
+ return GW_OK;
+}
+
+ANN static m_bool emit_exp_post(const Emitter emit, const Exp_Postfix* post) { GWDEBUG_EXE
+ struct Op_Import opi = { .op=post->op, .lhs=post->exp->type, .data=(uintptr_t)post };
+ CHECK_BB(emit_exp(emit, post->exp, 1))
+ return op_emit(emit, &opi);
+}
+
+ANN static m_bool emit_exp_dur(const Emitter emit, const Exp_Dur* dur) { GWDEBUG_EXE
+ CHECK_BB(emit_exp(emit, dur->base, 0))
+ CHECK_BB(emit_exp(emit, dur->unit, 0))
+ emit_add_instr(emit, FloatTimes);
+ return GW_OK;
+}
+
+ANN static m_bool is_special(const Type t) {
+ if(isa(t, t_complex) > 0 || isa(t, t_polar) > 0 ||
+ isa(t, t_vec3) > 0 || isa(t, t_vec4) > 0 ||
+ isa(t, t_vararg) > 0)
+ return GW_OK;
+ return GW_ERROR;
+}
+
+ANN static Type_List tmpl_tl(const Env env, const m_str name) {
+ const m_str start = strchr(name, '<');
+ const m_str end = strchr(name, '@');
+ char c[strlen(name)];
+ strcpy(c, start + 1);
+ c[strlen(start) - strlen(end) - 2] = '\0';
+ m_uint depth;
+ return str2tl(env, c, &depth);
+}
+
+ANN m_bool traverse_dot_tmpl(const Emitter emit, const struct dottmpl_ *dt) {
+ const m_uint scope = env_push_type(emit->env, dt->owner);
+ m_bool ret = GW_ERROR;
+ if(traverse_func_template(emit->env, dt->def, dt->tl) > 0) {
+ ret = emit_func_def(emit, dt->def);
+ nspc_pop_type(emit->env->curr);
+ }
+ env_pop(emit->env, scope);
+ return ret;
+}
+
+static inline m_bool push_func_code(const Emitter emit, const Func f) {
+ if(GET_FLAG(f, template) && f->value_ref->owner_class) {
+ const Instr _instr = (Instr)vector_back(&emit->code->instr);
+ assert(_instr->execute == DotTmpl);
+ size_t len = strlen(f->name);
+ size_t sz = len - strlen(f->value_ref->owner_class->name);
+ char c[sz + 1];
+ strncpy(c, f->name, sz);
+ c[sz] = '\0';
+ struct dottmpl_ *dt = mp_alloc(dottmpl);
+ dt->name = s_name(insert_symbol(c));
+ dt->overload = f->def->tmpl->base;
+ dt->tl = tmpl_tl(emit->env, c);
+ dt->base = f->def;
+ _instr->m_val = (m_uint)dt;
+ _instr->m_val2 = strlen(c);
+ return GW_OK;
+ }
+ const Instr _instr = (Instr)vector_back(&emit->code->instr);
+ if(_instr->opcode == (m_bit)(m_uint)RegPushImm)
+ return !!(_instr->m_val = (m_uint)f->code);
+ assert(_instr->opcode == (m_bit)(m_uint)RegPushBase);
+ _instr->m_val = (m_uint)f->code;
+ _instr->opcode = (m_bit)(m_uint)RegPushImm;
+ return GW_OK;
+}
+
+static m_bool emit_template_code(const Emitter emit, const Func f) {
+ if(GET_FLAG(f, ref))
+ CHECK_BB(traverse_template(emit->env, f->value_ref->owner_class->def))
+ const Value v = f->value_ref;
+ size_t scope = emit_push(emit, v->owner_class, v->owner);
+ CHECK_BB(emit_func_def(emit, f->def)) // orig
+ emit_pop(emit, scope);
+ return push_func_code(emit, f);
+}
+
+ ANN static Instr emit_call(const Emitter emit, const Func f) {
+ MEMOIZE_CALL
+ const Type t = actual_type(f->value_ref->type);
+ if(isa(t, t_fptr) < 0) {
+ const f_instr exec = GET_FLAG(f->def, builtin) ? GET_FLAG(f, member) ?
+ FuncMember : FuncStatic : FuncUsr;
+ return emit_add_instr(emit, exec);
+ }
+ /*const Instr ex = */emit_add_instr(emit, GWOP_EXCEPT);
+// ex->m_val = -SZ_INT;
+ return emit_add_instr(emit, FuncPtr);
+}
+
+ANN m_bool emit_exp_call1(const Emitter emit, const Func f) { GWDEBUG_EXE
+ if(!f->code || (GET_FLAG(f, ref) && !GET_FLAG(f, builtin))) {
+ if(GET_FLAG(f, template) && emit->env->func != f)
+ CHECK_BB(emit_template_code(emit, f))
+ } else if((f->value_ref->owner_class && is_special(f->value_ref->owner_class) > 0) ||
+ !f->value_ref->owner_class || GET_FLAG(f, template))
+ push_func_code(emit, f);
+ else {
+ const Instr back = (Instr)vector_back(&emit->code->instr);
+ if((f_instr)(m_uint)back->opcode == DotFunc)
+ back->m_val = f->vt_index;
+ }
+ if(GET_FLAG(f, member) && isa(actual_type(f->value_ref->type), t_fptr) > 0) {
+ const Instr back = (Instr)vector_back(&emit->code->instr);
+ m_bit exec = back->opcode;
+ m_uint val = back->m_val;
+ m_uint val2 = back->m_val2;
+ back->opcode = (m_bit)(m_uint)RegDup2;
+ back->m_val = f->def->stack_depth;
+ const Instr instr = emit_add_instr(emit, (f_instr)(m_uint)exec);
+ instr->m_val = val;
+ instr->m_val2 = val2;
+ }
+ const Instr offset = emit_add_instr(emit, RegSetImm);
+ offset->m_val = emit_code_offset(emit);
+ const Instr instr = emit_call(emit, f);
+ const m_uint size = instr->m_val = f->def->ret_type->size;
+ return (m_bool)(instr->m_val2 = kindof(size, !size));
+}
+
+ANN2(1,2) static m_bool emit_exp_spork_finish(const Emitter emit, const VM_Code code,
+ const m_uint depth, const m_bool f) {
+ const Instr ini = emit_add_instr(emit, SporkIni);
+ ini->m_val = (m_uint)code;
+ if(!f) {
+ const m_uint member = GET_FLAG(code, member) ? SZ_INT : 0;
+ const Instr pop = emit_add_instr(emit, RegPop);
+ pop->m_val = depth + member;
+ if(depth) {
+ const Instr spork = emit_add_instr(emit, SporkFunc);
+ spork->m_val = depth;
+ }
+ if(member) {
+ const Instr m = emit_add_instr(emit, SporkThis);
+ m->m_val = depth;
+ }
+ } else {
+ const Instr spork = emit_add_instr(emit, SporkExp);
+ spork->m_val = depth;
+ }
+ emit_add_instr(emit, SporkEnd);
+ return GW_OK;
+}
+
+static inline void stack_alloc(const Emitter emit) {
+ emit_local(emit, SZ_INT, 0);
+ emit->code->stack_depth += SZ_INT;
+}
+
+static inline void stack_alloc_this(const Emitter emit) {
+ SET_FLAG(emit->code, member);
+ stack_alloc(emit);
+}
+
+static m_bool scoped_stmt(const Emitter emit, const Stmt stmt, const m_bool pop) {
+ ++emit->env->scope;
+ emit_push_scope(emit);
+ const m_bool pure = SAFE_FLAG(emit->env->func, pure);
+ if(!pure)
+ emit_add_instr(emit, GcIni);
+ CHECK_BB(emit_stmt(emit, stmt, pop))
+ if(!pure)
+ emit_add_instr(emit, GcEnd);
+ emit_pop_scope(emit);
+ --emit->env->scope;
+ return GW_OK;
+}
+
+#define SPORK_FUNC_PREFIX "spork~func:%i"
+#define SPORK_CODE_PREFIX "spork~code:%i"
+
+static void push_spork_code(const Emitter emit, const m_str prefix, const int pos) {
+ char c[strlen(SPORK_FUNC_PREFIX) + num_digit(pos) + 1];
+ sprintf(c, prefix, pos);
+ emit_push_code(emit, c);
+}
+
+ANN static m_bool spork_func(const Emitter emit, const Exp_Call* exp) { GWDEBUG_EXE
+ CHECK_BB(prepare_call(emit, exp))
+ push_spork_code(emit, SPORK_FUNC_PREFIX, exp->self->pos);
+ if(GET_FLAG(exp->m_func, member))
+ SET_FLAG(emit->code, member);
+ const Instr p = emit_add_instr(emit, RegPushImm);
+ p->m_val = (m_uint)exp->m_func->code;
+ CHECK_BB(emit_exp_call1(emit, exp->m_func))
+ const VM_Code code = finalyze(emit);
+ const m_uint size = exp->m_func->def->stack_depth - (GET_FLAG(exp->m_func,
+ member) ? SZ_INT : 0);
+ return emit_exp_spork_finish(emit, code, size, 0);
+}
+
+ANN static m_bool spork_code(const Emitter emit, const Stmt stmt) { GWDEBUG_EXE
+ emit_add_instr(emit, RegPushImm);
+ push_spork_code(emit, SPORK_CODE_PREFIX, stmt->pos);
+ if(!SAFE_FLAG(emit->env->func, member))
+ stack_alloc_this(emit);
+ CHECK_BB(scoped_stmt(emit, stmt, 0))
+ const VM_Code code = finalyze(emit);
+ return emit_exp_spork_finish(emit, code, emit->code->stack_depth, 1);
+}
+
+ANN m_bool emit_exp_spork(const Emitter emit, const Exp_Unary* unary) {
+ return unary->code ? spork_code(emit, unary->code) :
+ spork_func(emit, &unary->exp->d.exp_call);
+}
+
+ANN static m_bool emit_exp_unary(const Emitter emit, const Exp_Unary* unary) { GWDEBUG_EXE
+ struct Op_Import opi = { .op=unary->op, .data=(uintptr_t)unary };
+ if(unary->op != op_spork && unary->exp) {
+ CHECK_BB(emit_exp(emit, unary->exp, 1))
+ opi.rhs = unary->exp->type;
+ }
+ return op_emit(emit, &opi);
+}
+
+ANN static m_bool emit_implicit_cast(const Emitter emit,
+ const restrict Type from, const restrict Type to) { GWDEBUG_EXE
+ struct Op_Import opi = { .op=op_impl, .lhs=from, .rhs=to, .data=(m_uint)from };
+ return op_emit(emit, &opi);
+}
+
+ANN static Instr emit_flow(const Emitter emit, const Type type,
+ const f_instr f1, const f_instr f2) { GWDEBUG_EXE
+ if(isa(type, t_float) > 0) {
+ return emit_add_instr(emit, f2);
+ }
+ return emit_add_instr(emit, f1);
+}
+
+ANN static m_bool emit_exp_if(const Emitter emit, const Exp_If* exp_if) { GWDEBUG_EXE
+ CHECK_BB(emit_exp(emit, exp_if->cond, 0))
+ const Instr op = emit_flow(emit, exp_if->cond->type, BranchEqInt, BranchEqFloat);
+ CHECK_BB(emit_exp(emit, exp_if->if_exp, 0))
+ const Instr op2 = emit_add_instr(emit, Goto);
+ op->m_val = emit_code_size(emit);
+ const m_bool ret = emit_exp(emit, exp_if->else_exp, 0);
+ op2->m_val = emit_code_size(emit);
+ return ret;
+}
+
+ANN static m_bool emit_exp_lambda(const Emitter emit, const Exp_Lambda * lambda) { GWDEBUG_EXE
+ if(lambda->def) {
+ const m_uint scope = !lambda->owner ?
+ emit->env->scope : emit_push_type(emit, lambda->owner);
+ CHECK_BB(emit_func_def(emit, lambda->def))
+ const Instr instr = emit_add_instr(emit, RegPushImm);
+ instr->m_val = (m_uint)lambda->def->func->code;
+ if(lambda->owner)
+ emit_pop(emit, scope);
+ } else
+ emit_add_instr(emit, RegPushImm);
+ return GW_OK;
+}
+
+DECL_EXP_FUNC(emit)
+
+ANN2(1) static m_bool emit_exp(const Emitter emit, Exp exp, const m_bool ref) { GWDEBUG_EXE
+ do {
+ CHECK_BB(exp_func[exp->exp_type](emit, &exp->d))
+ if(exp->cast_to)
+ CHECK_BB(emit_implicit_cast(emit, exp->type, exp->cast_to))
+ if(ref && isa(exp->type, t_object) > 0) {
+ const Instr instr = emit_add_instr(emit, RegAddRef);
+ instr->m_val = exp->emit_var;
+ }
+ if(emit->env->func && isa(exp->type, t_function) > 0 &&
+ !GET_FLAG(exp->type->d.func->value_ref->d.func_ref, pure))
+ UNSET_FLAG(emit->env->func, pure);
+ } while((exp = exp->next));
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_if(const Emitter emit, const Stmt_If stmt) { GWDEBUG_EXE
+ emit_push_scope(emit);
+ CHECK_BB(emit_exp(emit, stmt->cond, 0))
+ const Instr op = emit_flow(emit, isa(stmt->cond->type, t_object) > 0 ?
+ t_int : stmt->cond->type, BranchEqInt, BranchEqFloat);
+ CHECK_OB(op)
+ CHECK_BB(scoped_stmt(emit, stmt->if_body, 1))
+ const Instr op2 = emit_add_instr(emit, Goto);
+ op->m_val = emit_code_size(emit);
+ if(stmt->else_body)
+ CHECK_BB(scoped_stmt(emit, stmt->else_body, 1))
+ op2->m_val = emit_code_size(emit);
+ emit_pop_scope(emit);
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_code(const Emitter emit, const Stmt_Code stmt) { GWDEBUG_EXE
+ ++emit->env->scope;
+ const m_bool ret = stmt->stmt_list ? emit_stmt_list(emit, stmt->stmt_list) : 1;
+ --emit->env->scope;
+ return ret;
+}
+
+#ifdef OPTIMIZE
+ANN static m_bool optimize_taill_call(const Emitter emit, const Exp_Call* e) {
+ Exp arg = e->args;
+ if(arg)
+ CHECK_BB(emit_exp(emit, e->args, 0))
+ const Instr instr = emit_add_instr(emit, PutArgsInMem);
+ while(arg) {
+ instr->m_val += arg->type->size;
+ arg = arg->next;
+ }
+ emit_add_instr(emit, Goto);
+ return GW_OK;
+}
+#define OPTIMIZE_TCO\
+ if(stmt->val->exp_type == ae_exp_call && emit->env->func == stmt->val->d.exp_call.m_func)\
+ return optimize_taill_call(emit, &stmt->val->d.exp_call);
+#else
+#define OPTIMIZE_TCO
+#endif
+
+
+ANN static m_bool emit_stmt_return(const Emitter emit, const Stmt_Exp stmt) { GWDEBUG_EXE
+ if(stmt->val) {
+ OPTIMIZE_TCO
+ CHECK_BB(emit_exp(emit, stmt->val, 0))
+ if(isa(stmt->val->type, t_object) > 0)
+ emit_add_instr(emit, RegAddRef);
+ }
+ vector_add(&emit->code->stack_return, (vtype)emit_add_instr(emit, Goto));
+ return GW_OK;
+}
+
+ANN static inline m_bool emit_stmt_continue(const Emitter emit, const Stmt stmt __attribute__((unused))) { GWDEBUG_EXE
+ vector_add(&emit->code->stack_cont, (vtype)emit_add_instr(emit, Goto));
+ return GW_OK;
+}
+
+ANN static inline m_bool emit_stmt_break(const Emitter emit, const Stmt stmt __attribute__((unused))) { GWDEBUG_EXE
+ vector_add(&emit->code->stack_break, (vtype)emit_add_instr(emit, Goto));
+ return GW_OK;
+}
+
+ANN static inline void emit_push_stack(const Emitter emit) {
+ emit_push_scope(emit);
+ vector_add(&emit->code->stack_cont, (vtype)NULL);
+ vector_add(&emit->code->stack_break, (vtype)NULL);
+}
+
+ANN static void pop_vector(Vector v, const m_uint pc) {
+ Instr instr;
+ while((instr = (Instr)vector_pop(v)))
+ instr->m_val = pc;
+}
+
+ANN static void emit_pop_stack(const Emitter emit, const m_uint index) {
+ pop_vector(&emit->code->stack_cont, index);
+ pop_vector(&emit->code->stack_break, emit_code_size(emit));
+ emit_pop_scope(emit);
+}
+
+ANN static Instr _flow(const Emitter emit, const Exp e, const m_bool b) {
+ CHECK_BO(emit_exp(emit, e, 0))
+ const f_instr instr_i = b ? BranchEqInt : BranchNeqInt;
+ const f_instr instr_f = b ? BranchEqFloat : BranchNeqFloat;
+ return emit_flow(emit, e->type, instr_i, instr_f);
+}
+
+ANN static m_bool emit_stmt_flow(const Emitter emit, const Stmt_Flow stmt) { GWDEBUG_EXE
+ const m_uint index = emit_code_size(emit);
+ Instr op = NULL;
+ emit_push_stack(emit);
+ if(!stmt->is_do)
+ op = _flow(emit, stmt->cond, stmt->self->stmt_type == ae_stmt_while);
+ CHECK_BB(scoped_stmt(emit, stmt->body, 1))
+ if(stmt->is_do) {
+ CHECK_OB((op = _flow(emit, stmt->cond, stmt->self->stmt_type != ae_stmt_while)))
+ op->m_val = index;
+ } else {
+ const Instr goto_ = emit_add_instr(emit, Goto);
+ goto_->m_val = index;
+ op->m_val = emit_code_size(emit);
+ }
+ emit_pop_stack(emit, index);
+ return GW_OK;
+}
+
+ANN static m_uint get_decl_size(Var_Decl_List a) {
+ m_uint size = 0;
+ do if(GET_FLAG(a->self->value, used))
+ size += a->self->value->type->size;
+ while((a = a->next));
+ return size;
+}
+
+ANN static m_uint pop_exp_size(const Emitter emit, Exp e) {
+ m_uint size = 0;
+ do {
+ if(e->exp_type == ae_exp_primary &&
+ e->d.exp_primary.primary_type == ae_primary_hack) {
+ size += pop_exp_size(emit, e->d.exp_primary.d.exp);
+ continue;
+ }
+ size += (e->exp_type == ae_exp_decl ?
+ get_decl_size(e->d.exp_decl.list) : e->type->size);
+ } while((e = e->next));
+ return size;
+}
+
+ANN static void pop_exp(const Emitter emit, Exp e) {
+ const m_uint size = pop_exp_size(emit, e);
+ if(size) {
+ const Instr instr = emit_add_instr(emit, RegPop);
+ instr->m_val = size;
+ }
+}
+
+ANN static m_bool emit_stmt_for(const Emitter emit, const Stmt_For stmt) { GWDEBUG_EXE
+ emit_push_stack(emit);
+ CHECK_BB(emit_stmt(emit, stmt->c1, 1))
+ const m_uint index = emit_code_size(emit);
+ CHECK_BB(emit_stmt(emit, stmt->c2, 0))
+ const Instr op = emit_flow(emit, stmt->c2->d.stmt_exp.val->type,
+ BranchEqInt, BranchEqFloat);
+ CHECK_BB(scoped_stmt(emit, stmt->body, 1))
+ const m_uint action_index = emit_code_size(emit);
+ if(stmt->c3) {
+ CHECK_BB(emit_exp(emit, stmt->c3, 0))
+ pop_exp(emit, stmt->c3);
+ }
+ const Instr _goto = emit_add_instr(emit, Goto);
+ _goto->m_val = index;
+ op->m_val = emit_code_size(emit);
+ emit_pop_stack(emit, action_index);
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_auto(const Emitter emit, const Stmt_Auto stmt) { GWDEBUG_EXE
+ CHECK_BB(emit_exp(emit, stmt->exp, 0))
+ const Instr s1 = emit_add_instr(emit, MemSetImm);
+ const Instr s2 = emit_add_instr(emit, MemSetImm);
+ const m_uint ini_pc = emit_code_size(emit);
+ emit_push_stack(emit);
+ const Instr loop = emit_add_instr(emit, AutoLoopStart);
+ const m_uint offset = emit_local(emit, 2*SZ_INT, 0);
+ s2->m_val = stmt->v->offset = offset + SZ_INT;
+ CHECK_BB(emit_stmt(emit, stmt->body, 1))
+ const m_uint end_pc = emit_code_size(emit);
+ if(stmt->is_ptr) {
+ const Instr release = emit_add_instr(emit, ObjectRelease);
+ release->m_val = offset + SZ_INT;
+ }
+ const Instr end = emit_add_instr(emit, AutoLoopEnd);
+ const Instr tgt = emit_add_instr(emit, Goto);
+ end->m_val2 = emit_code_size(emit);
+ tgt->m_val = ini_pc;
+ s1->m_val = end->m_val = loop->m_val = offset;
+ if(stmt->is_ptr)
+ loop->m_val2 = (m_uint)stmt->v->type;
+ emit_pop_stack(emit, end_pc);
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_loop(const Emitter emit, const Stmt_Loop stmt) { GWDEBUG_EXE
+ emit_push_stack(emit);
+ CHECK_BB(emit_exp(emit, stmt->cond, 0))
+ m_int* counter = (m_int*)xcalloc(1, SZ_INT);
+ const Instr init = emit_add_instr(emit, InitLoopCounter);
+ init->m_val = (m_uint)counter;
+ const m_uint index = emit_code_size(emit);
+ const Instr deref = emit_add_instr(emit, DotStatic);
+ deref->m_val = (m_uint)counter;
+ deref->m_val2 = SZ_INT;
+ const Instr op = emit_add_instr(emit, BranchEqInt);
+ const Instr dec = emit_add_instr(emit, DecIntAddr);
+ dec->m_val = (m_uint)counter;
+ CHECK_BB(scoped_stmt(emit, stmt->body, 1))
+ const Instr _goto = emit_add_instr(emit, Goto);
+ _goto->m_val = index;
+ op->m_val = emit_code_size(emit);
+ emit_pop_stack(emit, index);
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_jump(const Emitter emit, const Stmt_Jump stmt) { GWDEBUG_EXE
+ if(!stmt->is_label)
+ stmt->data.instr = emit_add_instr(emit, Goto);
+ else {
+ if(switch_inside(emit->env, stmt->self->pos) && !strcmp(s_name(stmt->name), "default")) {
+ if(!strcmp(s_name(stmt->name), "default"))
+ vector_release(&stmt->data.v);
+ return switch_default(emit->env, emit_code_size(emit), stmt->self->pos);
+ }
+ if(!stmt->data.v.ptr)
+ ERR_B(stmt->self->pos, "illegal case")
+ const m_uint size = vector_size(&stmt->data.v);
+ if(!size) {
+ vector_release(&stmt->data.v);
+ ERR_B(stmt->self->pos, "label '%s' defined but not used.", s_name(stmt->name))
+ }
+ LOOP_OPTIM
+ for(m_uint i = size + 1; --i;) {
+ const Stmt_Jump label = (Stmt_Jump)vector_at(&stmt->data.v, i - 1);
+ if(!label->data.instr) {
+ vector_release(&stmt->data.v);
+ ERR_B(label->self->pos, "you are trying to use a upper label.")
+ }
+ label->data.instr->m_val = emit_code_size(emit);
+ }
+ vector_release(&stmt->data.v);
+ }
+ return GW_OK;
+}
+
+ANN static m_bool emit_switch_instr(const Emitter emit, Instr *instr) {
+ const m_uint dyn = switch_dyn(emit->env);
+ if(dyn) {
+ Exp e;
+ while((e = switch_expget(emit->env)))
+ CHECK_BB(emit_exp(emit, e, 0))
+ *instr = emit_add_instr(emit, SwitchIni);
+ } else {
+ const Instr instr = emit_add_instr(emit, RegSetImm);
+ instr->m_val = (m_uint)switch_map(emit->env);
+ }
+ return GW_OK;
+}
+
+ANN static void emit_switch_map(const Instr instr, const Map map) {
+ const Map m = new_map();
+ for(m_uint i = map_size(map) + 1; --i;)
+ map_set(m, VKEY(map, i-1), VVAL(map, i -1));
+ instr->m_val2 = (m_uint)m;
+}
+
+ANN static m_bool emit_stmt_switch(const Emitter emit, const Stmt_Switch stmt) { GWDEBUG_EXE
+ switch_get(emit->env, stmt);
+ Instr push = NULL;
+ CHECK_BB(emit_exp(emit, stmt->val, 0))
+ CHECK_BB(emit_switch_instr(emit, &push))
+ vector_add(&emit->code->stack_break, (vtype)NULL);
+ const Instr instr = emit_add_instr(emit, BranchSwitch);
+ instr->m_val2 = (m_uint)switch_map(emit->env);
+ CHECK_BB(emit_stmt(emit, stmt->stmt, 1))
+ instr->m_val = switch_idx(emit->env) ?: emit_code_size(emit);
+ if(push) {
+ emit_switch_map(push, (Map)instr->m_val2);
+ (push)->m_val = (m_uint)switch_vec(emit->env);
+ }
+ switch_end(emit->env);
+ pop_vector(&emit->code->stack_break, emit_code_size(emit));
+ return GW_OK;
+}
+
+ANN m_bool value_value(const Value v, m_int *value) {
+ if((!GET_FLAG(v, builtin) && !GET_FLAG(v, enum)) || GET_FLAG(v, member))
+ return 0;
+ *value = v->d.ptr ? *(m_int*)v->d.ptr : v->owner->class_data[v->offset];
+ return GW_OK;
+}
+
+ANN Value case_value(const Exp exp) {
+ if(exp->exp_type == ae_exp_primary) {
+ const Exp_Primary* prim = &exp->d.exp_primary;
+ if(prim->primary_type == ae_primary_num)
+ return NULL;
+ return prim->value;
+ }
+ const Exp_Dot* dot = &exp->d.exp_dot;
+ return find_value(actual_type(dot->t_base), dot->xid);
+}
+
+ANN static m_bool prim_value(const Exp exp, m_int *value) {
+ *value = (m_int)exp->d.exp_primary.d.num;
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_case(const Emitter emit, const Stmt_Exp stmt) { GWDEBUG_EXE
+ CHECK_BB(switch_inside(emit->env, stmt->self->pos))
+ m_int value = 0;
+ const Value v = case_value(stmt->val);
+ if((!v && prim_value(stmt->val, &value)) || value_value(v, &value)) {
+ CHECK_BB(switch_dup(emit->env, value, stmt->val->pos))
+ switch_dynpc(emit->env, value, emit_code_size(emit));
+ } else
+ switch_pc(emit->env, emit_code_size(emit));
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_type(const Emitter emit, const Stmt_Type stmt) { GWDEBUG_EXE
+ return stmt->type->def ? emit_class_def(emit, stmt->type->def) : 1;
+}
+
+ANN static m_bool emit_stmt_enum(const Emitter emit, const Stmt_Enum stmt) { GWDEBUG_EXE
+ LOOP_OPTIM
+ for(m_uint i = 0; i < vector_size(&stmt->values); ++i) {
+ const Value v = (Value)vector_at(&stmt->values, i);
+ if(!emit->env->class_def) {
+ ALLOC_PTR(addr, m_uint, i);
+ v->offset = emit_local(emit, SZ_INT, 0);
+ v->d.ptr = addr;
+ } else
+ *(m_uint*)(emit->env->class_def->nspc->class_data + v->offset) = i;
+ }
+ return GW_OK;
+}
+
+ANN void emit_union_offset(Decl_List l, const m_uint o) { GWDEBUG_EXE
+ do {
+ Var_Decl_List v = l->self->d.exp_decl.list;
+ do v->self->value->offset = o;
+ while((v = v->next));
+ } while((l = l->next));
+}
+
+ANN static m_bool emit_stmt_union(const Emitter emit, const Stmt_Union stmt) { GWDEBUG_EXE
+ Decl_List l = stmt->l;
+ m_uint scope = emit->env->scope;
+ const m_bool global = GET_FLAG(stmt, global);
+ if(stmt->xid) {
+ if(stmt->value->type->nspc->class_data_size && !stmt->value->type->nspc->class_data)
+ stmt->value->type->nspc->class_data =
+ (m_bit*)xcalloc(1, stmt->value->type->nspc->class_data_size);
+ stmt->value->type->nspc->offset = stmt->s;
+ if(!stmt->value->type->p)
+ stmt->value->type->p = mp_ini((uint32_t)stmt->value->type->size);
+ Type_Decl *type_decl = new_type_decl(new_id_list(stmt->xid, stmt->self->pos),
+ emit->env->class_def ? ae_flag_member : 0); // or zero ?
+ type_decl->flag = stmt->flag;
+ const Var_Decl var_decl = new_var_decl(stmt->xid, NULL, 0);
+ const Var_Decl_List var_decl_list = new_var_decl_list(var_decl, NULL);
+ const Exp exp = new_exp_decl(type_decl, var_decl_list);
+ exp->d.exp_decl.type = stmt->value->type;
+ var_decl->value = stmt->value;
+ CHECK_BB(emit_exp_decl(emit, &exp->d.exp_decl))
+ free_exp(exp);
+ if(global) {
+ const M_Object o = new_object(NULL, stmt->value->type);
+ stmt->value->d.ptr = (m_uint*)o;
+ SET_FLAG(stmt->value, builtin);
+ SET_FLAG(stmt->value, global);
+ }
+ scope = emit_push_type(emit, stmt->value->type);
+ } else if(stmt->type_xid) {
+ if(stmt->type->nspc->class_data_size && !stmt->type->nspc->class_data)
+ stmt->type->nspc->class_data =
+ (m_bit*)xcalloc(1, stmt->type->nspc->class_data_size);
+ stmt->type->nspc->offset = stmt->s;
+ if(!stmt->type->p)
+ stmt->type->p = mp_ini((uint32_t)stmt->type->size);
+ scope = emit_push_type(emit, stmt->type);
+ } else if(emit->env->class_def) {
+ if(!GET_FLAG(l->self->d.exp_decl.list->self->value, member))
+ stmt->o = emit_local(emit, stmt->s, 0);
+ } else if(global) {
+ void* ptr = (void*)xcalloc(1, stmt->s);
+ l = stmt->l;
+ do {
+ Var_Decl_List list = l->self->d.exp_decl.list;
+ list->self->value->d.ptr = ptr;
+ SET_FLAG(list->self->value, union);
+ } while((l = l->next));
+ SET_FLAG(stmt->l->self->d.exp_decl.list->self->value, enum);
+ }
+ emit_union_offset(stmt->l, stmt->o);
+ if(stmt->xid) {
+ const Instr instr = emit_add_instr(emit, RegPop);
+ instr->m_val = SZ_INT;
+ }
+ if(stmt->xid || stmt->type_xid || global)
+ emit_pop(emit, scope);
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_exp(const Emitter emit, const struct Stmt_Exp_* exp) {
+ return exp->val ? emit_exp(emit, exp->val, 0) : 1;
+}
+
+static const _exp_func stmt_func[] = {
+ (_exp_func)emit_stmt_exp, (_exp_func)emit_stmt_flow, (_exp_func)emit_stmt_flow,
+ (_exp_func)emit_stmt_for, (_exp_func)emit_stmt_auto, (_exp_func)emit_stmt_loop,
+ (_exp_func)emit_stmt_if, (_exp_func)emit_stmt_code, (_exp_func)emit_stmt_switch,
+ (_exp_func)emit_stmt_break, (_exp_func)emit_stmt_continue, (_exp_func)emit_stmt_return,
+ (_exp_func)emit_stmt_case, (_exp_func)emit_stmt_jump, (_exp_func)emit_stmt_enum,
+ (_exp_func)dummy_func, (_exp_func)emit_stmt_type, (_exp_func)emit_stmt_union,
+};
+
+ANN static m_bool emit_stmt(const Emitter emit, const Stmt stmt, const m_bool pop) { GWDEBUG_EXE
+ CHECK_BB(stmt_func[stmt->stmt_type](emit, &stmt->d))
+ if(pop && stmt->stmt_type == ae_stmt_exp && stmt->d.stmt_exp.val)
+ pop_exp(emit, stmt->d.stmt_exp.val);
+ return GW_OK;
+}
+
+ANN static m_bool emit_stmt_list(const Emitter emit, Stmt_List l) { GWDEBUG_EXE
+ do CHECK_BB(emit_stmt(emit, l->stmt, 1))
+ while((l = l->next));
+ return GW_OK;
+}
+
+ANN static m_bool emit_dot_static_import_data(const Emitter emit, const Value v, const uint emit_addr) { GWDEBUG_EXE
+ if(v->d.ptr && GET_FLAG(v, builtin)) { // from C
+ if(GET_FLAG(v, enum)) {
+ const Instr func_i = emit_add_instr(emit, RegPushImm);
+ func_i->m_val = (m_uint)v->d.ptr;
+ } else {
+ const m_uint size = v->type->size;
+ const Instr instr = emit_kind(emit, size, emit_addr, regpushimm);
+ instr->m_val = (isa(v->type, t_object) > 0 ?
+ (m_uint)&v->d.ptr : (m_uint)v->d.ptr);
+ instr->m_val2 = size;
+ }
+ return GW_OK;
+ }
+ return emit_dot_static_data(emit, v, emit_addr);
+}
+
+ANN static m_bool emit_complex_member(const Emitter emit, const Exp_Dot* member) { GWDEBUG_EXE
+ const Exp base = member->base;
+ base->emit_var = 1;
+ CHECK_BB(emit_exp(emit, base, 0))
+ const m_bool is_complex = !strcmp((isa(base->type, t_complex) > 0 ? "re" : "phase") ,
+ s_name(member->xid));
+ if(is_complex && member->self->emit_var) // skip
+ return GW_OK;
+ const Instr instr = emit_add_instr(emit, is_complex ? ComplexReal : ComplexImag);
+ instr->m_val = member->self->emit_var;
+ return GW_OK;
+}
+
+ANN static inline void emit_vec_func(const Emitter emit, const Value v) {
+ const Instr instr = emit_add_instr(emit, RegPushImm);
+ instr->m_val = (m_uint)v->d.func_ref->code;
+}
+
+ANN static m_bool emit_VecMember(const Emitter emit, const Exp_Dot* member) {
+ member->base->emit_var = 1;
+ CHECK_BB(emit_exp(emit, member->base, 0))
+ const Value v = find_value(member->base->type, member->xid);
+ if(GET_FLAG(v, func)) {
+ emit_vec_func(emit, v);
+ return GW_OK;
+ }
+ if(!v->offset && member->self->emit_var) // skip
+ return GW_OK;
+ const Instr instr = emit_add_instr(emit, VecMember);
+ instr->m_val2 = v->offset;
+ instr->m_val = member->self->emit_var;
+ return GW_OK;
+}
+
+ANN static m_bool emit_vararg_start(const Emitter emit, const m_uint offset) { GWDEBUG_EXE
+ if(emit->env->func->variadic)
+ ERR_B(0, "vararg.start already used. this is an error")
+ emit->env->func->variadic = emit_add_instr(emit, VarargTop);
+ emit->env->func->variadic->m_val = offset;
+ emit->env->func->variadic->m_val2 = emit_code_size(emit);
+ return GW_OK;
+}
+
+ANN static m_bool emit_vararg_end(const Emitter emit, const m_uint offset) { GWDEBUG_EXE
+ if(!emit->env->func->variadic)
+ ERR_B(0, "vararg.start not used before vararg.end. this is an error")
+ const Instr instr = emit_add_instr(emit, VarargEnd);
+ instr->m_val = offset;
+ instr->m_val2 = emit->env->func->variadic->m_val2;
+ emit->env->func->variadic->m_val2 = emit_code_size(emit);
+ return GW_OK;
+}
+
+ANN static m_bool emit_vararg(const Emitter emit, const Exp_Dot* member) { GWDEBUG_EXE
+ m_uint offset = emit->env->class_def ? SZ_INT : 0;
+ Arg_List l = emit->env->func->def->arg_list;
+ const m_str str = s_name(member->xid);
+ while(l) {
+ offset += l->type->size;
+ l = l->next;
+ }
+ if(!strcmp(str, "start"))
+ return emit_vararg_start(emit, offset);
+ if(!strcmp(str, "end"))
+ return emit_vararg_end(emit, offset);
+ const Instr instr = emit_add_instr(emit, VarargMember);
+ instr->m_val = offset;
+ instr->m_val2 = member->self->type->size;
+ return GW_OK;
+}
+
+ANN static m_bool emit_exp_dot_special(const Emitter emit, const Exp_Dot* member) { GWDEBUG_EXE
+ const Type t = member->t_base;
+ if(isa(t, t_complex) > 0 || isa(t, t_polar) > 0)
+ return emit_complex_member(emit, member);
+ else if(isa(t, t_vec3) > 0 || isa(t, t_vec4) > 0)
+ return emit_VecMember(emit, member);
+ return emit_vararg(emit, member);
+}
+
+ANN static m_bool emit_dot_static_func(const Emitter emit, const Func func) { GWDEBUG_EXE
+// if(func->code) {
+// const Instr func_i = emit_add_instr(emit, RegPushImm);
+// func_i->m_val = (m_uint)func->code;
+// } else {
+ // TODO: improve me
+ const Instr func_i = emit_add_instr(emit, PushStaticCode);
+ func_i->m_val = (m_uint)func;
+// }
+ return GW_OK;
+}
+
+ANN static m_bool emit_member_func(const Emitter emit, const Exp_Dot* member, const Func func) { GWDEBUG_EXE
+ if(emit_exp(emit, member->base, 0) < 0)
+ ERR_B(member->self->pos, "... in member function") // LCOV_EXCL_LINE
+ /*const Instr ex = */emit_add_instr(emit, GWOP_EXCEPT);
+ //ex->m_val = -SZ_INT;
+ if(GET_FLAG(member->base->type, force)) {
+ const Instr func_i = emit_add_instr(emit, RegPushImm);
+ func_i->m_val = (m_uint)func->code;
+ return GW_OK;
+ }
+ if(!func->def->tmpl) {
+ const Instr func_i = emit_add_instr(emit, DotFunc);
+ func_i->m_val = func->vt_index;
+ return GW_OK;
+ }
+ emit_add_instr(emit, DotTmpl);
+ return GW_OK;
+}
+
+ANN static inline void emit_member(const Emitter emit, const Value v, const uint emit_addr) {
+ /*const Instr ex = */emit_add_instr(emit, GWOP_EXCEPT);
+ //ex->m_val = -SZ_INT;
+ const m_uint size = v->type->size;
+ const Instr instr = emit_kind(emit, size, emit_addr, dotmember);
+ instr->m_val = v->offset;
+ instr->m_val2 = size;
+}
+
+ANN static m_bool emit_exp_dot_instance(const Emitter emit, const Exp_Dot* member) { GWDEBUG_EXE
+ const Type t_base = member->t_base;
+ const Value value = find_value(t_base, member->xid);
+ const uint emit_addr = member->self->emit_var;
+ if(isa(member->self->type, t_fptr) > 0) { // function pointer
+ if(GET_FLAG(value, member)) { // member
+ if(emit_exp(emit, member->base, 0) < 0)
+ ERR_B(member->self->pos, "... in member function") // LCOV_EXCL_LINE
+ emit_member(emit, value, emit_addr);
+ return GW_OK;
+ } else
+ return emit_dot_static_data(emit, value, emit_addr);
+ } else if(isa(member->self->type, t_function) > 0)
+ return emit_member_func(emit, member, value->d.func_ref);
+ else { // variable
+ if(GET_FLAG(value, member)) { // member
+ CHECK_BB(emit_exp(emit, member->base, 0))
+ emit_member(emit, value, emit_addr);
+ return GW_OK;
+ } else // static
+ CHECK_BB(emit_dot_static_import_data(emit, value, emit_addr))
+ }
+ return GW_OK;
+}
+
+ANN static m_bool emit_exp_dot_static(const Emitter emit, const Exp_Dot* member) { GWDEBUG_EXE
+ const Type t_base = member->t_base->d.base_type;
+ const Value value = find_value(t_base, member->xid);
+ if(isa(member->self->type, t_function) > 0 && isa(member->self->type, t_fptr) < 0)
+ return emit_dot_static_func(emit, value->d.func_ref);
+ return emit_dot_static_import_data(emit, value, member->self->emit_var);
+}
+
+ANN static m_bool emit_exp_dot(const Emitter emit, const Exp_Dot* member) { GWDEBUG_EXE
+ if(is_special(member->t_base) > 0)
+ return emit_exp_dot_special(emit, member);
+ if(isa(member->t_base, t_class) > 0)
+ return emit_exp_dot_static(emit, member);
+ return emit_exp_dot_instance(emit, member);
+}
+
+ANN static inline void emit_func_def_global(const Emitter emit, const Value value) { GWDEBUG_EXE
+ const Instr set_mem = emit_add_instr(emit, MemSetImm);
+ set_mem->m_val = value->offset = emit_local(emit, SZ_INT, 0);
+ set_mem->m_val2 = (m_uint)value->d.func_ref->code;
+}
+
+ANN static void emit_func_def_init(const Emitter emit, const Func func) { GWDEBUG_EXE
+ const Type t = emit->env->class_def;
+ char c[(t ? strlen(t->name) + 1 : 0) + strlen(func->name) + 6];
+ sprintf(c, "%s%s%s(...)", t ? t->name : "", t ? "." : "", func->name);
+ emit_push_code(emit, c);
+}
+
+ANN static void emit_func_def_args(const Emitter emit, Arg_List a) { GWDEBUG_EXE
+ do {
+ const Value value = a->var_decl->value;
+ const m_uint size = value->type->size;
+ const m_bool obj = isa(value->type, t_object) > 0;
+ emit->code->stack_depth += size;
+ value->offset = emit_local(emit, size, obj);
+ } while((a = a->next));
+}
+
+ANN static void emit_func_def_ensure(const Emitter emit, const Func_Def func_def) { GWDEBUG_EXE
+ const m_uint size = func_def->ret_type->size;
+ if(size) {
+ const Instr instr = emit_kind(emit, size, 0, regpushimm);
+ instr->m_val2 = size;
+ }
+ vector_add(&emit->code->stack_return, (vtype)emit_add_instr(emit, Goto));
+}
+
+ANN static void emit_func_def_return(const Emitter emit) { GWDEBUG_EXE
+ const m_uint val = emit_code_size(emit);
+ LOOP_OPTIM
+ for(m_uint i = vector_size(&emit->code->stack_return) + 1; --i; ) {
+ const Instr instr = (Instr)vector_at(&emit->code->stack_return, i-1);
+ instr->m_val = val;
+ }
+ vector_clear(&emit->code->stack_return);
+ emit_pop_scope(emit);
+ MEMOIZE_STORE
+ emit_add_instr(emit, FuncReturn);
+}
+
+ANN static void emit_func_def_code(const Emitter emit, const Func func) { GWDEBUG_EXE
+ func->code = emit_code(emit);
+ if(GET_FLAG(func->def, dtor)) {
+ emit->env->class_def->nspc->dtor = func->code;
+ Instr instr = (Instr)vector_back(func->code->instr);
+ instr->execute = DTOR_EOC;
+ ADD_REF(func->code)
+ }
+}
+
+ANN static m_bool emit_func_def_body(const Emitter emit, const Func_Def func_def) { GWDEBUG_EXE
+ if(func_def->arg_list)
+ emit_func_def_args(emit, func_def->arg_list);
+ if(GET_FLAG(func_def, variadic))
+ stack_alloc(emit);
+ if(func_def->d.code->d.stmt_code.stmt_list)
+ CHECK_BB(emit_stmt_code(emit, &func_def->d.code->d.stmt_code))
+ emit_func_def_ensure(emit, func_def);
+ return GW_OK;
+}
+
+ANN static m_bool emit_func_def(const Emitter emit, const Func_Def func_def) { GWDEBUG_EXE
+ const Func func = get_func(emit->env, func_def);
+ if(func->code)return GW_OK;
+ if(tmpl_list_base(func_def->tmpl)) { // don't check template definition
+ UNSET_FLAG(func_def, template);
+ return GW_OK;
+ }
+ if(SAFE_FLAG(emit->env->class_def, builtin) && GET_FLAG(emit->env->class_def, template))
+ return GW_OK;
+ emit_func_def_init(emit, func);
+ if(GET_FLAG(func, member))
+ stack_alloc_this(emit);
+ emit_push_scope(emit);
+ const Func former = emit->env->func;
+ emit->env->func = func;
+ CHECK_BB(emit_func_def_body(emit, func_def))
+ if(GET_FLAG(func_def, variadic) && !emit->env->func->variadic)
+ ERR_B(func_def->td->xid->pos, "invalid variadic use")
+ emit_func_def_return(emit);
+ emit_func_def_code(emit, func);
+ emit->env->func = former;
+ emit_pop_code(emit);
+ if(!emit->env->class_def && !GET_FLAG(func_def, global) && !func_def->tmpl)
+ emit_func_def_global(emit, func->value_ref);
+ MEMOIZE_INI
+ return GW_OK;
+}
+
+DECL_SECTION_FUNC(emit)
+
+ANN Code* emit_class_code(const Emitter emit, const m_str name) { GWDEBUG_EXE
+ const m_uint len = strlen(name) + 7;
+ char c[len];
+ snprintf(c, len, "class %s", name);
+ emit_push_code(emit, c);
+ stack_alloc_this(emit);
+ return emit->code;
+}
+
+ANN inline void emit_class_finish(const Emitter emit, const Nspc nspc) { GWDEBUG_EXE
+ emit_add_instr(emit, FuncReturn);
+ nspc->pre_ctor = emit_code(emit);
+}
+
+ANN static inline void emit_class_push(const Emitter emit, const Type type) { GWDEBUG_EXE
+ vector_add(&emit->env->class_stack, (vtype)emit->env->class_def);
+ emit->env->class_def = type;
+}
+
+ANN static inline void emit_class_pop(const Emitter emit) { GWDEBUG_EXE
+ emit->env->class_def = (Type)vector_pop(&emit->env->class_stack);
+ emit_pop_code(emit);
+}
+
+ANN static m_bool emit_class_def(const Emitter emit, const Class_Def class_def) { GWDEBUG_EXE
+ const Type type = class_def->type;
+ const Nspc nspc = type->nspc;
+ if(tmpl_class_base(class_def->tmpl))
+ return GW_OK;
+ if(class_def->ext && ((/*!GET_FLAG(type->parent, emit) &&*/
+ GET_FLAG(class_def->ext, typedef)) || class_def->ext->types)) {
+ const Type base = class_def->ext->array ?
+ array_base(type->parent) : type->parent;
+ if(!base->nspc->pre_ctor)
+ CHECK_BB(emit_class_def(emit, base->def))
+ }
+ if(nspc->class_data_size)
+ nspc->class_data = (m_bit*)xcalloc(1, nspc->class_data_size);
+ emit_class_push(emit, type);
+ emit_class_code(emit, type->name);
+ if(class_def->ext && class_def->ext->array)
+ CHECK_BB(emit_array_extend(emit, type->parent, class_def->ext->array->exp))
+ if(class_def->body) {
+ Class_Body body = class_def->body;
+ do CHECK_BB(emit_section(emit, body->section))
+ while((body = body->next));
+ }
+ emit_class_finish(emit, nspc);
+ emit_class_pop(emit);
+ SET_FLAG(type, emit);
+ return GW_OK;
+}
+
+ANN static void emit_free_code(Code* code) {
+ LOOP_OPTIM
+ for(m_uint j = vector_size(&code->instr) + 1; --j;)
+ mp_free(Instr, (Instr)vector_at(&code->instr, j - 1));
+ free_code(code);
+}
+
+ANN static void emit_free_stack(const Emitter emit) { GWDEBUG_EXE
+ LOOP_OPTIM
+ for(m_uint i = vector_size(&emit->stack) + 1; --i;)
+ emit_free_code((Code*)vector_at(&emit->stack, i - 1));
+ vector_clear(&emit->stack);
+ emit_free_code(emit->code);
+}
+
+ANN static inline m_bool emit_ast_inner(const Emitter emit, Ast ast) { GWDEBUG_EXE
+ do CHECK_BB(emit_section(emit, ast->section))
+ while((ast = ast->next));
+ return GW_OK;
+}
+
+ANN VM_Code emit_ast(const Emitter emit, Ast ast) { GWDEBUG_EXE
+ emit->code = new_code(emit, emit->env->name);
+ emit_push_scope(emit);
+ const m_bool ret = emit_ast_inner(emit, ast);
+ emit_pop_scope(emit);
+ if(ret > 0)
+ return finalyze(emit);
+ emit_free_stack(emit);
+ return NULL;
+}
projects / gwion.git / commitdiff