COLOR_ALWAYS,
} __attribute__((packed));
-typedef struct Arg_ {
+typedef struct CliArg_ {
struct CArg arg;
struct Map_ mod;
struct Vector_ add;
bool loop;
bool quit;
enum COLOR color;
-} Arg;
+} CliArg;
-ANN void arg_release(Arg *);
-ANN m_bool arg_parse(const Gwion, Arg *);
-ANN void arg_compile(const Gwion, Arg *);
+ANN void arg_release(CliArg *);
+ANN m_bool arg_parse(const Gwion, CliArg *);
+ANN void arg_compile(const Gwion, CliArg *);
#endif
} Clean;
ANN static void clean_array_sub(Clean *a, Array_Sub b);
-ANN static void clean_id_list(Clean *a, ID_List b);
ANN static void clean_type_list(Clean *a, Type_List b);
ANN static void clean_tmpl(Clean *a, Tmpl *b);
ANN static void clean_range(Clean *a, Range *b);
ANEW ANN Emitter new_emitter(MemPool);
ANN void free_emitter(MemPool, Emitter);
-ANN m_bool emit_ast(const Env env, Ast ast);
+ANN m_bool emit_ast(const Env env, Ast *ast);
ANN m_bool emit_func_def(const Emitter emit, const Func_Def fdef);
ANN m_bool emit_exp_call1(const Emitter, const Func, const bool is_static);
ANN2(1)
// trait helpers
ANN static inline bool has_trait(const Type t, const Symbol trait) {
ID_List list = t->info->traits;
- while (list) {
- if (list->xid == trait) return true;
- list = list->next;
+ for(uint32_t i = 0; i < list->len; i++) {
+ Symbol xid = *mp_vector_at(list, Symbol, i);
+ if (xid == trait) return true;
}
return false;
}
-ANN static inline ID_List miss_traits(const Type t, const Specialized_List sl) {
- ID_List traits = sl->traits;
- while (traits) {
- if (!has_trait(t, traits->xid)) return traits;
- traits = traits->next;
+ANN static inline Symbol miss_traits(const Type t, const Specialized *spec) {
+ ID_List traits = spec->traits;
+ for(uint32_t i = 0; i < traits->len; i++) {
+ Symbol xid = *mp_vector_at(traits, Symbol, i);
+ if (!has_trait(t, xid)) return xid;
}
return NULL;
}
+
typedef enum {
et_void,
et_int,
#define __GWION
// typedef struct Gwion_* Gwion;
+#include "arg.h"
#include "plug.h"
#include "driver.h"
#include "gwiondata.h"
struct PPArg_ * ppa;
};
-ANN m_bool gwion_ini(const Gwion, struct Arg_ *);
+ANN m_bool gwion_ini(const Gwion, CliArg*);
ANN VM * gwion_cpy(const VM *);
ANN void gwion_run(const Gwion gwion);
ANN void gwion_end(const Gwion gwion);
union {
Union_List list; // union
struct Vector_ v;
+ MP_Vector *mpv;
// ID_List curr;// enum
};
union {
ANN Symbol str2sym(const Gwion, const m_str, const loc_t);
ANN ID_List str2symlist(const Gwion, const m_str, const loc_t);
-ANN Var_Decl str2var(const Gwion, const m_str, const loc_t);
-ANN Var_Decl_List str2varlist(const Gwion, const m_str, const loc_t);
+ANN m_bool str2var(const Gwion, Var_Decl, const m_str, const loc_t);
ANN Type_Decl *str2td(const Gwion, const m_str, const loc_t);
ANN Type str2type(const Gwion, const m_str, const loc_t);
#define gwi_str2sym(gwi, path) str2sym(gwi->gwion, path, gwi->loc)
#define gwi_str2symlist(gwi, path) str2symlist(gwi->gwion, path, gwi->loc)
-#define gwi_str2var(gwi, path) str2var(gwi->gwion, path, gwi->loc)
-#define gwi_str2varlist(gwi, path) str2varlist(gwi->gwion, path, gwi->loc)
+#define gwi_str2var(gwi, decl, path) str2var(gwi->gwion, decl, path, gwi->loc)
#define gwi_str2td(gwi, path) str2td(gwi->gwion, path, gwi->loc)
#define gwi_str2type(gwi, path) str2type(gwi->gwion, path, gwi->loc)
return NULL; \
}
-ANN void gwi_body(const Gwi, const Ast);
+ANN void gwi_body(const Gwi, const Section*);
ANN Exp make_exp(const Gwi gwi, const m_str type, const m_str name);
}
ANN static inline void set_decl_ref(const Exp e) {
- if (e->exp_type == ae_exp_decl)
- SET_FLAG(e->d.exp_decl.list->self->value, late);
+ if (e->exp_type == ae_exp_decl) {
+ Var_Decl vd = mp_vector_at(e->d.exp_decl.list, struct Var_Decl_, 0);
+ SET_FLAG(vd->value, late);
+ }
}
ANN void func_operator(const Func_Def fdef, struct Op_Import *opi);
#define __GWIONPASS
typedef union __attribute__((__transparent_union__)) {
- struct Ast_ *ast;
+ Ast *ast;
m_bool * ret;
} PassArg;
ANN void * get_module(const struct Gwion_ *, const m_str);
ANN void set_module(const struct Gwion_ *gwion, const m_str name,
void *const ptr);
-ANN m_bool plugin_ini(struct Gwion_ *gwion, const m_str iname);
+ANN m_bool plugin_ini(struct Gwion_ *gwion, const m_str iname, const loc_t);
#define GWIMPORT_NAME import
#define GWMODINI_NAME gwmodini
#ifndef __TRAVERSE
#define __TRAVERSE
-ANN m_bool traverse_ast(const Env, const Ast);
+ANN m_bool traverse_ast(const Env, const Ast*);
ANN m_bool traverse_class_def(const Env, const Class_Def);
ANN m_bool traverse_func_def(const Env, const Func_Def);
ANN m_bool traverse_union_def(const Env, const Union_Def);
ANN m_bool traverse_type_def(const Env env, const Type_Def);
ANN m_bool traverse_exp(const Env, const Exp);
-ANN m_bool scan0_ast(const Env, Ast);
-ANN m_bool scan1_ast(const Env, Ast);
-ANN m_bool scan2_ast(const Env, Ast);
-ANN m_bool check_ast(const Env, Ast);
+ANN m_bool scan0_ast(const Env, Ast*);
+ANN m_bool scan1_ast(const Env, Ast*);
+ANN m_bool scan2_ast(const Env, Ast*);
+ANN m_bool check_ast(const Env, Ast*);
ANN m_bool scan1_exp(const Env, const Exp);
ANN m_bool scan2_exp(const Env, const Exp);
-Subproject commit a7f57ef9dec1fa797ab295adf89d8509d7a636dc
+Subproject commit 7121bd4bd7ba6429999b1c54f68d9c3edbfd416b
+#include <errno.h>
#include "gwion_util.h"
#include "gwion_ast.h"
#include "gwion_env.h"
ARG_CDOC,
};
-ANN static void arg_init(Arg *arg) {
+ANN static void arg_init(CliArg *arg) {
map_init(&arg->mod);
vector_init(&arg->add);
vector_init(&arg->lib);
arg->color = COLOR_AUTO;
}
-ANN void arg_release(Arg *arg) {
+ANN void arg_release(CliArg *arg) {
map_release(&arg->mod);
vector_release(&arg->add);
xfree((m_str)vector_front(&arg->lib));
static inline bool str2bool(const char *str) {
if (!str || !strcmp(str, "true")) return true;
if (!strcmp(str, "false")) return false;
- return atoi(str) ? true : false;
+ char *rem = NULL;
+ long opt = strtol(str, &rem, 10);
+ if(rem || errno == EINVAL) {
+ gw_err("invalid argument for boolean option, setting to `false`\n");
+ return false;
+ }
+ return !!opt;
}
ANN static inline void get_debug(const Gwion gwion, const char *dbg) {
gwion_set_cdoc(gwion, is_cdoc);
}
-ANN void arg_compile(const Gwion gwion, Arg *arg) {
+ANN void arg_compile(const Gwion gwion, CliArg *arg) {
const Vector v = &arg->add;
for (m_uint i = 0; i < vector_size(v); i++) {
switch (vector_at(v, i)) {
&opt[CDOC]);
}
-static inline void add2arg(Arg *const arg, const char *data,
+static inline void add2arg(CliArg *const arg, const char *data,
const enum arg_type type) {
vector_add(&arg->add, type);
vector_add(&arg->add, (vtype)data);
struct ArgInternal {
const Gwion gwion;
- Arg * arg;
+ CliArg *arg;
};
ANN m_bool _arg_parse(struct ArgInternal *arg);
static void myproc(void *data, cmdopt_t *option, const char *arg) {
struct ArgInternal *arg_int = data;
- Arg * _arg = arg_int->arg;
+ CliArg * _arg = arg_int->arg;
if (arg) {
if (!_arg->arg.idx)
_arg->arg.idx++;
config_parse(arg, c);
}
-ANN m_bool arg_parse(const Gwion gwion, Arg *a) {
+ANN m_bool arg_parse(const Gwion gwion, CliArg *a) {
struct ArgInternal arg = {.gwion = gwion, .arg = a};
arg_init(a);
#ifdef __FUZZING
if (b->exp) clean_exp(a, b->exp);
}
-ANN static void clean_id_list(Clean *a, ID_List b) {
- if (b->next) clean_id_list(a, b->next);
-}
-
-ANN static void clean_specialized_list(Clean *a, Specialized_List b) {
- if (b->traits) clean_id_list(a, b->traits);
- if (b->next) clean_specialized_list(a, b->next);
-}
+#define clean_id_list(a, b) {}
+#define clean_specialized_list(a, b) {}
ANN static void clean_type_list(Clean *a, Type_List b) {
- clean_type_decl(a, b->td);
- if (b->next) clean_type_list(a, b->next);
+ for(uint32_t i = 0; i < b->len; i++) {
+ Type_Decl *td = *mp_vector_at(b, Type_Decl*, i);
+ clean_type_decl(a, td);
+ }
}
ANN static void clean_tmpl(Clean *a, Tmpl *b) {
ANN static void clean_type_decl(Clean *a, Type_Decl *b) {
if (b->array) clean_array_sub(a, b->array);
if (b->types) clean_type_list(a, b->types);
+ if (b->fptr) clean_fptr_def(a, b->fptr);
if (b->next) clean_type_decl(a, b->next);
}
}
ANN static void clean_var_decl_list(Clean *a, Var_Decl_List b) {
- clean_var_decl(a, b->self);
- if (b->next) clean_var_decl_list(a, b->next);
+ for(uint32_t i = 0; i < b->len; i++) {
+ Var_Decl vd = mp_vector_at(b, struct Var_Decl_, i);
+ clean_var_decl(a, vd);
+ }
}
ANN static void clean_exp_decl(Clean *a, Exp_Decl *b) {
++a->scope;
clean_exp(a, b->exp);
clean_stmt(a, b->body);
-// if (b->v) value_remref(b->v, a->gwion);
if (b->v) mp_free(a->gwion->mp, Value, b->v);
if (b->idx) clean_idx(a, b->idx);
--a->scope;
}
ANN static void clean_case_list(Clean *a, Stmt_List b) {
- clean_stmt_case(a, &b->stmt->d.stmt_match);
- if (b->next) clean_case_list(a, b->next);
+ for(m_uint i = 0; i < b->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt stmt = (Stmt)(b->ptr + offset);
+ clean_stmt_case(a, &stmt->d.stmt_match);
+ }
}
ANN static void clean_handler_list(Clean *a, Handler_List b) {
++a->scope;
- clean_stmt(a, b->stmt);
+ for(uint32_t i = 0; i < b->len; i++) {
+ Handler *handler = mp_vector_at(b, Handler, i);
+ clean_stmt(a, handler->stmt);
+ }
--a->scope;
- if (b->next) clean_handler_list(a, b->next);
}
+
ANN static void clean_stmt_try(Clean *a, Stmt_Try b) {
++a->scope;
clean_stmt(a, b->stmt);
}
ANN static void clean_arg_list(Clean *a, Arg_List b) {
- if (b->td) clean_type_decl(a, b->td);
- clean_var_decl(a, b->var_decl);
- if (b->next) clean_arg_list(a, b->next);
+ for(uint32_t i = 0; i < b->len; i++) {
+ Arg *arg = (Arg*)(b->ptr + i * sizeof(Arg));
+ if (arg->td) clean_type_decl(a, arg->td);
+ clean_var_decl(a, &arg->var_decl);
+ }
}
ANN static void clean_stmt_list(Clean *a, Stmt_List b) {
- clean_stmt(a, b->stmt);
- if (b->next) clean_stmt_list(a, b->next);
+ for(m_uint i = 0; i < b->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt stmt = (Stmt)(b->ptr + offset);
+ clean_stmt(a, stmt);
+ }
}
ANN static void clean_func_base(Clean *a, Func_Base *b) {
free_class_def(gwion->mp, b);
}
-ANN static void clean_enum_def(Clean *a, Enum_Def b) {
+ANN static void clean_enum_def(Clean *a NUSED, Enum_Def b) {
clean_id_list(a, b->list);
if (b->values.ptr) vector_release(&b->values);
}
ANN static void clean_union_list(Clean *a, Union_List b) {
- clean_type_decl(a, b->td);
- if (b->next) clean_union_list(a, b->next);
+ for(uint32_t i = 0; i < b->len; i++) {
+ Union_Member *tgt = mp_vector_at(b, Union_Member, i);
+ clean_type_decl(a, tgt->td);
+ clean_var_decl(a, &tgt->vd);
+ }
}
ANN static void clean_union_def(Clean *a, Union_Def b) {
}
ANN static void clean_ast(Clean *a, Ast b) {
- clean_section(a, b->section);
- if (b->next) clean_ast(a, b->next);
+ for(m_uint i = 0; i < b->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ clean_section(a, (Section*)(b->ptr + offset));
+ }
}
ANN void ast_cleaner(const Gwion gwion, Ast b) {
#include "compile.h"
#include "gwion.h"
#include "pass.h"
-#include "clean.h"
enum compile_type { COMPILE_NAME, COMPILE_MSTR, COMPILE_FILE };
for (m_uint i = 0; i < vector_size(&gwion->data->passes->vec); ++i) {
const compilation_pass pass =
(compilation_pass)vector_at(&gwion->data->passes->vec, i);
- CHECK_BB(pass(gwion->env, c->ast));
+ CHECK_BB(pass(gwion->env, &c->ast));
}
return GW_OK;
}
env_reset(env);
load_context(ctx, env);
const m_bool ret = _passes(gwion, c);
+ ctx->tree = c->ast;
if (ret > 0) //{
nspc_commit(env->curr);
if (ret > 0 || env->context->global)
vector_add(&env->scope->known_ctx, (vtype)ctx);
else { // nspc_rollback(env->global_nspc);
- if (!ctx->error) {
- gw_err(_("{-}while compiling file `{0}{/}%s{-}`{0}\n"), c->base);
- ctx->error = 1;
- }
context_remref(ctx, env->gwion);
}
unload_context(ctx, env);
CHECK_OB((c->ast = parse(&arg)));
gwion->env->name = c->name;
const m_bool ret = passes(gwion, c);
- if (!arg.global) ast_cleaner(gwion, c->ast);
return ret;
}
} else {
const Instr instr = emit_add_instr(emit, RegPushMemDeref);
instr->m_val = v->from->offset;
- instr->m_val2 = v->type->size;
+ const Type t = (Type)vector_front(&v->type->info->tuple->contains);
+ instr->m_val2 = t->size;
}
return GW_OK;
}
#define emit_prim_nil (void *)dummy_func
ANN static void interp_multi(const Emitter emit, const Exp e) {
- Var_Decl_List list = e->d.exp_decl.list;
const bool emit_var = exp_getvar(e);
m_uint offset = 0;
- while ((list = list->next))
- offset += !emit_var ? list->self->value->type->size : SZ_INT;
+ Var_Decl_List list = e->d.exp_decl.list;
+ for(uint32_t i = 1; i < list->len; i++) {
+ Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ offset += !emit_var ? vd->value->type->size : SZ_INT;
+ }
if (offset) regpop(emit, offset);
}
-ANN static inline void interp_size(const Emitter emit, const Type t) {
+ANN static inline void interp_size(const Emitter emit, const Exp e) {
+ const Type t = !tflag(e->type, tflag_ref) || safe_tflag(e->cast_to, tflag_ref) ?
+ e->type : (Type)vector_front(&e->type->info->tuple->contains);
const Instr instr = regseti(emit, t->size);
instr->m_val2 = SZ_INT;
}
}
if (e->exp_type == ae_exp_decl) // why only objects?
interp_multi(emit, e);
- regseti(emit, (m_uint)e->type);
- interp_size(emit, e->type);
+ if(tflag(e->type, tflag_ref) && !safe_tflag(e->cast_to, tflag_ref)) {
+ const Type t = (Type)vector_front(&e->type->info->tuple->contains);
+ regseti(emit, (m_uint)t);
+ } else
+ regseti(emit, (m_uint)e->type);
+ interp_size(emit, e);
const m_bool isobj = isa(e->type, emit->gwion->type[et_object]) > 0;
if (isobj && e->exp_type != ae_exp_cast && !GET_FLAG(e->type, final)) emit_add_instr(emit, GackType);
const Instr instr = emit_add_instr(emit, Gack);
ANN static m_bool emit_exp_decl_non_static(const Emitter emit,
const Exp_Decl *decl,
- const Var_Decl var_decl,
+ const Var_Decl var_decl,
const uint is_ref,
const uint emit_var) {
const Value v = var_decl->value;
const uint var = exp_getvar(exp_self(decl));
const uint ref = GET_FLAG(decl->td, late) || type_ref(decl->type);
Var_Decl_List list = decl->list;
- do {
- const Value v = list->self->value;
+ for(uint32_t i = 0; i < list->len; i++) {
+ Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ const Value v = vd->value;
const uint r = ref || GET_FLAG(v, late);
if (GET_FLAG(decl->td, static))
- CHECK_BB(emit_exp_decl_static(emit, decl, list->self, r, var));
+ CHECK_BB(emit_exp_decl_static(emit, decl, vd, r, var));
else if (!global)
- CHECK_BB(emit_exp_decl_non_static(emit, decl, list->self, r, var));
+ CHECK_BB(emit_exp_decl_non_static(emit, decl, vd, r, var));
else
- CHECK_BB(emit_exp_decl_global(emit, decl, list->self, r, var));
- if (tflag(list->self->value->type, tflag_contract) &&
+ CHECK_BB(emit_exp_decl_global(emit, decl, vd, r, var));
+ if (tflag(v->type, tflag_contract) &&
!exp_getvar(exp_self(decl))) {
- const Type t = list->self->value->type;
+ const Type t = v->type;
struct Op_Import opi = {.lhs = t->info->base_type,
.op = insert_symbol("@implicit"),
.rhs = t};
CHECK_BB(op_emit(emit, &opi));
}
- set_late(emit->gwion, decl, list->self);
+ set_late(emit->gwion, decl, vd);
if (!exp_self(decl)->emit_var && GET_FLAG(array_base_simple(v->type), abstract) && !GET_FLAG(decl->td, late) &&
- GET_FLAG(v, late) && late_array(decl->td, list->self)
+ GET_FLAG(v, late) && late_array(decl->td, vd)
&& GET_FLAG(v->type, abstract)) {
env_warn(emit->env, decl->td->pos, _("Type '%s' is abstract, use {+G}late{0} instead of {G+}%s{0}"),
v->type->name, !GET_FLAG(decl->td, const) ? "var" : "const");
}
- } while ((list = list->next));
+ }
return GW_OK;
}
const m_uint scope =
!global ? emit->env->scope->depth : emit_push_global(emit);
const m_bool ret = emit_decl(emit, decl);
-
if (global) emit_pop(emit, scope);
return ret;
}
+
+// see take exp
+Exp nth_exp(Exp e, uint32_t n) {
+ for(uint32_t i = 0; i < n; i++)
+ e = e->next;
+ return e;
+}
+
ANN static m_uint vararg_size(const Gwion gwion, const Exp_Call *exp_call,
const Vector kinds) {
- Exp e = exp_call->args;
const Type t = actual_type(gwion, exp_call->func->type);
Arg_List l = t->info->func->def->base->args;
+ Exp e = l ? nth_exp(exp_call->args, l->len) : exp_call->args;
+// Exp e = l ? take_exp(exp_call->args, l->len - 1) : exp_call->args;
m_uint size = 0;
while (e) {
- if (!l) {
- size += e->type->size;
- vector_add(kinds, (vtype)e->type); // ->size
- } else
- l = l->next;
+ size += e->type->size;
+ vector_add(kinds, (vtype)e->type); // ->size
e = e->next;
}
return size;
return GW_OK;
}
-ANN static m_uint get_decl_size(Var_Decl_List a, bool emit_addr) {
+ANN static m_uint get_decl_size(Var_Decl_List list, bool emit_addr) {
m_uint size = 0;
- do // if(GET_FLAG(a->self->value, used))
- size += !emit_addr ? a->self->value->type->size : SZ_INT;
- while ((a = a->next));
+ for(uint32_t i = 0; i < list->len; i++) {
+ Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ // if(GET_FLAG(vd->value, used))
+ size += !emit_addr ? vd->value->type->size : SZ_INT;
+ }
return size;
}
+ANN static m_uint get_type_size(const Exp e) {
+ if(tflag(e->type, tflag_ref)&& !safe_tflag(e->cast_to, tflag_ref)) {
+ const Type base =(Type)vector_front(&e->type->info->tuple->contains);
+ return base->size;
+ }
+ return e->type->size;
+}
+
ANN static m_uint pop_exp_size(Exp e) {
const bool emit_addr = exp_getvar(e);
m_uint size = 0;
do {
size += (e->exp_type == ae_exp_decl
? get_decl_size(e->d.exp_decl.list, emit_addr)
- : !emit_addr ? e->type->size
+ : !emit_addr ? get_type_size(e)
+// : !emit_addr ? e->type->size
: SZ_INT);
} while ((e = e->next));
return size;
ANN static inline m_bool emit_exp_pop_next(const Emitter emit, Exp e) {
CHECK_BB(emit_exp(emit, e));
if (e->exp_type == ae_exp_decl) {
- Var_Decl_List list = e->d.exp_decl.list->next;
- while (list) {
- regpop(emit, !exp_getvar(e) ? list->self->value->type->size : SZ_INT);
- list = list->next;
+ Var_Decl_List list = e->d.exp_decl.list;
+ for(uint32_t i = 1; i < list->len; i++) {
+ Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ regpop(emit, !exp_getvar(e) ? vd->value->type->size : SZ_INT);
}
}
if (e->next) pop_exp(emit, e->next);
if (es.run) envset_pop(&es, dt->owner_class);
emit_pop(emit, scope);
emit->env->scope->shadowing = shadowing;
+ if(ret > 0) set_fflag(dt->def->base->func, fflag_tmpl);
return ret;
}
return instr;
}
-static m_bool me_cmp(MemoizeEmitter *me, const Arg_List arg) {
+static m_bool me_cmp(MemoizeEmitter *me, const Arg *arg) {
const Emitter emit = me->emit;
const Symbol sym = insert_symbol("?=");
struct Exp_ lhs = {
}
ANN static m_bool me_arg(MemoizeEmitter *me) {
- Arg_List arg = me->fdef->base->args;
- do {
+ Arg_List args = me->fdef->base->args;
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = (Arg*)(args->ptr + i * sizeof(Arg));
const m_uint sz = arg->type->size;
(void)me_push(me, sz);
const Instr instr = me_push(me, sz);
instr->m_val += me->offset + SZ_INT * 2;
CHECK_BB(me_cmp(me, arg));
- me->arg_offset += arg->type->size;
- } while ((arg = arg->next));
+ me->arg_offset += arg->type->size; // sz?
+ }
return GW_OK;
}
(e->cast_to ? isa(e->cast_to, emit->gwion->type[et_object]) > 0 : 1) &&
e->exp_type == ae_exp_decl && GET_FLAG(e->d.exp_decl.td, late) &&
exp_getuse(e) && !exp_getvar(e) &&
- GET_FLAG(e->d.exp_decl.list->self->value, late)) {
+ GET_FLAG((mp_vector_at(e->d.exp_decl.list, struct Var_Decl_, 0))->value, late)) {
+// GET_FLAG(e->d.exp_decl.list->self->value, late)) {
// e->exp_type == ae_exp_decl && !exp_getvar(e)) {
// const Instr instr = emit_add_instr(emit, GWOP_EXCEPT);
const Instr instr = emit_add_instr(emit, fast_except);
}
ANN static m_bool emit_stmt_code(const Emitter emit, const Stmt_Code stmt) {
+ if(!stmt->stmt_list) return GW_OK;
emit_push_scope(emit);
++emit->env->scope->depth;
- const m_bool ret =
- stmt->stmt_list ? emit_stmt_list(emit, stmt->stmt_list) : 1;
+ const m_bool ret = emit_stmt_list(emit, stmt->stmt_list);
emit_pop_scope(emit);
--emit->env->scope->depth;
return ret;
const m_uint key_offset = /*!stmt->idx
? */emit_local(emit, emit->gwion->type[et_int])
/*: emit_local(emit, stmt->idx->v->type)*/;
- const m_uint val_offset = emit_local(emit, stmt->v->type);
+ const m_uint val_offset = emit_localn(emit, stmt->v->type); // localn ?
const Instr tomem = emit_add_instr(emit, Reg2Mem);
tomem->m_val = arr_offset;
const Instr loop_idx = emit_add_instr(emit, MemSetImm);
.roll = each_op,
.unroll = each_op,
.idx = stmt->idx,
-.init = false
+ .init = false
};
if (n) {
loop.offset -= SZ_INT;
}
ANN static inline m_bool emit_handler_list(const restrict Emitter emit,
- const Handler_List handler,
+ const Handler_List handlers,
const Vector v) {
- const Instr instr = emit_add_instr(emit, HandleEffect);
- instr->m_val2 = (m_uint)handler->xid;
- CHECK_BB(scoped_stmt(emit, handler->stmt, 1));
- if (handler->next) CHECK_BB(emit_handler_list(emit, handler->next, v));
- emit_try_goto(emit, v);
- instr->m_val = emit_code_size(emit);
+ for(uint32_t i = 0; i < handlers->len; i++) {
+ Handler *handler = mp_vector_at(handlers, Handler, i);
+ const Instr instr = emit_add_instr(emit, HandleEffect);
+ instr->m_val2 = (m_uint)handler->xid;
+ CHECK_BB(scoped_stmt(emit, handler->stmt, 1));
+ //if (handler->next) CHECK_BB(emit_handler_list(emit, handler->next, v));
+ emit_try_goto(emit, v);
+ instr->m_val = emit_code_size(emit);
+ }
return GW_OK;
}
}
ANN static m_bool emit_stmt_cases(const Emitter emit, Stmt_List list) {
- do CHECK_BB(emit_stmt_match_case(emit, &list->stmt->d.stmt_match));
- while ((list = list->next));
+ for(m_uint i = 0; i < list->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt stmt = (Stmt)(list->ptr + offset);
+ CHECK_BB(emit_stmt_match_case(emit, &stmt->d.stmt_match));
+ }
return GW_OK;
}
}
ANN static m_bool emit_stmt_list(const Emitter emit, Stmt_List l) {
- do CHECK_BB(emit_stmt(emit, l->stmt, 1));
- while ((l = l->next));
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt stmt = (Stmt)(l->ptr + offset);
+ CHECK_BB(emit_stmt(emit, stmt, 1));
+ }
return GW_OK;
}
emit_push_code(emit, func->name);
}
-ANN static void emit_func_def_args(const Emitter emit, Arg_List a) {
- do {
- const Type type = a->var_decl->value->type;
+ANN static void emit_func_def_args(const Emitter emit, Arg_List args) {
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = (Arg*)(args->ptr + i * sizeof(Arg));
+ const Type type = arg->var_decl.value->type;
emit->code->stack_depth += type->size;
- a->var_decl->value->from->offset = emit_localn(emit, type);
- emit_debug(emit, a->var_decl->value);
- } while ((a = a->next));
+ arg->var_decl.value->from->offset = emit_localn(emit, type);
+ emit_debug(emit, arg->var_decl.value);
+ }
}
ANN static m_bool emit_func_def_return(const Emitter emit) {
HANDLE_SECTION_FUNC(emit, m_bool, Emitter)
ANN static inline m_bool emit_ast_inner(const Emitter emit, Ast ast) {
- do CHECK_BB(emit_section(emit, ast->section));
- while ((ast = ast->next));
+ for(m_uint i = 0; i < ast->len; i++) {
+ const m_uint offset = i * sizeof(struct Section_);
+ CHECK_BB(emit_section(emit, (Section*)(ast->ptr + offset)));
+ }
return emit_defers(emit);
}
emit->vararg_offset = 0;
}
-ANN m_bool emit_ast(const Env env, Ast ast) {
+ANN m_bool emit_ast(const Env env, Ast *ast) {
const Emitter emit = env->gwion->emit;
emit_clear(emit);
emit->code = new_code(emit, emit->env->name);
emit_push_scope(emit);
- const m_bool ret = emit_ast_inner(emit, ast);
+ const m_bool ret = emit_ast_inner(emit, *ast);
emit_pop_scope(emit);
if (ret > 0)
emit->info->code = finalyze(emit, EOC);
#include "gwion_env.h"
#include "vm.h"
#include "gwion.h"
+#include "clean.h"
ANN void free_context(const Context a, Gwion gwion) {
nspc_remref(a->nspc, gwion);
free_mstr(gwion->mp, a->name);
+ ast_cleaner(gwion, a->tree);
mp_free(gwion->mp, Context, a);
}
-ANN2(2) Context new_context(MemPool p, const Ast ast, const m_str str) {
+ANN2(1,3) Context new_context(MemPool p, const Ast ast, const m_str str) {
const Context context = mp_calloc(p, Context);
context->name = mstrdup(p, str);
context->nspc = new_nspc(p, context->name);
#include "traverse.h"
#include "vm.h"
#include "parse.h"
-#include "clean.h"
+//#include "clean.h"
ANN static struct Env_Scope_ *new_envscope(MemPool p) {
struct Env_Scope_ *a = mp_calloc(p, Env_Scope);
const m_uint size = vector_size(&a->known_ctx);
for (m_uint i = size + 1; --i;) {
const Context ctx = (Context)vector_at(&a->known_ctx, i - 1);
- if (!ctx->error && ctx->global) ast_cleaner(gwion, ctx->tree);
+// if (!ctx->error && ctx->global) ast_cleaner(gwion, ctx->tree);
context_remref(ctx, gwion);
}
}
#undef RETURN_TYPE
ANN Type find_type(const Env env, Type_Decl *path) {
- DECL_OO(const Type, type, = find_initial(env, path->xid));
+ DECL_OO(Type, type, = find_initial(env, path->xid));
while ((path = path->next) && type && type->nspc) {
const Nspc nspc = type->nspc;
- const Type child = find_in_parent(type, path->xid);
- if (!child)
+ if(!(type = find_in_parent(type, path->xid)))
ERR_O(path->pos, _("...(cannot find class '%s' in nspc '%s')"),
s_name(path->xid), nspc->name)
}
gwion->vm->gwion = gwion->emit->gwion = gwion->env->gwion = gwion;
}
-ANN static m_bool gwion_ok(const Gwion gwion, Arg *arg) {
+ANN static m_bool gwion_ok(const Gwion gwion, CliArg *arg) {
CHECK_BB(plug_ini(gwion, &arg->lib));
shreduler_set_loop(gwion->vm->shreduler, arg->loop);
if (gwion_audio(gwion) > 0) {
vector_release(&v);
}
-ANN m_bool gwion_ini(const Gwion gwion, Arg *arg) {
+ANN m_bool gwion_ini(const Gwion gwion, CliArg *arg) {
#ifdef USE_GETTEXT
setlocale(LC_ALL, NULL);
bindtextdomain(GWION_PACKAGE, LOCALE_INFO);
}
ANN2(1) void add_template(const Env env, const Type t) {
- Tmpl *tmpl = t->info->cdef->base.tmpl;
- if (tmpl) {
- nspc_push_type(env->gwion->mp, env->curr); //
- Specialized_List il = tmpl->list;
- do nspc_add_type(env->curr, il->xid, env->gwion->type[et_auto]);
- while ((il = il->next));
+ nspc_push_type(env->gwion->mp, env->curr); //
+ Specialized_List sl = t->info->cdef->base.tmpl->list;
+ for(uint32_t i = 0; i < sl->len; i++) {
+ Specialized *spec = mp_vector_at(sl, Specialized, i);
+ nspc_add_type(env->curr, spec->xid, env->gwion->type[et_auto]);
}
}
if (t->info->cdef && t->info->cdef->base.tmpl) {
gwi->tmpls++;
add_template(gwi->gwion->env, t);
+ set_tflag(t, tflag_cdef);
}
if (gwi->gwion->data->cdoc && t->info->cdef) {
lint_indent(gwi->lint);
struct td_checker tdc = {.str = path, .pos = pos};
return _str2sym(gwion, &tdc, path);
}
-
+/*
// only in enum.c
ANN ID_List str2symlist(const Gwion gwion, const m_str path, const loc_t pos) {
DECL_OO(const Symbol, sym, = str2sym(gwion, path, pos));
return new_id_list(gwion->mp, sym);
}
-
-ANN Var_Decl str2var(const Gwion gwion, const m_str path, const loc_t pos) {
+*/
+ANN m_bool str2var(const Gwion gwion, Var_Decl vd, const m_str path, const loc_t pos) {
struct td_checker tdc = {.str = path, .pos = pos};
- DECL_OO(const Symbol, sym, = __str2sym(gwion, &tdc));
+ DECL_OB(const Symbol, sym, = __str2sym(gwion, &tdc));
struct AC ac = {.str = tdc.str, .pos = pos};
- CHECK_BO(ac_run(gwion, &ac));
- const Array_Sub array = ac.depth ? mk_array(gwion->mp, &ac) : NULL;
- return new_var_decl(gwion->mp, sym, array, pos);
-}
-
-// only in udef.c
-ANN Var_Decl_List str2varlist(const Gwion gwion, const m_str path,
- const loc_t pos) {
- DECL_OO(const Var_Decl, var, = str2var(gwion, path, pos));
- return new_var_decl_list(gwion->mp, var, NULL);
+ CHECK_BB(ac_run(gwion, &ac));
+ vd->xid = sym;
+ vd->value = NULL;
+ vd->array = ac.depth ? mk_array(gwion->mp, &ac) : NULL;
+ vd->pos = pos;
+ return GW_OK;
}
#define SPEC_ERROR (Specialized_List) GW_ERROR
-ANN static Specialized_List _tmpl_list(const Gwion gwion,
- struct td_checker *tdc) {
+ANN static bool _tmpl_list(const Gwion gwion,
+ struct td_checker *tdc, Specialized_List *sl) {
DECL_OO(const Symbol, sym, = __str2sym(gwion, tdc));
- Specialized_List next = NULL;
+ // TODO: handle traits?
+ Specialized spec = {
+ .xid = sym,
+ .pos = tdc->pos
+ };
+ mp_vector_add(gwion->mp, sl, Specialized, spec);
if (*tdc->str == ',') {
++tdc->str;
- if (!(next = _tmpl_list(gwion, tdc)) || next == SPEC_ERROR)
- return SPEC_ERROR;
+ if (!_tmpl_list(gwion, tdc, sl))
+ return false;
}
- // TODO: handle traits?
- const Specialized_List list =
- new_specialized_list(gwion->mp, sym, NULL, tdc->pos);
- list->next = next;
- return list;
+ return true;
}
ANN static Specialized_List __tmpl_list(const Gwion gwion,
if (tdc->str[0] != ':') return NULL;
if (tdc->str[1] != '[') return SPEC_ERROR;
tdc->str += 2;
- const Specialized_List list = _tmpl_list(gwion, tdc);
- if (list == SPEC_ERROR) return SPEC_ERROR;
- if (tdc->str[0] != ']') { // unfinished template
- if (list) free_specialized_list(gwion->mp, list);
- return SPEC_ERROR;
+ Specialized_List sl = new_mp_vector(gwion->mp, sizeof(Specialized), 0);
+ if(!_tmpl_list(gwion, tdc, &sl) || tdc->str[0] != ']') {
+ free_specialized_list(gwion->mp, sl);
}
++tdc->str;
- return list;
+ return sl;
}
ANN m_bool check_typename_def(const Gwi gwi, ImportCK *ck) {
}
ANN static Type_Decl *_str2td(const Gwion gwion, struct td_checker *tdc);
-ANN Type_List __str2tl(const Gwion gwion, struct td_checker *tdc) {
+ANN bool str2tl(const Gwion gwion, struct td_checker *tdc, Type_List *tl) {
Type_Decl *td = _str2td(gwion, tdc);
- if (!td) GWION_ERR_O(tdc->pos, "invalid types");
- Type_List next = NULL;
+ if (!td) GWION_ERR_B(tdc->pos, "invalid types");
+ mp_vector_add(gwion->mp, tl, Type_Decl*, td);
if (*tdc->str == ',') {
++tdc->str;
- if (!(next = __str2tl(gwion, tdc))) {
- free_type_decl(gwion->mp, td);
- return NULL;
- }
+ if (!str2tl(gwion, tdc, tl))
+ return false;
}
- return new_type_list(gwion->mp, td, next);
+ return true;
}
ANN static Type_List td_tmpl(const Gwion gwion, struct td_checker *tdc) {
return (Type_List)GW_ERROR;
}
++tdc->str;
- Type_List tl = __str2tl(gwion, tdc);
- if (!tl) return (Type_List)GW_ERROR;
+ Type_List tl = new_mp_vector(gwion->mp, sizeof(Type_Decl*), 0);
+ if (!str2tl(gwion, tdc, &tl)) {
+ free_type_list(gwion->mp, tl);
+ return (Type_List)GW_ERROR;
+ }
if (tdc->str[0] != ']') {
free_type_list(gwion->mp, tl);
GWION_ERR(tdc->pos, "unfinished template");
ANN static m_bool td_info_run(const Env env, struct td_info *info) {
Type_List tl = info->tl;
- do {
- DECL_OB(const Type, t, = known_type(env, tl->td));
+ for(uint32_t i = 0; i < tl->len; i++) {
+ if (i) text_add(&info->text, ",");
+ Type_Decl *td = *mp_vector_at(tl, Type_Decl*, i);
+ DECL_OB(const Type, t, = known_type(env, td));
td_fullname(env, &info->text, t);
- if (tl->next) text_add(&info->text, ",");
- } while ((tl = tl->next));
+ }
return GW_OK;
}
CHECK_BB(ck_ini(gwi, ck_edef));
CHECK_OB((gwi->ck->xid = gwi_str2sym(gwi, type)));
vector_init(&gwi->ck->v);
+ gwi->ck->tmpl = new_mp_vector(gwi->gwion->mp, sizeof(Symbol), 0);
return GW_OK;
}
-
+/*
// adds the id_list to the enum
// change that algo?
ANN static void add2list(struct ImportCK *ck, const ID_List list) {
- if (!ck->tmpl)
- ck->tmpl = list;
- else
+ if (!ck->tmpl) {
+ ck->tmpl = new_mp_vector(list, ;
+ } else {
ck->curr->next = list;
+ }
ck->curr = list;
}
-/*
-void Append(DL_Enum* d, const ID_List list) {
- List* next = &d->base;
- while (*next != NULL) next = &(*next)->Next;
- *next = list;
- next->next = NULL;
-}
*/
//! add an enum entry
//! \arg the importer
//! TODO: change return type to m_bool
ANN m_int gwi_enum_add(const Gwi gwi, const m_str name, const m_uint i) {
CHECK_BB(ck_ok(gwi, ck_edef));
- DECL_OB(const ID_List, list, = gwi_str2symlist(gwi, name));
- add2list(gwi->ck, list);
+// DECL_OB(const ID_List, list, = gwi_str2symlist(gwi, name));
+
+ DECL_OB(const Symbol, xid, = gwi_str2sym(gwi, name));
+ mp_vector_add(gwi->gwion->mp, &gwi->ck->tmpl, Symbol, xid);
+// add2list(gwi->ck, list);
vector_add(&gwi->ck->v, (vtype)i);
return GW_OK;
}
gwi->ck->name = n;
CHECK_BB(check_typename_def(gwi, gwi->ck));
CHECK_OB((gwi->ck->td = gwi_str2td(gwi, t)));
- vector_init(&gwi->ck->v);
+ gwi->ck->mpv = new_mp_vector(gwi->gwion->mp, sizeof(Arg), 0);
return GW_OK;
}
return dl_func_init(gwi, t, n);
}
-ANN Arg_List make_dll_arg_list(const Vector v) {
- Arg_List base = (Arg_List)vector_front(v), arg_list = base;
- for (m_uint i = 1; i < vector_size(v); ++i)
- arg_list = (arg_list->next = (Arg_List)vector_at(v, i));
- vector_release(v);
- v->ptr = NULL;
- return base;
-}
-
ANEW ANN static Func_Base *gwi_func_base(const Gwi gwi, ImportCK *ck) {
- const Arg_List arg_list = make_dll_arg_list(&gwi->ck->v);
- Func_Base * base = new_func_base(gwi->gwion->mp, ck->td, ck->sym, arg_list,
+ Arg_List args = gwi->ck->mpv->len ? cpy_arg_list(gwi->gwion->mp, gwi->ck->mpv) : NULL;
+ Func_Base * base = new_func_base(gwi->gwion->mp, ck->td, ck->sym, args,
ck->flag, gwi->loc);
if (ck->variadic) base->fbflag |= fbflag_variadic;
ck->td = NULL;
}
ANN static m_bool section_fdef(const Gwi gwi, const Func_Def fdef) {
- Section * section = new_section_func_def(gwi->gwion->mp, fdef);
- const Ast body = new_ast(gwi->gwion->mp, section, NULL);
- gwi_body(gwi, body);
+// Section * section = new_section_func_def(gwi->gwion->mp, fdef);
+// const Ast body = new_ast(gwi->gwion->mp, section, NULL);
+ Section section = (Section) {
+ .section_type = ae_section_func,
+ .d = { .func_def = fdef }
+ };
+ gwi_body(gwi, §ion);
return GW_OK;
}
return GW_OK;
}
DECL_OB(Type_Decl *, td, = gwi_str2td(gwi, t));
- const Var_Decl var = gwi_str2var(gwi, n);
- if (var) {
- const Arg_List arg = new_arg_list(gwi->gwion->mp, td, var, NULL);
- vector_add(&gwi->ck->v, (vtype)arg);
+ struct Var_Decl_ var;
+ if(gwi_str2var(gwi, &var, n) > 0) {
+ Arg arg = { .td = td, .var_decl = var };
+ mp_vector_add(gwi->gwion->mp, &gwi->ck->mpv, Arg, arg);
return GW_OK;
}
free_type_decl(gwi->gwion->mp, td); // ???
}
ANN static m_bool section_fptr(const Gwi gwi, const Fptr_Def fdef) {
- Section * section = new_section_fptr_def(gwi->gwion->mp, fdef);
- const Ast body = new_ast(gwi->gwion->mp, section, NULL);
- gwi_body(gwi, body);
+ Section section = (Section) {
+ .section_type = ae_section_fptr,
+ .d = { .fptr_def = fdef }
+ };
+ gwi_body(gwi, §ion);
+// Section * section = new_section_fptr_def(gwi->gwion->mp, fdef);
+// const Ast body = new_ast(gwi->gwion->mp, section, NULL);
+// gwi_body(gwi, body);
return GW_OK;
}
ANN void ck_clean_fdef(MemPool mp, ImportCK *ck) {
if (ck->td) free_type_decl(mp, ck->td);
- if (ck->v.ptr) {
- for (m_uint i = 0; i < vector_size(&ck->v); ++i) {
- Arg_List list = (Arg_List)vector_at(&ck->v, i);
- list->next = NULL;
- free_arg_list(mp, list);
- }
- vector_release(&ck->v);
- }
+ free_arg_list(mp, ck->mpv);
if (ck->tmpl) free_id_list(mp, ck->tmpl);
}
#include "import.h"
#include "gwi.h"
-void gwi_body(const Gwi gwi, const Ast body) {
+void gwi_body(const Gwi gwi, const Section *section) {
const Class_Def cdef = gwi->gwion->env->class_def->info->cdef;
- if (!cdef->body)
- cdef->body = body;
- else
- gwi->body->next = body;
- gwi->body = body;
+ if (!cdef->body) {
+ mp_vector_first(gwi->gwion->mp, a, Section, *section);
+ cdef->body = a;
+ } else {
+ mp_vector_add(gwi->gwion->mp, &cdef->body, Section, (*section));
+ }
}
ANN void gwi_reset(const Gwi gwi) {
// gwion->env->context = ctx;
return ret;
}
+
}
ANN static m_int gwi_item_tmpl(const Gwi gwi) {
- const MemPool mp = gwi->gwion->mp;
- const Stmt stmt = new_stmt_exp(mp, ae_stmt_exp, gwi->ck->exp, gwi->loc);
- const Stmt_List slist = new_stmt_list(mp, stmt, NULL);
- Section * section = new_section_stmt_list(mp, slist);
- const Ast body = new_ast(mp, section, NULL);
- gwi_body(gwi, body);
+ mp_vector_first(gwi->gwion->mp, slist, struct Stmt_,
+ ((struct Stmt_) {
+ .stmt_type = ae_stmt_exp,
+ .d = { .stmt_exp = { .val = gwi->ck->exp } },
+ .pos = gwi->loc
+ }));
+ Section section = (Section) {
+ .section_type = ae_section_stmt,
+ .d = { .stmt_list = slist }
+ };
+// Section * section = new_section_stmt_list(mp, slist);
+// const Ast body = new_ast(mp, section, NULL);
+// gwi_body(gwi, body);
+ gwi_body(gwi, §ion);
mp_free2(gwi->gwion->mp, sizeof(ImportCK), gwi->ck);
gwi->ck = NULL;
return GW_OK;
if (env->class_def && tflag(env->class_def, tflag_tmpl))
return gwi_item_tmpl(gwi);
CHECK_BB(traverse_exp(env, gwi->ck->exp));
- const Value value = gwi->ck->exp->d.exp_decl.list->self->value;
+ const Value value = (mp_vector_at(gwi->ck->exp->d.exp_decl.list, struct Var_Decl_, 0))->value;
value->d = addr;
set_vflag(value, vflag_builtin);
if (!env->class_def) SET_FLAG(value, global);
// move me
ANN Exp make_exp(const Gwi gwi, const m_str type, const m_str name) {
DECL_OO(Type_Decl *, td, = gwi_str2td(gwi, type));
- const Var_Decl_List vlist = gwi_str2varlist(gwi, name);
- if (vlist) return new_exp_decl(gwi->gwion->mp, td, vlist, gwi->loc);
- free_type_decl(gwi->gwion->mp, td);
- return NULL;
+ struct Var_Decl_ vd;
+ if(gwi_str2var(gwi, &vd, name) < 0) {
+ free_type_decl(gwi->gwion->mp, td);
+ return NULL;
+ }
+ const Var_Decl_List list = new_mp_vector(gwi->gwion->mp, sizeof(struct Var_Decl_), 1);
+ mp_vector_set(list, struct Var_Decl_, 0, vd);
+ return new_exp_decl(gwi->gwion->mp, td, list, gwi->loc);
}
ANN m_int gwi_union_ini(const Gwi gwi, const m_str name) {
CHECK_BB(ck_ini(gwi, ck_udef));
gwi->ck->name = name;
CHECK_BB(check_typename_def(gwi, gwi->ck));
+ gwi->ck->mpv = new_mp_vector(gwi->gwion->mp, sizeof(Union_Member), 0);
return GW_OK;
}
CHECK_BB(ck_ok(gwi, ck_udef));
DECL_OB(Type_Decl *, td, = str2td(gwi->gwion, type, gwi->loc));
DECL_OB(const Symbol, xid, = str2sym(gwi->gwion, name, gwi->loc));
- const Union_List l = new_union_list(gwi->gwion->mp, td, xid, gwi->loc);
- l->next = gwi->ck->list;
- gwi->ck->list = l;
+ Union_Member um = { .td = td, .vd = { .xid = xid, .pos = gwi->loc } };
+ mp_vector_add(gwi->gwion->mp, &gwi->ck->list, Union_Member, um);
+// const Union_List l = new_union_list(gwi->gwion->mp, td, xid, gwi->loc);
+// l->next = gwi->ck->list;
+// gwi->ck->list = l;
return GW_OK;
}
ANN Type gwi_union_end(const Gwi gwi, const ae_flag flag) {
CHECK_BO(ck_ok(gwi, ck_udef));
- if (!gwi->ck->list) GWI_ERR_O(_("union is empty"));
- const Union_Def udef = new_union_def(gwi->gwion->mp, gwi->ck->list, gwi->loc);
+ if (!gwi->ck->mpv->len) GWI_ERR_O(_("union is empty"));
+ const Union_Def udef = new_union_def(gwi->gwion->mp, gwi->ck->mpv, gwi->loc);
gwi->ck->list = NULL;
udef->flag = flag;
udef->xid = gwi->ck->sym;
}
ANN void ck_clean_udef(MemPool mp, ImportCK *ck) {
- if (ck->list) free_union_list(mp, ck->list);
+ if (ck->mpv) free_mp_vector(mp, sizeof(Union_Member), ck->mpv);
if (ck->tmpl) free_id_list(mp, ck->tmpl);
}
#include "gwi.h"
#include "emit.h"
#include "looper.h"
+
static DTOR(array_dtor) {
if (*(void **)(o->data + SZ_INT)) xfree(*(void **)(o->data + SZ_INT));
struct M_Vector_ *a = ARRAY(o);
ERR_N(exp_self(bin)->pos, _("array depths do not match."));
}
if (bin->rhs->exp_type == ae_exp_decl) {
- if (bin->rhs->d.exp_decl.list->self->array &&
- bin->rhs->d.exp_decl.list->self->array->exp)
+ Var_Decl vd = mp_vector_at(bin->rhs->d.exp_decl.list, struct Var_Decl_, 0);
+ if (vd->array &&
+ vd->array->exp)
ERR_N(exp_self(bin)->pos,
_("do not provide array for 'xxx => declaration'."));
+ SET_FLAG(vd->value, late);
}
bin->rhs->ref = bin->lhs;
// bin->rhs->data = bin->lhs;
- if(bin->rhs->exp_type == ae_exp_decl)
- SET_FLAG(bin->rhs->d.exp_decl.list->self->value, late);
exp_setvar(bin->rhs, 1);
return bin->rhs->type;
}
frame->code = shred->code;
frame->offset = offset;
frame->index = 0;
- *(m_uint *)REG(SZ_INT) =
- offset; // + sizeof(frame_t);// + shred->code->stack_depth;
+ *(m_uint *)REG(SZ_INT) = offset;
shred->code = (VM_Code)code;
shred->pc = 0;
shredule(shred->tick->shreduler, shred, 0);
ANN static inline void _next(const VM_Shred shred, const m_uint offset) {
shred->pc = 0;
- *(m_uint *)REG(0) = offset; // + sizeof(frame_t);
+ *(m_uint *)REG(0) = offset;
POP_REG(shred, SZ_INT);
}
const Type t_array = env->gwion->type[et_array];
const Class_Def c = t_array->info->cdef;
DECL_ON(const Type, base,
- = ts->t != t_array ? ts->t : known_type(env, ts->td->types->td));
+ = ts->t != t_array ? ts->t : known_type(env, *mp_vector_at(ts->td->types, Type_Decl*, 0)));
if (base->size == 0) {
gwerr_basic("Can't use type of size 0 as array base", NULL, NULL,
"/dev/null", (loc_t) {}, 0);
cdef->base.ext = type2td(env->gwion, t_array, (loc_t) {});
cdef->base.xid = sym;
cdef->base.tmpl->base = 1; // could store depth here?
- cdef->base.tmpl->call = new_type_list(
- env->gwion->mp, type2td(env->gwion, base, (loc_t) {}), NULL);
+ cdef->base.tmpl->call = new_mp_vector(env->gwion->mp, sizeof(Type_Decl*), 1);
+ mp_vector_set(cdef->base.tmpl->call, Type_Decl*, 0, type2td(env->gwion, base, (loc_t) {}));
const Context ctx = env->context;
env->context = base->info->value->from->ctx;
const m_uint scope = env_push(env, base->info->value->from->owner_class,
.base = ts->t, .td = ts->td, .list = ts->t->info->cdef->base.tmpl->list};
const Type exists = tmpl_exists(env, &info);
if (exists) return exists != env->gwion->type[et_error] ? exists : NULL;
- CHECK_ON(ts->td->types);
- DECL_ON(const Type, key, = known_type(env, ts->td->types->td));
- CHECK_ON(ts->td->types->next);
- DECL_ON(const Type, val, = known_type(env, ts->td->types->next->td));
+ if(!ts->td->types || ts->td->types->len != 2) return env->gwion->type[et_error];
+ DECL_ON(const Type, key, = known_type(env, *mp_vector_at(ts->td->types, Type_Decl*, 0)));
+ DECL_ON(const Type, val, = known_type(env, *mp_vector_at(ts->td->types, Type_Decl*, 1)));
if(tflag(key, tflag_ref) || tflag(val, tflag_ref))
ERR_N(ts->td->pos, "can't use Ref:[] in dicts");
const Class_Def cdef = cpy_class_def(env->gwion->mp, env->gwion->type[et_dict]->info->cdef);
if (!tmpl) return;
Type_List tl = tmpl->call;
if (!tl) return;
- Specialized_List il = tmpl->list;
- while (il) {
- const Type t = known_type(env, tl->td);
- nspc_add_type(env->curr, il->xid, t);
- il = il->next;
- tl = tl->next;
+ Specialized_List sl = tmpl->list;
+ for(uint32_t i = 0; i < sl->len; i++) {
+ Specialized *spec = mp_vector_at(sl, Specialized, i);
+ Type_Decl *td = *mp_vector_at(tl, Type_Decl*, i);
+ const Type t = known_type(env, td);
+ nspc_add_type(env->curr, spec->xid, t);
}
}
return t1 == env->gwion->type[et_auto] ? GW_OK : GW_ERROR;
}
+ANN static inline bool handle_global(Func_Base *a, Func_Base *b) {
+ return (!b->func->value_ref->from->owner_class &&
+ (!GET_FLAG(a, global) && a->func->value_ref->from->owner_class));
+}
+
ANN static m_bool fptr_args(const Env env, Func_Base *base[2]) {
- Arg_List arg0 = base[0]->args, arg1 = base[1]->args;
- if(!base[0]->func->value_ref->from->owner_class &&
- (!GET_FLAG(base[1], global) && base[1]->func->value_ref->from->owner_class))
- arg0 = arg0->next;
- if(!base[1]->func->value_ref->from->owner_class &&
- (!GET_FLAG(base[0], global) && base[0]->func->value_ref->from->owner_class))
- arg1 = arg1->next;
- while (arg0) {
- CHECK_OB(arg1);
+ Arg_List args0 = base[0]->args, args1 = base[1]->args;
+ const bool offset0 = handle_global(base[0], base[1]);
+ const bool offset1 = handle_global(base[1], base[0]);
+ const uint32_t len0 = args0 ? args0->len : 0;
+ const uint32_t len1 = args1 ? args1->len : 0;
+ if(len0 - offset0 != len1 - offset1)
+ return GW_ERROR;
+ for(uint32_t i = 0; i < len1 - offset0; i++) {
+ const Arg *arg0 = (Arg*)(args0->ptr + (i + offset0) * sizeof(Arg));
+ const Arg *arg1 = (Arg*)(args1->ptr + (i + offset1) * sizeof(Arg));
if (arg0->type && arg1->type)
CHECK_BB(isa(arg0->type, arg1->type));
- else {
+ else if(!tmpl_base(base[0]->tmpl) && !tmpl_base(base[1]->tmpl)){
Type_Decl *td[2] = {arg0->td, arg1->td};
CHECK_BB(td_match(env, td));
}
- arg0 = arg0->next;
- arg1 = arg1->next;
}
- return !arg1 ? GW_OK : GW_ERROR;
+ return GW_OK;
}
ANN static bool fptr_effects(const Env env, struct FptrInfo *info) {
_("can't resolve operator"))
const Type l_type = info->lhs->value_ref->from->owner_class;
const Type r_type = info->rhs->value_ref->from->owner_class;
+ const Arg *l_arg = info->lhs->def->base->args ? mp_vector_at(info->lhs->def->base->args, Arg, 0) : NULL;
+ const Arg *r_arg = info->rhs->def->base->args ? mp_vector_at(info->rhs->def->base->args, Arg, 0) : NULL;
+// added when parsing bases template
+ const Type l_this = l_arg && l_arg->var_decl.value ? l_arg->var_decl.value->type : NULL;
+ const Type r_this = r_arg && r_arg->var_decl.value? r_arg->var_decl.value->type : NULL;
+
if (!r_type && l_type) {
if (/*!GET_FLAG(info->lhs, global) && */(!info->rhs->def->base->args ||
-isa(l_type, info->rhs->def->base->args->var_decl->value->type) < 0)
+isa(l_type, r_this) < 0)
)
ERR_B(info->pos,
_("can't assign member function to non member function pointer"))
} else if (!l_type && r_type) {
if (!GET_FLAG(info->rhs, global) && (!info->lhs->def->base->args ||
-isa(r_type, info->lhs->def->base->args->var_decl->value->type) < 0)
+isa(r_type, l_this) < 0)
)
ERR_B(info->pos,
_("can't assign non member function to member function pointer"))
ANN static m_bool _check_lambda(const Env env, Exp_Lambda *l,
const Func_Def def) {
- // if(l->def->base->func)return GW_OK;
+// if(l->def->base->func) return GW_OK;
+ Arg_List bases = def->base->args;
+ Arg_List args = l->def->base->args;
+ // arity match
+ if ((bases ? bases->len : 0) != (args ? args->len : 0))
+ ERR_B(exp_self(l)->pos, _("argument number does not match for lambda"))
const bool is_tmpl =
safe_tflag(def->base->func->value_ref->from->owner_class, tflag_tmpl);
if (is_tmpl)
template_push_types(
env,
def->base->func->value_ref->from->owner_class->info->cdef->base.tmpl);
- Arg_List base = def->base->args, arg = l->def->base->args;
- while (base && arg) {
- arg->td = type2td(env->gwion, known_type(env, base->td), exp_self(l)->pos);
- base = base->next;
- arg = arg->next;
+ if(bases) {
+ for(uint32_t i = 0; i < bases->len; i++) {
+ Arg *base = (Arg*)(bases->ptr + i * sizeof(Arg));
+ Arg *arg = (Arg*)(args->ptr + i * sizeof(Arg));
+ arg->td = type2td(env->gwion, known_type(env, base->td), exp_self(l)->pos);
+ }
+
}
l->def->base->td =
type2td(env->gwion, known_type(env, def->base->td), exp_self(l)->pos);
if (is_tmpl) nspc_pop_type(env->gwion->mp, env->curr);
- if (base || arg)
- ERR_B(exp_self(l)->pos, _("argument number does not match for lambda"))
l->def->base->flag = def->base->flag;
// if(GET_FLAG(def->base, global) && !l->owner &&
// def->base->func->value_ref->from->owner_class)
}
if(ret < 0) {
+ if(args) {
+ for(uint32_t i = 0; i < bases->len; i++) {
+ Arg *arg = (Arg*)(args->ptr + i * sizeof(Arg));
+ free_value(arg->var_decl.value, env->gwion);
+ arg->var_decl.value = NULL;
+ }
+ }
+/*
Arg_List args = l->def->base->args;
while(args) {
if(!args->var_decl->value) break;
args->var_decl->value = NULL;
args = args->next;
}
-
+*/
}
return ret;
}
const Type t = fptr_def->type;
free_fptr_def(env->gwion->mp, fptr_def);
// type_remref(t, env->gwion);
- bin->rhs->d.exp_decl.list->self->value->type = bin->rhs->type =
+ Var_Decl vd = mp_vector_at(bin->rhs->d.exp_decl.list, struct Var_Decl_, 0);
+ vd->value->type = bin->rhs->type =
bin->rhs->d.exp_decl.type = t;
exp_setvar(bin->rhs, 1);
return ret > 0 ? t : env->gwion->type[et_error];
static OP_CHECK(opck_fptr_at) {
Exp_Binary *bin = (Exp_Binary *)data;
- if (bin->rhs->exp_type == ae_exp_decl)
- UNSET_FLAG(bin->rhs->d.exp_decl.list->self->value, late);
+ if (bin->rhs->exp_type == ae_exp_decl) {
+ Var_Decl vd = mp_vector_at(bin->rhs->d.exp_decl.list, struct Var_Decl_, 0);
+ UNSET_FLAG(vd->value, late);
+ }
if (bin->lhs->exp_type == ae_exp_td)
ERR_N(bin->lhs->pos, "can't use type_decl expression");
// UNSET_FLAG(bin->rhs->d.exp_decl.list->self->value, late);
static m_bool op_impl_narg(const Env env, const Func_Def fdef,
const loc_t loc) {
+/*
m_uint narg = 0;
Arg_List arg = fdef->base->args;
while (arg) {
narg++;
arg = arg->next;
}
- if (narg == 2) return GW_OK;
+*/
+ Arg_List arg = fdef->base->args;
+ if (!arg && arg->len == 2) return GW_OK;
op_narg_err(env, fdef, loc);
return GW_ERROR;
}
static inline void op_impl_ensure_types(const Env env, const Func func) {
- Arg_List arg = func->def->base->args;
const bool owner_tmpl =
safe_tflag(func->value_ref->from->owner_class, tflag_tmpl);
- const bool func_tmpl = fflag(func, fflag_tmpl);
if (owner_tmpl)
template_push_types(
env, func->value_ref->from->owner_class->info->cdef->base.tmpl);
+ const bool func_tmpl = fflag(func, fflag_tmpl);
if (func_tmpl) template_push_types(env, func->def->base->tmpl);
+
+ Arg_List args = func->def->base->args;
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = (Arg*)(args->ptr + i * sizeof(Arg));
+ if (!arg->type) arg->type = known_type(env, arg->td);
+ }
+/*
while (arg) {
if (!arg->type) arg->type = known_type(env, arg->td);
arg = arg->next;
}
+*/
if (!func->def->base->ret_type)
func->def->base->ret_type = known_type(env, func->def->base->td);
if (owner_tmpl) nspc_pop_type(env->gwion->mp, env->curr);
op_impl_ensure_types(env, func);
const Symbol lhs_sym = insert_symbol("@lhs");
const Symbol rhs_sym = insert_symbol("@rhs");
+ const Arg *arg0 = (Arg*)(func->def->base->args->ptr);
+ const Arg *arg1 = (Arg*)(func->def->base->args->ptr + sizeof(Arg));
struct Exp_ _lhs = {
.d = {.prim = {.d = {.var = lhs_sym}, .prim_type = ae_prim_id}},
.exp_type = ae_exp_primary,
- .type = func->def->base->args->type,
- .pos = func->def->base->args->td->pos};
+ .type = arg0->type,
+ .pos = arg0->td->pos};
struct Exp_ _rhs = {
.d = {.prim = {.d = {.var = rhs_sym}, .prim_type = ae_prim_id}},
.exp_type = ae_exp_primary,
- .type = func->def->base->args->next->type,
- .pos = func->def->base->args->next->td->pos};
+ .type = arg1->type,
+ .pos = arg1->td->pos};
struct Exp_ self = {.pos = impl->e->pos};
// Exp_Binary _bin = { .lhs=&_lhs, .op=impl->e->d.prim.d.var, .rhs=&_rhs };//
// .lhs=func->def->base->args // TODO
self.d.exp_binary.rhs = &_rhs;
self.d.exp_binary.op = impl->e->d.prim.d.var;
struct Op_Import opi = {.op = impl->e->d.prim.d.var,
- .lhs = func->def->base->args->type,
- .rhs = func->def->base->args->next->type,
+ .lhs = arg0->type,
+ .rhs = arg1->type,
.data = (uintptr_t)&self.d.exp_binary,
.pos = impl->e->pos};
vector_add(&env->scope->effects, 0);
}
}
const Arg_List args = cpy_arg_list(env->gwion->mp, func->def->base->args);
- // beware shadowing ?
- args->var_decl->xid = lhs_sym;
- args->next->var_decl->xid = rhs_sym;
+ Arg *larg0 = (Arg*)(args->ptr);
+ Arg *larg1 = (Arg*)(args->ptr + sizeof(Arg));
+ larg0->var_decl.xid = rhs_sym;
+ larg1->var_decl.xid = rhs_sym;
Func_Base *base =
new_func_base(env->gwion->mp, type2td(env->gwion, t, impl->e->pos),
impl->e->d.prim.d.var, args, ae_flag_none, impl->e->pos);
m_vector_release(eff);
}
const Exp lhs =
- new_prim_id(env->gwion->mp, args->var_decl->xid, impl->e->pos);
+ new_prim_id(env->gwion->mp, larg0->var_decl.xid, impl->e->pos);
const Exp rhs =
- new_prim_id(env->gwion->mp, args->next->var_decl->xid, impl->e->pos);
+ new_prim_id(env->gwion->mp, larg1->var_decl.xid, impl->e->pos);
const Exp bin = new_exp_binary(env->gwion->mp, lhs, impl->e->d.prim.d.var,
rhs, impl->e->pos);
- const Stmt stmt =
- new_stmt_exp(env->gwion->mp, ae_stmt_return, bin, impl->e->pos);
- const Stmt_List list = new_stmt_list(env->gwion->mp, stmt, NULL);
- const Stmt code = new_stmt_code(env->gwion->mp, list, impl->e->pos);
+ mp_vector_first(env->gwion->mp, slist, struct Stmt_,
+ ((struct Stmt_) {
+ .stmt_type = ae_stmt_return, .d = { .stmt_exp = { .val = bin }},
+ .pos = impl->e->pos
+ }));
+ const Stmt code = new_stmt_code(env->gwion->mp, slist, impl->e->pos);
const Func_Def def = new_func_def(env->gwion->mp, base, code);
def->base->xid = impl->e->d.prim.d.var;
const m_uint scope = env_push(env, NULL, opi.nspc);
ANN Type check_exp_unary_spork(const Env env, const Stmt code);
ANN static void fork_exp(const Env env, const Exp_Unary *unary) {
- const Stmt stmt =
- new_stmt_exp(env->gwion->mp, ae_stmt_exp, unary->exp, unary->exp->pos);
- const Stmt_List list = new_stmt_list(env->gwion->mp, stmt, NULL);
- const Stmt code = new_stmt_code(env->gwion->mp, list, unary->exp->pos);
+ mp_vector_first(env->gwion->mp, slist, struct Stmt_,
+ ((struct Stmt_) {
+ .stmt_type = ae_stmt_exp, .d = { .stmt_exp = { .val = unary->exp, } },
+ .pos = unary->exp->pos
+ }));
+ const Stmt code = new_stmt_code(env->gwion->mp, slist, unary->exp->pos);
((Exp_Unary *)unary)->exp = NULL;
((Exp_Unary *)unary)->code = code;
((Exp_Unary *)unary)->unary_type = unary_code;
static OP_CHECK(opck_usrugen) {
Exp_Binary * bin = (Exp_Binary *)data;
const Arg_List arg = bin->lhs->type->info->func->def->base->args;
- if (!arg || arg->next)
+ if (!arg || arg->len > 1)
ERR_N(exp_self(bin)->pos,
_("Tick function take one and only one argument"));
- if (isa(arg->type, env->gwion->type[et_float]) < 0)
+ if (isa(((Arg*)(arg->ptr))->type, env->gwion->type[et_float]) < 0)
ERR_N(exp_self(bin)->pos,
_("Tick functions argument must be of type float"));
if (isa(bin->lhs->type->info->func->def->base->ret_type,
const Exp_Binary *bin = (Exp_Binary *)data;
if (opck_rassign(env, data) == env->gwion->type[et_error])
return env->gwion->type[et_error];
- if (bin->rhs->exp_type == ae_exp_decl)
- SET_FLAG(bin->rhs->d.exp_decl.list->self->value, late);
+ if (bin->rhs->exp_type == ae_exp_decl) {
+ Var_Decl vd = mp_vector_at(bin->rhs->d.exp_decl.list, struct Var_Decl_, 0);
+ SET_FLAG(vd->value, late);
+ }
exp_setvar(bin->rhs, 1);
CHECK_BO(isa(bin->lhs->type, bin->rhs->type));
bin->lhs->ref = bin->rhs;
const Class_Def cdef = new_class_def(
env->gwion->mp, c->flag, info->name,
c->base.ext ? cpy_type_decl(env->gwion->mp, c->base.ext) : NULL,
- c->body ? cpy_ast(env->gwion->mp, c->body) : NULL, c->pos);
+ NULL, c->pos);
+ if(c->body) cdef->body = cpy_ast(env->gwion->mp, c->body);
cdef->cflag = c->cflag;
cdef->base.tmpl = mk_tmpl(env, c->base.tmpl, info->td->types);
const m_bool ret = scan0_class_def(env, cdef);
ANN Type tmpl_exists(const Env env, struct tmpl_info *const info);
-ANN bool tmpl_global(const Env env, Type_List call) {
- do {
- if(!type_global(env, known_type(env, call->td)))
+ANN bool tmpl_global(const Env env, Type_List tl) {
+ for(uint32_t i = 0; i < tl->len; i++) {
+ Type_Decl *td = *mp_vector_at(tl, Type_Decl*, i);
+ if(!type_global(env, known_type(env, td)))
return false;
- } while((call = call->next));
+ };
return true;
}
ANN static inline Type ptr_base(const Env env, const Type t) {
return (Type)vector_front(&t->info->tuple->types);
- return known_type(env, t->info->cdef->base.tmpl->call->td);
+// return known_type(env, *mp_vector_at(t->info->cdef->base.tmpl->call, Type_Decl*, 0));
}
static OP_CHECK(opck_ptr_assign) {
Type u = bin->rhs->type;
do {
const Type base = ptr_base(env, u);
-// if (isa(t, base) > 0) return t;
if (isa(t, base) > 0) return bin->rhs->type;
} while ((u = u->info->parent) && u->info->cdef->base.tmpl->call);
} while ((t = t->info->parent));
- return env->gwion->type[et_error];
+ ERR_N(exp_self(bin)->pos, "can't assign to pointer");
}
static OP_EMIT(opem_ptr_assign) {
static OP_CHECK(opck_ptr_cast) {
const Exp_Cast *cast = (Exp_Cast *)data;
- if (!cast->td->types || !cast->td->types->td)
+ if (!cast->td->types || !cast->td->types->len)
ERR_N(exp_self(cast)->pos, "'Ptr' needs types to cast");
DECL_ON(const Type, t, = known_type(env, cast->td));
if (t->info->cdef && !tflag(t, tflag_check))
CHECK_BN(ensure_traverse(env, t));
- const Type to = known_type(env, cast->td->types->td);
+ const Type to = known_type(env, *mp_vector_at(cast->td->types, Type_Decl*, 0));
exp_setvar(cast->exp, 1);
if (isa(cast->exp->type, to) > 0) return t;
ERR_N(exp_self(cast)->pos, "invalid pointer cast");
base->info->value->from->owner_class,
base->info->value->from->owner);
const Type t = known_type(shred->info->vm->gwion->env,
- base->info->cdef->base.tmpl->call->td);
+ *mp_vector_at(base->info->cdef->base.tmpl->call, Type_Decl*, 0));
env_pop(shred->info->vm->gwion->env, scope);
struct_release(shred, t, *(m_bit **)o);
}
.base = ts->t, .td = ts->td, .list = ts->t->info->cdef->base.tmpl->list};
const Type exists = tmpl_exists(env, &info);
if (exists) return exists != env->gwion->type[et_error] ? exists : NULL;
- const Type base = known_type(env, ts->td->types->td);
+ const Type base = known_type(env, *mp_vector_at(ts->td->types, Type_Decl*, 0));
const Type t = new_type(env->gwion->mp, s_name(info.name), base);
t->size = SZ_INT;
t->info->parent = env->gwion->type[et_ptr];
.base = ts->t, .td = ts->td, .list = ts->t->info->cdef->base.tmpl->list};
const Type exists = tmpl_exists(env, &info);
if (exists) return exists != env->gwion->type[et_error] ? exists : NULL;
- const Type base = known_type(env, ts->td->types->td);
+ const Type base = known_type(env, *mp_vector_at(ts->td->types, Type_Decl*, 0));
const Type t = new_type(env->gwion->mp, s_name(info.name), base);
t->size = SZ_INT;
SET_FLAG(t, abstract | ae_flag_final);
const Type t_typed = gwi_class_ini(gwi, "TypedFork:[A]", "Fork");
gwi_item_ini(gwi, "A", "retval");
- GWI_BB((gwi_item_end(gwi, ae_flag_const, num, 0)))
+ GWI_BB(gwi_item_end(gwi, ae_flag_const, num, 0))
GWI_BB(gwi_class_end(gwi))
SET_FLAG(t_typed, abstract | ae_flag_final);
return GW_OK;
return sym;
}
-ANN static m_bool template_match(Specialized_List base, Type_List call) {
- while ((call = call->next) && (base = base->next))
- ;
- return !call ? GW_OK : GW_ERROR;
+ANN static m_bool template_match(Specialized_List sl, Type_List tl) {
+// uint32_t i = 0;
+// while ((call = call->next)) i++;
+//&& (base = base->next))
+// while ((call = call->next) && (base = base->next))
+// ;
+// return i = base->len ? GW_OK : GW_ERROR;
+// return !call ? GW_OK : GW_ERROR;
+ return tl->len >= sl->len;
}
ANN static Type _tmpl_exists(const Env env, const Symbol name) {
#else
int main(int argc, char **argv) {
- Arg arg = {.arg = {.argc = argc, .argv = argv}, .loop = false};
+ CliArg arg = {.arg = {.argc = argc, .argv = argv}, .loop = false};
signal(SIGINT, sig);
signal(SIGTERM, sig);
struct Gwion_ gwion = {};
ANN static m_bool check_decl(const Env env, const Exp_Decl *decl) {
Var_Decl_List list = decl->list;
- do {
- const Var_Decl var = list->self;
- CHECK_BB(check_var(env, var));
- CHECK_BB(check_var_td(env, var, decl->td));
- if (is_fptr(env->gwion, decl->type)) CHECK_BB(check_fptr_decl(env, var));
- valid_value(env, var->xid, var->value);
+ for(uint32_t i = 0; i < list->len; i++) {
+ const Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ CHECK_BB(check_var(env, vd));
+ CHECK_BB(check_var_td(env, vd, decl->td));
+ if (is_fptr(env->gwion, decl->type)) CHECK_BB(check_fptr_decl(env, vd));
+ valid_value(env, vd->xid, vd->value);
// set_vflag(var->value, vflag_used));
- } while ((list = list->next));
+ }
return GW_OK;
}
const m_bool ret = check_decl(env, decl);
if (global) env_pop(env, scope);
env_weight(env, 1 + isa(decl->type, env->gwion->type[et_object]) > 0);
- return ret > 0 ? decl->list->self->value->type : NULL;
+ return ret > 0 ? (mp_vector_at(decl->list, struct Var_Decl_, 0))->value->type : NULL;
}
ANN static m_bool check_collection(const Env env, Type type, const Exp e,
type : type_list_base_func(type);
}
-ANN static Type_List mk_type_list(const Env env, const Arg_List arg,
+ANN static Type_Decl* mk_td(const Env env, const Arg *arg,
const Type type, const loc_t pos) {
const Type base = type_list_base(env->gwion, type);
const Type t = !arg->td->array ?
base : array_type(env, base, arg->td->array->depth);
- Type_Decl *td = type2td(env->gwion, t, pos);
- return new_type_list(env->gwion->mp, td, NULL);
+ return type2td(env->gwion, t, pos);
}
ANN static inline bool func_match_inner(const Env env, const Exp e,
}
ANN2(1, 2)
-static Func find_func_match_actual(const Env env, Func func, const Exp args,
+static Func find_func_match_actual(const Env env, Func func, const Exp exp,
const bool implicit, const bool specific) {
do {
- Exp e = args;
- Arg_List e1 = func->def->base->args;
+ Exp e = exp;
+ Arg_List args = func->def->base->args;
+ m_uint i = 0;
+ const m_uint args_len = args ? args->len : 0;
while (e) {
e->cast_to = NULL;
if (!e->type) // investigate
return NULL;
- if (tflag(e->type, tflag_ref) && isa(e->type, e1->type) > 0) {
- if(!e->cast_to)e->cast_to = e1->type;
- }
- if (!e1) {
+// rewrite
+ Arg *arg = i < args_len ? mp_vector_at(args, Arg, i++) : NULL;
+ if (!arg) {
if (fbflag(func->def->base, fbflag_variadic)) return func;
CHECK_OO(func->next);
- return find_func_match_actual(env, func->next, args, implicit,
+ return find_func_match_actual(env, func->next, exp, implicit,
specific);
}
- if (e1->type == env->gwion->type[et_auto] ||
+ if (tflag(e->type, tflag_ref) && isa(e->type, arg->type) > 0) {
+ if(!e->cast_to)e->cast_to = arg->type;
+ }
+ if (arg->type == env->gwion->type[et_auto] ||
(func->def->base->tmpl &&
is_fptr(env->gwion, func->value_ref->type) > 0)) {
const Type owner = func->value_ref->from->owner_class;
if (owner) CHECK_BO(template_push(env, owner));
- e1->type = known_type(env, e1->td);
+ arg->type = known_type(env, arg->td);
if (owner) nspc_pop_type(env->gwion->mp, env->curr);
- CHECK_OO(e1->type);
+ CHECK_OO(arg->type);
}
- if (!func_match_inner(env, e, e1->type, implicit, specific)) break;
+ if (!func_match_inner(env, e, arg->type, implicit, specific)) break;
e = e->next;
- e1 = e1->next;
}
- if (!e1) return func;
-// if (!e && !e1) return func;
+ if (!e && args_len == i) return func;
} while ((func = func->next));
return NULL;
}
return ret;
}
-ANN static m_bool check_func_args(const Env env, Arg_List arg_list) {
- do {
- const Var_Decl decl = arg_list->var_decl;
+ANN static m_bool check_func_args(const Env env, Arg_List args) {
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ const Var_Decl decl = &arg->var_decl;
const Value v = decl->value;
CHECK_BB(already_defined(env, decl->xid, decl->pos));
valid_value(env, decl->xid, v);
- } while ((arg_list = arg_list->next));
+ }
return GW_OK;
}
if (next) gw_err(", "); \
return next; \
}
-next_arg(Exp) next_arg(Arg_List);
+next_arg(Exp)
+//next_arg(Arg_List);
ANN static void print_current_args(Exp e) {
gw_err(_("and not\n "));
gw_err("\n");
}
-ANN static void print_arg(Arg_List e) {
- do
- gw_err("{G}%s{0} {/}%s{0}", e->type ? e->type->name : NULL,
- e->var_decl->xid ? s_name(e->var_decl->xid) : "");
- while ((e = next_arg_Arg_List(e)));
+ANN static void print_arg(Arg_List args) {
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ gw_err("{G}%s{0} {/}%s{0}", arg->type ? arg->type->name : NULL,
+ arg->var_decl.xid ? s_name(arg->var_decl.xid) : "");
+ if(i < args->len - 1) gw_err(", ");
+ }
+// while ((e = next_arg_Arg_List(e)));
}
ANN2(1)
env_set_error(env);
}
-ANN static m_uint get_type_number(Specialized_List list) {
- m_uint type_number = 0;
- do ++type_number;
- while ((list = list->next));
- return type_number;
-}
-
ANN static Func get_template_func(const Env env, Exp_Call *const func,
const Value v) {
const Func f = find_template_match(env, v, func);
ANN static Type_List check_template_args(const Env env, Exp_Call *exp,
const Tmpl *tm, const Func_Def fdef) {
m_uint args_number = 0;
- const m_uint type_number = get_type_number(tm->list);
- Type_List tl[type_number];
- tl[0] = NULL;
- Specialized_List list = tm->list;
- while (list) {
- Arg_List arg = fdef->base->args;
+ const m_uint type_number = tm->list->len;
+ Type_List tl = new_mp_vector(env->gwion->mp, sizeof(Type_Decl*), type_number);
+ Specialized_List sl = tm->list;
+ for(uint32_t i = 0; i < sl->len; i++) {
+ Specialized *spec = mp_vector_at(sl, Specialized, i);
+ Arg_List args = fdef->base->args;
+ const uint32_t args_len = args ? args->len : 0;
Exp template_arg = exp->args;
- while (arg && template_arg) {
- if (list->xid == arg->td->xid) {
+ uint32_t count = 0;
+ while (count < args_len && template_arg) {
+ Arg *arg = mp_vector_at(args, Arg, count);
+ if (spec->xid == arg->td->xid) {
if (isa(template_arg->type, env->gwion->type[et_lambda]) > 0 &&
!template_arg->type->info->func)
break;
- tl[args_number] =
- mk_type_list(env, arg, template_arg->type, fdef->base->pos);
- if (args_number) tl[args_number - 1]->next = tl[args_number];
+ mp_vector_set(tl, Type_Decl*, args_number,
+ mk_td(env, arg, template_arg->type, fdef->base->pos));
++args_number;
break;
}
- arg = arg->next;
+ count++;
template_arg = template_arg->next;
}
- list = list->next;
}
if (args_number < type_number) // TODO: free type_list
ERR_O(exp->func->pos, _("not able to guess types for template call."))
- return tl[0];
+ return tl;
}
ANN static Type check_exp_call_template(const Env env, Exp_Call *exp) {
ANN static Type check_lambda_call(const Env env, const Exp_Call *exp) {
if (exp->args) CHECK_OO(check_exp(env, exp->args));
Exp_Lambda *l = &exp->func->d.exp_lambda;
- Arg_List arg = l->def->base->args;
+ Arg_List args = l->def->base->args;
Exp e = exp->args;
+ for(uint32_t i = 0; i < (args ? args->len : 0); i++) {
+ if(!e)
+ ERR_O(exp_self(exp)->pos, _("argument number does not match for lambda"))
+ Arg *arg = mp_vector_at(args, Arg, i);
+ arg->type = e->type;
+ if(is_class(env->gwion, arg->type))
+ type_addref(arg->type);
+ e = e->next;
+ }
+ if(e)
+ ERR_O(exp_self(exp)->pos, _("argument number does not match for lambda"))
+/*
while (arg && e) {
arg->type = e->type;
if(is_class(env->gwion, arg->type))
}
if (arg || e)
ERR_O(exp_self(exp)->pos, _("argument number does not match for lambda"))
+*/
l->def->base->values = env->curr->info->value;
const m_bool ret = traverse_func_def(env, l->def);
if (l->def->base->func) {
if (is_auto) {
assert(bin->rhs->type == bin->lhs->type);
// bin->rhs->type = bin->lhs->type;
- set_vflag(bin->rhs->d.exp_decl.list->self->value, vflag_assigned);
+ set_vflag((mp_vector_at(bin->rhs->d.exp_decl.list, struct Var_Decl_, 0))->value, vflag_assigned);
}
struct Op_Import opi = {.op = bin->op,
.lhs = bin->lhs->type,
exp_setuse(bin->rhs, 1);
const Type ret = op_check(env, &opi);
if (!ret && is_auto && exp_self(bin)->exp_type == ae_exp_binary)
- bin->rhs->d.exp_decl.list->self->value->type = env->gwion->type[et_auto];
+ (mp_vector_at(bin->rhs->d.exp_decl.list, struct Var_Decl_, 0))->value->type = env->gwion->type[et_auto];
return ret;
}
ANN m_bool check_type_def(const Env env, const Type_Def tdef) {
if (tdef->when) {
set_tflag(tdef->type, tflag_contract);
- const Var_Decl decl = new_var_decl(env->gwion->mp, insert_symbol("self"),
- NULL, tdef->when->pos);
- const Arg_List args = new_arg_list(
- env->gwion->mp, cpy_type_decl(env->gwion->mp, tdef->ext), decl, NULL);
+ struct Var_Decl_ decl = { .xid = insert_symbol("self"), .pos = tdef->when->pos };
+ Type_Decl *td = cpy_type_decl(env->gwion->mp, tdef->ext);
+ mp_vector_first(env->gwion->mp, args, Arg, ((Arg) { .td = td, .var_decl = decl }));
+// const Arg_List args = new_arg_list(
+// env->gwion->mp, cpy_type_decl(env->gwion->mp, tdef->ext), decl, NULL);
Func_Base *fb = new_func_base(
env->gwion->mp, type2td(env->gwion, tdef->type, tdef->pos),
insert_symbol("@implicit"), args, ae_flag_none, tdef->pos);
tdef->when->pos);
const Exp when = cpy_exp(env->gwion->mp, tdef->when);
when->next = helper;
- const Stmt stmt =
- new_stmt_exp(env->gwion->mp, ae_stmt_exp, when, when->pos);
- const Stmt_List body =
- new_stmt_list(env->gwion->mp, stmt, NULL); // ret_list);
+// const Stmt stmt =
+// new_stmt_exp(env->gwion->mp, ae_stmt_exp, when, when->pos);
+// const Stmt_List body =
+// new_stmt_list(env->gwion->mp, stmt, NULL); // ret_list);
+// Stmt_List body;
+ mp_vector_first(env->gwion->mp, body, struct Stmt_,
+ ((struct Stmt_) {
+ .stmt_type = ae_stmt_exp, .d = { .stmt_exp = { .val = when }},
+ .pos = when->pos
+ }));
const Stmt code = new_stmt_code(env->gwion->mp, body, when->pos);
const Func_Def fdef = new_func_def(env->gwion->mp, fb, code);
- CHECK_BB(traverse_func_def(env, fdef));
- const Exp predicate = stmt->d.stmt_exp.val;
- if (isa(predicate->type, env->gwion->type[et_bool]) < 0) {
- char explain[strlen(predicate->type->name) + 20];
- sprintf(explain, "found `{/+}%s{0}`", predicate->type->name);
+ if(traverse_func_def(env, fdef) < 0) {
+ free_mp_vector(env->gwion->mp, sizeof(struct Stmt_), body);
+ return GW_ERROR;
+ }
+ if (isa(when->type, env->gwion->type[et_bool]) < 0) {
+ free_mp_vector(env->gwion->mp, sizeof(struct Stmt_), body);
+ char explain[strlen(when->type->name) + 20];
+ sprintf(explain, "found `{/+}%s{0}`", when->type->name);
gwerr_basic("Invalid `{/+}when{0}` predicate expression type", explain,
"use `{/+}bool{0}`", env->name, when->pos, 0);
char from[strlen(tdef->type->name) + 39];
const Exp ret_id =
new_prim_id(env->gwion->mp, insert_symbol("self"), when->pos);
ret_id->d.prim.value = new_value(env->gwion->mp, tdef->type, "self");
- const Stmt ret =
- new_stmt_exp(env->gwion->mp, ae_stmt_return, ret_id, when->pos);
- const Stmt_List ret_list = new_stmt_list(env->gwion->mp, ret, NULL);
+ struct Stmt_ ret = {
+ .stmt_type = ae_stmt_return, .d = { .stmt_exp = { .val = ret_id }},
+ .pos = when->pos
+ };
+ mp_vector_add(env->gwion->mp, &fdef->d.code->d.stmt_code.stmt_list, struct Stmt_, ret);
ret_id->type = tdef->type;
- body->next = ret_list;
tdef->when_def = fdef;
}
return (!is_fptr(env->gwion, tdef->type) && tdef->type->info->cdef)
ANN m_bool check_enum_def(const Env env, const Enum_Def edef) {
const m_uint scope = env_push_type(env, edef->t);
ID_List list = edef->list;
- do decl_static(env, nspc_lookup_value0(env->curr, list->xid));
- while ((list = list->next));
+ for(uint32_t i = 0; i < list->len; i++) {
+ Symbol xid = *mp_vector_at(list, Symbol, i);
+ decl_static(env, nspc_lookup_value0(env->curr, xid));
+ }
env_pop(env, scope);
nspc_allocdata(env->gwion->mp, edef->t->nspc);
return GW_OK;
ERR_B(stmt->val->pos, _("Can't use type `{+G}%s{+G}` for return"),
ret_type->name);
if (stmt->val) {
+ Arg *arg = mp_vector_at(env->func->def->base->args, Arg, 0);
if (env->func->def->base->xid == insert_symbol("@implicit") &&
- ret_type == env->func->def->base->args->type)
+ ret_type == arg->type)
ERR_B(stmt_self(stmt)->pos,
_("can't use implicit casting while defining it"))
if (check_implicit(env, stmt->val, env->func->def->base->ret_type) > 0)
RET_NSPC(_check_stmt_case(env, stmt))}
ANN static m_bool case_loop(const Env env, const Stmt_Match stmt) {
- Stmt_List list = stmt->list;
- do CHECK_BB(check_stmt_case(env, &list->stmt->d.stmt_match));
- while ((list = list->next));
+ for(m_uint i = 0; i < stmt->list->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt s = (Stmt)(stmt->list->ptr + offset);
+ CHECK_BB(check_stmt_case(env, &s->d.stmt_match));
+ }
return GW_OK;
}
+ANN static inline m_bool check_handler(const restrict Env env,
+ const Handler *handler) {
+ RET_NSPC(check_stmt(env, handler->stmt));
+}
+
ANN static inline m_bool check_handler_list(const restrict Env env,
- const Handler_List handler) {
- if (handler->next) CHECK_BB(check_handler_list(env, handler->next));
- RET_NSPC(check_stmt(env, handler->stmt))
+ const Handler_List handlers) {
+ for(uint32_t i = 0; i < handlers->len; i++) {
+ Handler *handler = mp_vector_at(handlers, Handler, i);
+ CHECK_BB(check_handler(env, handler));
+ }
+ return GW_OK;
+}
+
+ANN static inline bool find_handler(const Handler_List handlers, const Symbol xid) {
+ for(uint32_t i = 0; i < handlers->len; i++) {
+ Handler *handler = mp_vector_at(handlers, Handler, i);
+ if(xid == handler->xid) return true;
+ }
+ return false;
}
ANN static inline m_bool check_stmt_try_start(const restrict Env env,
for (m_uint i = 0; i < m_vector_size(v); i++) {
struct ScopeEffect eff;
m_vector_get(v, i, &eff);
- Handler_List handler = stmt->handler;
- bool found = false;
- do { // check there is no duplicate handler
- if (eff.sym == handler->xid) {
- found = true;
- break;
- }
- } while ((handler = handler->next));
+ bool found = find_handler(stmt->handler, eff.sym);
if (!found) env_add_effect(env, eff.sym, eff.pos);
}
m_vector_release(v);
}
ANN static m_bool check_stmt_list(const Env env, Stmt_List l) {
- do CHECK_BB(check_stmt(env, l->stmt));
- while ((l = l->next));
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt s = (Stmt)(l->ptr + offset);
+ CHECK_BB(check_stmt(env, s));
+ }
return GW_OK;
}
if(fflag(func, fflag_valid))return GW_OK;
set_fflag(func, fflag_valid);
assert(func == fdef->base->func);
- if (env->class_def)
+ if (env->class_def && !strstr(func->name, "lambda:"))
CHECK_BB(check_parent_match(env, fdef));
if (tmpl_base(fdef->base->tmpl)) return GW_OK;
Value override = NULL;
ANN static m_bool check_extend_def(const Env env, const Extend_Def xdef) {
CHECK_BB(ensure_check(env, xdef->t));
CHECK_BB(extend_push(env, xdef->t));
- const m_bool ret = check_ast(env, xdef->body);
+ const m_bool ret = check_ast(env, &xdef->body);
extend_pop(env, xdef->t);
return ret;
}
ANN static m_bool _check_trait_def(const Env env, const Trait_Def pdef) {
const Trait trait = nspc_lookup_trait1(env->curr, pdef->xid);
Ast ast = pdef->body;
- while (ast) {
- Section *section = ast->section;
+// while (ast) {
+// Section *section = ast->section;
+ for(m_uint i = 0; i < ast->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ Section * section = (Section*)(ast->ptr + offset);
if (section->section_type == ae_section_stmt) {
- Stmt_List list = section->d.stmt_list;
- while (list) {
- const Stmt stmt = list->stmt;
+ Stmt_List l = section->d.stmt_list;
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt stmt = (Stmt)(l->ptr + offset);
+// Stmt_List list = section->d.stmt_list;
+// while (list) {
+// const Stmt stmt = list->stmt;
if (stmt->stmt_type == ae_stmt_exp) {
CHECK_BB(traverse_exp(env, stmt->d.stmt_exp.val));
Var_Decl_List list = stmt->d.stmt_exp.val->d.exp_decl.list;
- while (list) {
- const Value value = list->self->value;
+ for(uint32_t i = 0; i < list->len; i++) {
+ Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ const Value value = vd->value;
valuefrom(env, value->from,
- list->self->pos); // we do not need owner
+ vd->pos); // we do not need owner
if (!trait->requested_values.ptr)
vector_init(&trait->requested_values);
vector_add(&trait->requested_values, (m_uint)value);
- list = list->next;
}
}
- list = list->next;
+// list = list->next;
}
}
- ast = ast->next;
+// ast = ast->next;
}
return GW_OK;
}
bool err = false;
for (m_uint i = 0; i < vector_size(&cdef->base.type->nspc->vtable); ++i) {
const Func f = (Func)vector_at(&cdef->base.type->nspc->vtable, i);
- if (f && f->def->base && GET_FLAG(f->def->base, abstract)) {
+ if (f && f->def->base && GET_FLAG(f->def->base, abstract)) {
if (!err) {
err = true;
gwerr_basic(_("missing function definition"),
}
ANN static bool class_def_has_body(const Env env, Ast ast) {
- do {
- const Section *section = ast->section;
+// do {
+ for(m_uint i = 0; i < ast->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+// const Section *section = ast->section;
+ const Section *section = (Section*)(ast->ptr + offset);
if (section->section_type == ae_section_stmt) {
- Stmt_List list = section->d.stmt_list;
- do {
- const Stmt stmt = list->stmt;
+ Stmt_List l = section->d.stmt_list;
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt stmt = (Stmt)(l->ptr + offset);
if (stmt->stmt_type == ae_stmt_pp) continue;
if (stmt->stmt_type == ae_stmt_exp) {
const Exp exp = stmt->d.stmt_exp.val;
if (!exp) continue;
if (exp->exp_type != ae_exp_decl) return true;
if (GET_FLAG(exp->d.exp_decl.td, late)) continue;
- Var_Decl_List dlist = exp->d.exp_decl.list;
- do {
- if (GET_FLAG(dlist->self->value, late)) continue;
- if (isa(dlist->self->value->type, env->gwion->type[et_compound]) >
+ Var_Decl_List list = exp->d.exp_decl.list;
+ for(uint32_t i = 0; i < list->len; i++) {
+ Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ if (GET_FLAG(vd->value, late)) continue;
+ if (isa(vd->value->type, env->gwion->type[et_compound]) >
0)
- // if(tflag(dlist->self->value->type, tflag_ctor) ||
- // dlist->self->value->type->array_depth)
+ // if(tflag(vd->value->type, tflag_ctor) ||
+ // cd->value->type->array_depth)
return true;
- } while ((dlist = dlist->next));
+ }
} else
return true;
- } while ((list = list->next));
+ } //while ((list = list->next));
}
- } while ((ast = ast->next));
+ } //while ((ast = ast->next));
return false;
}
if (!GET_FLAG(cdef, abstract)) CHECK_BB(check_abstract(env, cdef));
if (cdef->traits) {
ID_List list = cdef->traits;
- bool value_error = false;
- do
- if (!check_trait_requests(env, t, list)) value_error = true;
- while ((list = list->next));
-
- if (value_error) {
+ if (!check_trait_requests(env, t, list)) {
env->class_def = t;
env_error_footer(env);
env_set_error(env);
vector_pop(v);
}
-ANN m_bool check_ast(const Env env, Ast ast) {
- do CHECK_BB(check_section(env, ast->section));
- while ((ast = ast->next));
+ANN m_bool check_ast(const Env env, Ast *ast) {
+ Ast a = *ast;
+ for(m_uint i = 0; i < a->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ Section * section = (Section*)(a->ptr + offset);
+ CHECK_BB(check_section(env, section));
+ }
check_unhandled(env);
return GW_OK;
}
const m_bool ret = traverse_func_def(env, cpy);
env_pop(env, scope);
if (ret > 0) {
- Section * section = new_section_func_def(env->gwion->mp, cpy);
- const Ast ast = new_ast(env->gwion->mp, section, NULL);
- Ast last = t->info->cdef->body;
- while (last->next) last = last->next;
- last->next = ast;
+ Section section = (Section) {
+ .section_type = ae_section_func,
+ .d = { .func_def = cpy }
+ };
+ // ensure body?
+ mp_vector_add(env->gwion->mp, &t->info->cdef->body, Section, section);
return true;
} else
free_func_def(env->gwion->mp, cpy);
}
return error;
}
-
+/*
ANN2(1, 2)
static inline bool trait_nodup(Type t, const Symbol trait, ID_List list) {
bool nodup = true;
do {
- while (list) {
- if (trait == list->xid) nodup = false;
- list = list->next;
+ for(uint32_t i = 0; i < list->len; i++) {
+ Symbol xid = *mp_vector_at(list, Symbol, i);
+ if (trait == xid) nodup = false;
}
} while ((t = t->info->parent));
return nodup;
}
+*/
+ANN bool trait_nodup(const ID_List list, const uint32_t i) {
+ Symbol fst = *mp_vector_at(list, Symbol, i);
+ for(uint32_t j = i; j < list->len; j++) {
+ Symbol snd = *mp_vector_at(list, Symbol, j);
+ if (fst == snd) return false;
+ }
+ return true;
+}
ANN bool check_trait_requests(const Env env, const Type t, const ID_List list) {
- const Trait trait = nspc_lookup_trait1(env->curr, list->xid);
- if (!trait_nodup(t, list->xid, list->next)) {
- gwerr_secondary("duplicated trait", trait->filename, trait->loc);
+ for(uint32_t i = 0; i < list->len; i++) {
+ Symbol xid = *mp_vector_at(list, Symbol, i);
+ const Trait trait = nspc_lookup_trait1(env->curr, xid);
+ if (!trait_nodup(list, i)) {
+ gwerr_secondary("duplicated trait", trait->filename, trait->loc);
+ env_set_error(env);
+ return false;
+ }
+ const bool value_error = trait->requested_values.ptr ? check_trait_variables(env, t, trait) : false;
+ const bool funcs_error = trait->requested_funcs.ptr ? check_trait_functions(env, t, trait) : false;
+ if (!value_error && !funcs_error) continue;
+ const Value request = (Value)vector_front(&trait->requested_values);
+ gwerr_secondary("from trait", request->from->filename, trait->loc);
env_set_error(env);
return false;
}
- const bool value_error = trait->requested_values.ptr ? check_trait_variables(env, t, trait) : false;
- const bool funcs_error = trait->requested_funcs.ptr ? check_trait_functions(env, t, trait) : false;
- if (!value_error && !funcs_error) return true;
- const Value request = (Value)vector_front(&trait->requested_values);
- gwerr_secondary("from trait", request->from->filename, trait->loc);
- env_set_error(env);
- return false;
+ return true;
}
ANN m_bool compat_func(const restrict Func_Def lhs,
const restrict Func_Def rhs) {
- Arg_List e1 = lhs->base->args;
- Arg_List e2 = rhs->base->args;
-
- while (e1 && e2) {
- if (e1->type != e2->type) return GW_ERROR;
- e1 = e1->next;
- e2 = e2->next;
+ Arg_List args0 = lhs->base->args;
+ Arg_List args1 = rhs->base->args;
+ if(!args0 && !args1)
+ return GW_OK;
+ if((!args0 && args1) || (args0 && !args1))
+ return GW_ERROR;
+ if(args0->len != args1->len)
+ return GW_ERROR;
+ for(uint32_t i = 0; i < args0->len; i++) {
+ Arg *arg0 = mp_vector_at(args0, Arg, i);
+ Arg *arg1 = mp_vector_at(args1, Arg, i);
+ if (arg0->type != arg1->type) return GW_ERROR;
}
- if (e1 || e2) return GW_ERROR;
return GW_OK;
}
fbflag(fdef->base, fbflag_unary) +
(!strcmp(str, "@conditional") || !strcmp(str, "@unconditional"));
const Arg_List args = fdef->base->args;
- opi->lhs = is_unary ? NULL : args ? args->var_decl->value->type : NULL;
+ Arg *arg0 = args ? mp_vector_at(args, Arg, 0) : NULL;
+ Arg *arg1 = (args && args->len >= 2) ? mp_vector_at(args, Arg, 1) : NULL;
+ opi->lhs = is_unary ? NULL : args ? arg0->var_decl.value->type : NULL;
if (strcmp(str, "@implicit"))
- opi->rhs = args ? is_unary ? args->var_decl->value->type
- : (args->next ? args->next->var_decl->value->type
- : NULL)
+// opi->rhs = args ? is_unary ? arg0->var_decl->value->type
+ opi->rhs = args ? is_unary ? (arg0 ? arg0->var_decl.value->type : NULL)
+ : (arg1 ? arg1->var_decl.value->type : NULL)
: NULL;
else
opi->rhs = fdef->base->ret_type;
// CHECK_BO(template_push_types(env, &tmpl));;
const bool ret = check_traverse_fdef(env, fdef) > 0;
// nspc_pop_type(env->gwion->mp, env->curr);
+ if(!ret)free_func_def(env->gwion->mp, fdef);
return ret;
}
fdef->base->tmpl->call = cpy_type_list(env->gwion->mp, ra->types);
fdef->base->tmpl->base = i;
const Func func = ensure_tmpl(env, fdef, ra->e);
- if (!func && !fdef->base->func) free_func_def(env->gwion->mp, fdef);
if (func && vflag(ra->v, vflag_builtin)) {
builtin_func(env->gwion->mp, func, (void*)ra->v->d.func_ref->code->native_func);
set_vflag(func->value_ref, vflag_builtin);
DECL_OO(const Func, f, = __find_template_match(env, v, exp));
Type_List tl = exp->tmpl->call;
Specialized_List sl = f->def->base->tmpl->list;
- while (tl) {
- DECL_OO(const Type, t, = known_type(env, tl->td));
- if (miss_traits(t, sl)) return NULL;
- tl = tl->next;
+ for(uint32_t i = 0; i < tl->len; i++) {
+ Type_Decl *td = *mp_vector_at(tl, Type_Decl*, i);
+ DECL_OO(const Type, t, = known_type(env, td));
+ if(t->info->traits) {
+ Specialized * spec = mp_vector_at(sl, Specialized, i);
+ if (miss_traits(t, spec)) return NULL;
+ }
}
return f;
}
} while (r && (r = op_parent(env, r)));
return NULL;
}
-
+/*
//! check if type matches for template operator
ANN bool _tmpl_match(const Env env, const Type t, Type_Decl *const td,
Specialized_List *slp) {
const Type base = known_type(env, td);
return base ? isa(t, base) > 0 : false;
}
+*/
+//! check if type matches for template operator
+ANN2(1,2,3) bool _tmpl_match(const Env env, const Type t, Type_Decl *const td,
+ Specialized *spec, uint32_t *idx) {
+ if (spec && !td->next && !td->types && td->xid == spec->xid) {
+ (*idx)++;
+ return true;
+ }
+ const Type base = known_type(env, td);
+ return base ? isa(t, base) > 0 : false;
+}
//! check Func_Base matches for template operator
-// usage of `is_class` is supicious rn
ANN bool tmpl_match(const Env env, const struct Op_Import *opi,
Func_Base *const base) {
Specialized_List sl = base->tmpl->list;
- const Arg_List arg = base->args;
+ const Arg_List args = base->args;
+ Arg *arg0 = mp_vector_at(args, Arg, 0);
+ Arg *arg1 = mp_vector_at(args, Arg, 1);
+ uint32_t idx = 0;
if (opi->lhs) {
- if (!_tmpl_match(env, opi->lhs, arg->td, &sl)) return false;
+ if (!_tmpl_match(env, opi->lhs, arg0->td, mp_vector_at(sl, Specialized, idx), &idx)) return false;
if (fbflag(base, fbflag_postfix)) return !!opi->rhs;
if (!fbflag(base, fbflag_unary)) {
if (!opi->rhs) return false;
- if (!_tmpl_match(env, opi->rhs, arg->next->td, &sl)) return false;
+ if (!_tmpl_match(env, opi->rhs, arg1->td, mp_vector_at(sl, Specialized, idx), &idx)) return false;
} else if (opi->rhs)
return false;
} else {
if (!fbflag(base, fbflag_unary) ||
- !_tmpl_match(env, opi->rhs, arg->td, &sl))
+ !_tmpl_match(env, opi->rhs, arg0->td, mp_vector_at(sl, Specialized, idx), &idx))
return false;
}
return true;
}
-//! make template operator Type_List
-ANN2(1, 2)
-static Type_List op_type_list(const Env env, const Type t, const Type_List next,
- const loc_t loc) {
- Type_Decl *const td0 = type2td(env->gwion, t, loc);
- return new_type_list(env->gwion->mp, td0, next);
-}
-
//! make template operator Func_def
ANN Type op_def(const Env env, struct Op_Import *const opi,
const Func_Def fdef) {
const Func_Def tmpl_fdef = cpy_func_def(env->gwion->mp, fdef);
tmpl_fdef->base->tmpl->base = 0;
+ tmpl_fdef->base->tmpl->call = new_mp_vector(env->gwion->mp,
+ sizeof(Type_Decl*), !!opi->lhs + !!opi->rhs);
if (opi->lhs) {
- Type_List next =
- opi->rhs ? op_type_list(env, opi->rhs, NULL, opi->pos) : NULL;
- tmpl_fdef->base->tmpl->call = op_type_list(env, opi->lhs, next, opi->pos);
+ mp_vector_set(tmpl_fdef->base->tmpl->call, Type_Decl*, 0, type2td(env->gwion, opi->lhs, opi->pos));
+ if(opi->rhs)
+ mp_vector_set(tmpl_fdef->base->tmpl->call, Type_Decl*, 1, type2td(env->gwion, opi->rhs, opi->pos));
} else
- tmpl_fdef->base->tmpl->call = op_type_list(env, opi->rhs, NULL, opi->pos);
+ mp_vector_set(tmpl_fdef->base->tmpl->call, Type_Decl*, 0, type2td(env->gwion, opi->rhs, opi->pos));
if (traverse_func_def(env, tmpl_fdef) < 0) {
if (!tmpl_fdef->base->func) func_def_cleaner(env->gwion, tmpl_fdef);
return NULL;
CHECK_BB(scan0_defined(env, udef->xid, udef->pos));
udef->type = union_type(env, udef->xid, udef->pos);
Union_List l = udef->l;
- do udef->type->nspc->offset += SZ_INT;
- while ((l = l->next));
+// do udef->type->nspc->offset += SZ_INT;
+// while ((l = l->next));
udef->type->nspc->offset += SZ_INT;
SET_ACCESS(udef, udef->type);
if (udef->tmpl) union_tmpl(env, udef);
}
ANN static m_bool find_traits(const Env env, ID_List traits, const loc_t pos) {
- do {
- if (!nspc_lookup_trait1(env->curr, traits->xid)) {
+ for(uint32_t i = 0; i < traits->len; i++) {
+ Symbol xid = *mp_vector_at(traits, Symbol, i);
+ if (!nspc_lookup_trait1(env->curr, xid)) {
gwerr_basic(_("can't find trait"), NULL, NULL, env->name, pos, 0);
- did_you_mean_trait(env->curr, s_name(traits->xid));
+ did_you_mean_trait(env->curr, s_name(xid));
env_set_error(env);
return GW_ERROR;
}
- } while ((traits = traits->next));
+ }
return GW_OK;
}
t->nspc->parent = env->curr;
t->info->cdef = cdef;
t->flag |= cdef->flag;
- // add_type(env, t->info->value->from->owner, t);
+ //add_type(env, t->info->value->from->owner, t);
cdef_flag(cdef, t);
return t;
}
-ANN static m_bool scan0_stmt_list(const Env env, Stmt_List list) {
- do
- if (list->stmt->stmt_type == ae_stmt_pp) {
- if (list->stmt->d.stmt_pp.pp_type == ae_pp_include)
- env->name = list->stmt->d.stmt_pp.data;
- else if (list->stmt->d.stmt_pp.pp_type == ae_pp_import)
- CHECK_BB(plugin_ini(env->gwion, list->stmt->d.stmt_pp.data));
+ANN static m_bool scan0_stmt_list(const Env env, Stmt_List l) {
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt stmt = (Stmt)(l->ptr + offset);
+ if (stmt->stmt_type == ae_stmt_pp) {
+ if (stmt->d.stmt_pp.pp_type == ae_pp_include)
+ env->name = stmt->d.stmt_pp.data;
+ else if (stmt->d.stmt_pp.pp_type == ae_pp_import)
+ CHECK_BB(plugin_ini(env->gwion, stmt->d.stmt_pp.data, stmt->pos));
}
- while ((list = list->next));
+ }
return GW_OK;
}
-//#define scan0_func_def dummy_func
-
-ANN static m_bool fdef_defaults(const Func_Def fdef) {
- Arg_List list = fdef->base->args;
- while (list) {
- if (list->exp) return true;
- list = list->next;
+ANN static Exp mk_default_args(const MemPool p, const Arg_List args, const uint32_t max) {
+ Exp exp = NULL, base_exp = NULL;
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ const Exp arg_exp = new_prim_id(p, arg->var_decl.xid, arg->var_decl.pos);
+ if(exp)
+ exp = (exp->next = arg_exp);
+ else
+ base_exp = exp = arg_exp;
}
- return false;
-}
-
-ANN static Exp arglist2exp(MemPool p, Arg_List arg, const Exp default_arg) {
- Exp exp = new_prim_id(p, arg->var_decl->xid, arg->var_decl->pos);
- if (arg->next)
- exp->next = arglist2exp(p, arg->next, default_arg);
- else
- exp->next = cpy_exp(p, default_arg);
- return exp;
-}
-
-ANN2(1,2) static Ast scan0_func_def_default(const MemPool p, const Ast ast,
- const Ast next) {
- const Func_Def base_fdef = ast->section->d.func_def;
- Arg_List base_arg = base_fdef->base->args, former = NULL;
- while (base_arg) {
- if (!base_arg->next && base_arg->exp) {
- if (former) former->next = NULL;
- // use cpy_func_base?
- Func_Base *base = new_func_base(
- p, base_fdef->base->td ? cpy_type_decl(p, base_fdef->base->td) : NULL, base_fdef->base->xid,
- former ? cpy_arg_list(p, base_fdef->base->args) : NULL,
- base_fdef->base->flag, base_fdef->base->pos);
- const Exp efunc =
- new_prim_id(p, base_fdef->base->xid, base_fdef->base->pos);
- Exp arg_exp = former
- ? arglist2exp(p, base_fdef->base->args, base_arg->exp)
- : cpy_exp(p, base_arg->exp);
- const Exp ecall = new_exp_call(p, efunc, arg_exp, base_fdef->base->pos);
- const Stmt code =
- new_stmt_exp(p, ae_stmt_return, ecall, base_fdef->base->pos);
- const Stmt_List slist = new_stmt_list(p, code, NULL);
- const Stmt body = new_stmt_code(p, slist, base_fdef->base->pos);
- const Func_Def fdef = new_func_def(p, base, body);
- Section * new_section = new_section_func_def(p, fdef);
- if (former) former->next = base_arg;
- const Ast tmp_ast = new_ast(p, new_section, NULL);
- ast->next = scan0_func_def_default(p, tmp_ast, next);
- return ast;
- }
- former = base_arg;
- base_arg = base_arg->next;
+ // now add default args
+ for(uint32_t i = args->len; i < max; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ const Exp arg_exp = cpy_exp(p, arg->exp);
+ if(exp)
+ exp = (exp->next = arg_exp);
+ else
+ base_exp = exp = arg_exp;
+ }
+ return base_exp;
+}
+
+ANN2(1) static void scan0_func_def_default(const MemPool p, const Section *s,
+ Ast *acc) {
+ const Func_Def base_fdef = s->d.func_def;
+ Arg_List args = base_fdef->base->args;
+ const uint32_t len = args->len;
+ while(args->len--) {
+ Arg *arg = mp_vector_at(args, Arg, args->len);
+ if(!arg->exp) break;
+ Func_Base *base = new_func_base(
+ p, base_fdef->base->td ? cpy_type_decl(p, base_fdef->base->td) : NULL, base_fdef->base->xid,
+ cpy_arg_list(p, args),
+ base_fdef->base->flag, base_fdef->base->pos);
+ const Exp efunc = new_prim_id(p, base->xid, base->pos);
+ const Exp exp_arg = mk_default_args(p, args, len);
+ const Exp ecall = new_exp_call(p, efunc, exp_arg, base->pos);
+ mp_vector_first(p, slist, struct Stmt_,
+ ((struct Stmt_) {
+ .stmt_type = ae_stmt_return, .d = { .stmt_exp = { .val = ecall }},
+ .pos = base_fdef->base->pos
+ }));
+ const Stmt body = new_stmt_code(p, slist, base->pos);
+ const Func_Def fdef = new_func_def(p, base, body);
+ Section section = MK_SECTION(func, func_def, fdef);
+ mp_vector_add(p, acc, Section, section);
}
- ast->next = next;
- return ast;
+ args->len = len;
}
#define scan0_func_def dummy_func
if (GET_FLAG(t, final)) // TODO: add type initial declaration
ERR_B(xdef->td->pos, _("can't extend final type"))
Ast ast = xdef->body;
- do {
- if (ast->section->section_type == ae_section_func &&
- GET_FLAG(ast->section->d.func_def->base, abstract))
- ERR_B(ast->section->d.func_def->base->pos,
+ for(m_uint i = 0; i < ast->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ Section * section = (Section*)(ast->ptr + offset);
+ if (section->section_type == ae_section_func &&
+ GET_FLAG(section->d.func_def->base, abstract))
+ ERR_B(section->d.func_def->base->pos,
_("can't use {/+}abstract{0} functions in {+/}extends{0}"))
- } while ((ast = ast->next));
+ }
xdef->t = t;
return GW_OK;
}
trait->filename = env->name;
nspc_add_trait(env->curr, pdef->xid, trait);
Ast ast = pdef->body;
- while (ast) {
- Section *section = ast->section;
+ if(!ast) return GW_OK; // ???
+ for(m_uint i = 0; i < ast->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ Section *section = (Section*)(ast->ptr + offset);
if (section->section_type == ae_section_func) {
const Func_Def fdef = section->d.func_def;
if (!trait->requested_funcs.ptr) vector_init(&trait->requested_funcs);
vector_add(&trait->requested_funcs, (m_uint)fdef);
}
- ast = ast->next;
}
return GW_OK;
}
return ret;
}
-ANN m_bool scan0_ast(const Env env, Ast ast) {
- Ast next;
- do {
- next = ast->next;
- CHECK_BB(scan0_section(env, ast->section));
- if (ast->section->section_type != ae_section_func ||
- !fdef_defaults(ast->section->d.func_def))
+ANN m_bool scan0_ast(const Env env, Ast *ast) {
+ Ast a = *ast;
+ Ast acc = new_mp_vector(env->gwion->mp, sizeof(Section), 0);
+ for(m_uint i = 0; i < a->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ Section * section = (Section*)(a->ptr + offset);
+ CHECK_BB(scan0_section(env, section));
+
+ if (section->section_type != ae_section_func ||
+ !fbflag(section->d.func_def->base, fbflag_default))
continue;
- (void)scan0_func_def_default(env->gwion->mp, ast, ast->next);
- } while ((ast = next));
+ scan0_func_def_default(env->gwion->mp, section, &acc);
+
+ }
+
+ for(m_uint i = 0; i < acc->len; i++) {
+ Section *section = (Section*)(acc->ptr + i * sizeof(Section));
+ mp_vector_add(env->gwion->mp, ast, Section, *section);
+ }
+ free_mp_vector(env->gwion->mp, sizeof(Section), acc);
+
return GW_OK;
}
}
ANN static m_bool scan1_decl(const Env env, const Exp_Decl *decl) {
- Var_Decl_List list = decl->list;
const bool decl_ref = array_ref(decl->td->array);
- do {
- const Var_Decl var = list->self;
- CHECK_BB(isres(env, var->xid, exp_self(decl)->pos));
+ Var_Decl_List list = decl->list;
+ for(uint32_t i = 0; i < list->len; i++) {
+ const Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ CHECK_BB(isres(env, vd->xid, exp_self(decl)->pos));
Type t = decl->type;
- CHECK_BB(scan1_defined(env, var));
- if (var->array) {
- if (var->array->exp) CHECK_BB(scan1_exp(env, var->array->exp));
- CHECK_OB((t = array_type(env, decl->type, var->array->depth)));
+ CHECK_BB(scan1_defined(env, vd));
+ if (vd->array) {
+ if (vd->array->exp) CHECK_BB(scan1_exp(env, vd->array->exp));
+ CHECK_OB((t = array_type(env, decl->type, vd->array->depth)));
}
const Type base = array_base_simple(t);
-
if ((!GET_FLAG(decl->td, late) && GET_FLAG(base, abstract)) &&
- (array_ref2(var->array) ||
+ (array_ref2(vd->array) ||
array_ref2(decl->td->array)))
- ERR_B(var->pos, _("arrays of abstract type '%s' must be declared empty"),
+ ERR_B(vd->pos, _("arrays of abstract type '%s' must be declared empty"),
base->name);
- const Value v = var->value =
- var->value ?: new_value(env->gwion->mp, t, s_name(var->xid));
- nspc_add_value(env->curr, var->xid, v);
+ const Value v = vd->value =
+ vd->value ?: new_value(env->gwion->mp, t, s_name(vd->xid));
+ nspc_add_value(env->curr, vd->xid, v);
if (GET_FLAG(t, abstract) && !GET_FLAG(decl->td, late)) SET_FLAG(v, late);
v->type = t;
- if (decl_ref || array_ref(var->array)) SET_FLAG(v, late);
+ if (decl_ref || array_ref(vd->array)) SET_FLAG(v, late);
v->flag |= decl->td->flag;
if (!env->scope->depth) {
- valuefrom(env, v->from, var->pos);
+ valuefrom(env, v->from, vd->pos);
if (env->class_def) {
if (env->class_def->info->tuple) tuple_contains(env, v);
if (!GET_FLAG(decl->td, static)) {
set_vflag(v, vflag_fglobal); // file global
} else if (GET_FLAG(decl->td, global))
SET_FLAG(v, global);
- else if(v->type != env->gwion->type[et_auto] && (v->type != env->class_def || env->scope->depth)) {
+// else if(v->type != env->gwion->type[et_auto] && (v->type != env->class_def || env->scope->depth)) {
+ else if(v->type != env->gwion->type[et_auto] && (v->type != env->class_def)) {
type_addref(v->type);
set_vflag(v, vflag_inner); // file global
}
- } while ((list = list->next));
- ((Exp_Decl *)decl)->type = decl->list->self->value->type;
+ }
+ ((Exp_Decl *)decl)->type = (mp_vector_at(decl->list, struct Var_Decl_, 0))->value->type;
return GW_OK;
}
ANN static inline m_bool
_scan1_stmt_match(const restrict Env env, const Stmt_Match stmt) {
if (stmt->where) CHECK_BB(scan1_stmt(env, stmt->where));
- Stmt_List list = stmt->list;
- do CHECK_BB(scan1_stmt_match_case(env, &list->stmt->d.stmt_match));
- while ((list = list->next));
+ Stmt_List l = stmt->list;
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt s = (Stmt)(l->ptr + offset);
+ CHECK_BB(scan1_stmt_match_case(env, &s->d.stmt_match));
+ }
return GW_OK;
}
RET_NSPC(_scan1_stmt_match(env, stmt))
}
+ANN static inline m_bool scan1_handler(const restrict Env env,
+ const Handler *handler) {
+ RET_NSPC(scan1_stmt(env, handler->stmt));
+}
+
ANN static inline m_bool scan1_handler_list(const restrict Env env,
- const Handler_List handler) {
- if (handler->next) CHECK_BB(scan1_handler_list(env, handler->next));
- RET_NSPC(scan1_stmt(env, handler->stmt))
+ const Handler_List handlers) {
+ for(uint32_t i = 0; i < handlers->len; i++) {
+ Handler * handler = mp_vector_at(handlers, Handler, i);
+ CHECK_BB(scan1_handler(env, handler));
+ }
+ return GW_OK;
}
ANN static inline m_bool scan1_stmt_try(const restrict Env env,
const Nspc nspc = edef->t->nspc;
const m_uint scope = env_push_type(env, edef->t);
ID_List list = edef->list;
- do {
- const Value v = new_value(env->gwion->mp, edef->t, s_name(list->xid));
+ for(uint32_t i = 0; i < list->len; i++) {
+ Symbol xid = *mp_vector_at(list, Symbol, i);
+ const Value v = new_value(env->gwion->mp, edef->t, s_name(xid));
valuefrom(env, v->from, edef->pos);
if (env->class_def) {
SET_FLAG(v, static);
set_vflag(v, vflag_builtin);
SET_FLAG(v, const);
set_vflag(v, vflag_valid);
- nspc_add_value(nspc, list->xid, v);
+ nspc_add_value(nspc, xid, v);
vector_add(&edef->values, (vtype)v);
- } while ((list = list->next));
+ }
env_pop(env, scope);
return GW_OK;
}
-ANN static Value arg_value(const Env env, const Arg_List list) {
- const Var_Decl var = list->var_decl;
- const Value v = new_value(env->gwion->mp, list->type,
- var->xid ? s_name(var->xid) : (m_str) __func__);
- if (var->array)
- v->type = list->type = array_type(env, list->type, var->array->depth);
- if (list->td) {
- v->flag = list->td->flag;
+ANN static Value arg_value(const Env env, Arg *const arg) {
+ const Var_Decl vd = &arg->var_decl;
+ const Value v = new_value(env->gwion->mp, arg->type,
+ vd->xid ? s_name(vd->xid) : (m_str) __func__);
+ if (vd->array)
+ v->type = arg->type = array_type(env, arg->type, vd->array->depth);
+ if (arg->td) {
+ v->flag = arg->td->flag;
// SET_FLAG(v, global); ???
}
return v;
}
-ANN static m_bool scan1_args(const Env env, Arg_List list) {
- do {
- const Var_Decl var = list->var_decl;
- if (var->xid) CHECK_BB(isres(env, var->xid, var->pos));
- if (list->td) {
- SET_FLAG(list->td, late);
- CHECK_OB((list->type = void_type(env, list->td)));
- UNSET_FLAG(list->td, late);
+ANN static m_bool scan1_args(const Env env, Arg_List args) {
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ const Var_Decl vd = &arg->var_decl;
+ if (vd->xid) CHECK_BB(isres(env, vd->xid, vd->pos));
+ if (arg->td) {
+ SET_FLAG(arg->td, late);
+ CHECK_OB((arg->type = void_type(env, arg->td)));
+ UNSET_FLAG(arg->td, late);
}
- var->value = arg_value(env, list);
- if (var->xid) nspc_add_value(env->curr, var->xid, var->value);
- } while ((list = list->next));
+ vd->value = arg_value(env, arg);
+ if (vd->xid) nspc_add_value(env->curr, vd->xid, vd->value);
+ }
return GW_OK;
}
}
ANN static m_bool _scan1_fbase_tmpl(const Env env, Func_Base *base) {
- Specialized_List id = base->tmpl->list;
- do nspc_add_type(env->curr, id->xid, env->gwion->type[et_auto]);
- while ((id = id->next));
+ Specialized_List sl = base->tmpl->list;
+ for(uint32_t i = 0; i < sl->len; i++) {
+ Specialized *spec = mp_vector_at(sl, Specialized, i);
+ nspc_add_type(env->curr, spec->xid, env->gwion->type[et_auto]);
+ }
CHECK_OB((base->ret_type = scan1_noret(env, base)));
if (base->args) {
- Arg_List arg = base->args;
- do CHECK_OB(known_type(env, arg->td));
- while ((arg = arg->next));
+ Arg_List args = base->args;
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ CHECK_OB(known_type(env, arg->td));
+ }
}
return GW_OK;
}
ANN static m_bool scan1_fdef_base_tmpl(const Env env, const Func_Def fdef) {
Func_Base *const base = fdef->base;
if (!fbflag(base, fbflag_op)) return scan1_fbase_tmpl(env, base);
- Arg_List arg = fdef->base->args;
- Specialized_List sl = fdef->base->tmpl->list;
- do {
- if (!arg->td->next && sl && arg->td->xid == sl->xid) { sl = sl->next; }
- } while ((arg = arg->next));
- if (sl) ERR_B(base->pos, "too many template types for operator");
+ Arg_List args = fdef->base->args;
+ Specialized_List sl = fdef->base->tmpl->list;
+ uint32_t j = 0;
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ Specialized *spec = mp_vector_at(sl, Specialized, j);
+ if (!arg->td->next && spec && arg->td->xid == spec->xid) { j++; }
+ }
+ if (j < sl->len) ERR_B(base->pos, "too many template types for operator");
const Vector v = &env->curr->info->op_tmpl;
if (!v->ptr) vector_init(v);
vector_add(v, (m_uint)cpy_func_def(env->gwion->mp, fdef));
const Value v = new_value(env->gwion->mp, env->gwion->type[et_int], "@index");
nspc_add_value_front(env->curr, insert_symbol("@index"), v);
valuefrom(env, v->from, udef->pos);
- do {
- DECL_OB(const Type, t, = known_type(env, l->td));
- if (nspc_lookup_value0(env->curr, l->xid))
- ERR_B(l->pos, _("'%s' already declared in union"), s_name(l->xid))
- const Value v = new_value(env->gwion->mp, t, s_name(l->xid));
-// if (!tflag(t, tflag_scan1)) // ???
- tuple_contains(env, v); // ???
-// v->from->offset = SZ_INT;
- v->from->offset = v->type->size;
+ for(uint32_t i = 0; i < l->len; i++) {
+ Union_Member *um = mp_vector_at(l, Union_Member, i);
+ DECL_OB(const Type, t, = known_type(env, um->td));
+ if (nspc_lookup_value0(env->curr, um->vd.xid))
+ ERR_B(um->vd.pos, _("'%s' already declared in union"), s_name(um->vd.xid))
+ const Value v = new_value(env->gwion->mp, t, s_name(um->vd.xid));
+ tuple_contains(env, v);
valuefrom(env, v->from, udef->pos);
- nspc_add_value_front(env->curr, l->xid, v);
+ nspc_add_value_front(env->curr, um->vd.xid, v);
if (t->size > sz) sz = t->size;
- } while ((l = l->next));
+ }
udef->type->nspc->offset = SZ_INT + sz;
return GW_OK;
}
}
ANN static m_bool scan1_stmt_list(const Env env, Stmt_List l) {
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt s = (Stmt)(l->ptr + offset);
+ CHECK_BB(scan1_stmt(env, s));
+ }
+/*
do {
CHECK_BB(scan1_stmt(env, l->stmt));
if (l->next) {
}
}
} while ((l = l->next));
+*/
return GW_OK;
}
ANN static inline m_bool scan_internal_arg(const Env env,
const Func_Base *base) {
- if (base->args && !base->args->next) return GW_OK;
+ if (base->args->len == 1) return GW_OK;
assert(base->td);
ERR_B(base->td->pos, _("'%s' must have one (and only one) argument"),
s_name(base->xid))
return GW_OK;
}
-ANN static m_bool scan1_fdef_args(const Env env, Arg_List list) {
- do CHECK_BB(shadow_arg(env, list->var_decl->xid, list->var_decl->pos));
- while ((list = list->next));
+ANN static m_bool scan1_fdef_args(const Env env, Arg_List args) {
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ CHECK_BB(shadow_arg(env, arg->var_decl.xid, arg->var_decl.pos));
+ }
return GW_OK;
}
ANN static m_bool scan1_extend_def(const Env env, const Extend_Def xdef) {
CHECK_BB(ensure_scan1(env, xdef->t));
CHECK_BB(extend_push(env, xdef->t));
- const m_bool ret = scan1_ast(env, xdef->body);
+ const m_bool ret = scan1_ast(env, &xdef->body);
extend_pop(env, xdef->t);
return ret;
}
return GW_OK;
}
-ANN m_bool scan1_ast(const Env env, Ast ast) {
- do CHECK_BB(scan1_section(env, ast->section));
- while ((ast = ast->next));
+ANN m_bool scan1_ast(const Env env, Ast *ast) {
+ Ast a = *ast;
+ for(m_uint i = 0; i < a->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ Section *section = (Section*)(a->ptr + offset);
+ CHECK_BB(scan1_section(env, section));
+ }
return GW_OK;
}
const Type t = decl->type;
CHECK_BB(ensure_scan2(env, t));
Var_Decl_List list = decl->list;
- do {
- const Var_Decl var = list->self;
- const Exp array = var->array ? var->array->exp : NULL;
+ for(uint32_t i = 0; i < list->len; i++) {
+ const Var_Decl vd = mp_vector_at(list, struct Var_Decl_, i);
+ const Exp array = vd->array ? vd->array->exp : NULL;
if (array) CHECK_BB(scan2_exp(env, array));
- nspc_add_value(env->curr, var->xid, var->value);
- } while ((list = list->next));
+ nspc_add_value(env->curr, vd->xid, vd->value);
+ }
return GW_OK;
}
return ret;
}
-ANN static m_bool scan2_args(const Func_Def f) {
- Arg_List list = f->base->args;
+ANN static m_bool scan2_args(const Env env, const Func_Def f) {
+ Arg_List args = f->base->args;
const bool global = GET_FLAG(f->base, global);
- do {
- const Value v = list->var_decl->value;
+ for(uint32_t i = 0; i < args->len; i++) {
+ Arg *arg = mp_vector_at(args, Arg, i);
+ const Value v = arg->var_decl.value;
v->from->offset = f->stack_depth;
f->stack_depth += v->type->size;
if (global) SET_FLAG(v, global);
- } while ((list = list->next));
+ }
return GW_OK;
}
ANN m_bool scan2_fptr_def(const Env env NUSED, const Fptr_Def fptr) {
if (!tmpl_base(fptr->base->tmpl)) {
const Func_Def def = fptr->type->info->func->def;
- if (def->base->args) { RET_NSPC(scan2_args(def)) }
+ if (def->base->args) { RET_NSPC(scan2_args(env, def)) }
} else
set_tflag(fptr->type, tflag_ftmpl);
return GW_OK;
ANN static m_bool multi_decl(const Env env, const Exp e, const Symbol op) {
if (e->exp_type == ae_exp_decl) {
- if (e->d.exp_decl.list->next)
+ if (e->d.exp_decl.list->len > 1)
ERR_B(e->pos, _("cant '%s' from/to a multi-variable declaration."),
s_name(op))
// set_vflag(e->d.exp_decl.list->self->value, vflag_used);
ANN static inline m_bool
_scan2_stmt_match(const restrict Env env, const Stmt_Match stmt) {
if (stmt->where) CHECK_BB(scan2_stmt(env, stmt->where));
- Stmt_List list = stmt->list;
- do CHECK_BB(scan2_stmt_match_case(env, &list->stmt->d.stmt_match));
- while ((list = list->next));
+ Stmt_List l = stmt->list;
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt s = (Stmt)(l->ptr + offset);
+ CHECK_BB(scan2_stmt_match_case(env, &s->d.stmt_match));
+ }
return GW_OK;
}
+ANN static inline m_bool scan2_handler(const restrict Env env,
+ const Handler *handler) {
+ RET_NSPC(scan2_stmt(env, handler->stmt));
+}
+
ANN static inline m_bool scan2_handler_list(const restrict Env env,
- const Handler_List handler) {
- if (handler->next) CHECK_BB(scan2_handler_list(env, handler->next));
- RET_NSPC(scan2_stmt(env, handler->stmt))
+ const Handler_List handlers) {
+ for(uint32_t i = 0; i < handlers->len; i++) {
+ Handler * handler = mp_vector_at(handlers, Handler, i);
+ CHECK_BB(scan2_handler(env, handler));
+ }
+ return GW_OK;
}
ANN static inline m_bool scan2_stmt_try(const restrict Env env,
return scan2_stmt_func[stmt->stmt_type](env, &stmt->d);
}
-ANN static m_bool scan2_stmt_list(const Env env, Stmt_List list) {
- do CHECK_BB(scan2_stmt(env, list->stmt));
- while ((list = list->next));
+ANN static m_bool scan2_stmt_list(const Env env, Stmt_List l) {
+ for(m_uint i = 0; i < l->len; i++) {
+ const m_uint offset = i * sizeof(struct Stmt_);
+ const Stmt s = (Stmt)(l->ptr + offset);
+ CHECK_BB(scan2_stmt(env, s));
+ }
return GW_OK;
}
func_symbol(env, env->curr->name, name, "template", ff->vt_index);
nspc_add_value(env->curr, sym, value);
if (!overload) {
- value_addref(value);
+// value_addref(value);
nspc_add_value(env->curr, f->base->xid, value);
+// nspc_add_func(env->curr, f->base->xid, func);
}
+ nspc_add_func(env->curr, sym, func);
func->vt_index = ff->vt_index;
return GW_OK;
}
--i;
const Symbol sym = func_symbol(env, env->curr->name, name, "template", i);
nspc_add_value(env->curr, sym, value);
+nspc_add_func(env->curr, sym, func);
if (!overload) {
- value_addref(value);
+// value_addref(value);
nspc_add_value(env->curr, f->base->xid, value);
- nspc_add_func(env->curr, f->base->xid, func);
+// nspc_add_func(env->curr, f->base->xid, func);
} else
func->vt_index = ++overload->from->offset;
return GW_OK;
ANN static m_str func_tmpl_name(const Env env, const Func_Def f) {
const m_str name = s_name(f->base->xid);
struct Vector_ v;
- Specialized_List id = f->base->tmpl->list;
+ Specialized_List sl = f->base->tmpl->list;
m_uint tlen = 0;
vector_init(&v);
- do {
- const Type t = nspc_lookup_type0(env->curr, id->xid);
+ for(uint32_t i = 0; i < sl->len; i++) {
+ Specialized * spec = mp_vector_at(sl, Specialized, i);
+ const Type t = nspc_lookup_type0(env->curr, spec->xid);
if (!t) return NULL;
vector_add(&v, (vtype)t);
tlen += strlen(t->name);
- } while ((id = id->next) && ++tlen);
+ ++tlen;
+ } //while ((id = id->next) && ++tlen);
char tmpl_name[tlen + 2];
m_str str = tmpl_name;
for (m_uint i = 0; i < vector_size(&v); ++i) {
CHECK_OB(func_create(env, f, overload, name));
else
f->base->func = base;
- if (f->base->args) CHECK_BB(scan2_args(f));
+ if (f->base->args) CHECK_BB(scan2_args(env, f));
if (!f->builtin && f->d.code) CHECK_BB(scan2_func_def_code(env, f));
if (!base) {
if (fbflag(f->base, fbflag_op)) CHECK_BB(scan2_func_def_op(env, f));
scan2_cpy_fdef(const Env env, const Func_Def fdef) {
const Func_Def f = cpy_func_def(env->gwion->mp, fdef);
f->base->ret_type = fdef->base->ret_type;
- Arg_List a = f->base->args, b = fdef->base->args;
- while (a) {
- a->var_decl->value = b->var_decl->value;
- a->type = b->type;
- a = a->next;
- b = b->next;
+ Arg_List args0 = f->base->args, args1 = fdef->base->args;
+ for(uint32_t i = 0; i < (args0 ? args0->len : 0); i++) {
+ Arg *arg0 = mp_vector_at(args0, Arg, i);
+ Arg *arg1 = mp_vector_at(args1, Arg, i);
+ arg0->var_decl.value = arg1->var_decl.value;
+ arg0->type = arg1->type;
}
scan1_func_def(env, f);
return f;
ANN static m_bool scan2_extend_def(const Env env, const Extend_Def xdef) {
CHECK_BB(ensure_scan2(env, xdef->t));
CHECK_BB(extend_push(env, xdef->t));
- const m_bool ret = scan2_ast(env, xdef->body);
+ const m_bool ret = scan2_ast(env, &xdef->body);
extend_pop(env, xdef->t);
return ret;
}
return GW_OK;
}
-ANN m_bool scan2_ast(const Env env, Ast ast) {
- do CHECK_BB(scan2_section(env, ast->section));
- while ((ast = ast->next));
+ANN m_bool scan2_ast(const Env env, Ast *ast) {
+ Ast a = *ast;
+ for(m_uint i = 0; i < a->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ Section *section = (Section*)(a->ptr + offset);
+ CHECK_BB(scan2_section(env, section));
+ }
return GW_OK;
}
#include "parse.h"
ANN static inline m_bool _body(const Env e, Ast b, const _exp_func f) {
- do CHECK_BB(f(e, b->section));
- while ((b = b->next));
+ for(m_uint i = 0; i < b->len; i++) {
+ const m_uint offset = i * sizeof(Section);
+ Section *section = (Section*)(b->ptr + offset);
+ CHECK_BB(f(e, section));
+ }
return GW_OK;
}
ANN static m_bool _push_types(const Env env, const Nspc nspc,
const Tmpl *tmpl) {
- Specialized_List list = tmpl->list;
- Type_List call = tmpl->call;
- do {
- if (!call) break;
- const Type t = call->td ? known_type(env, call->td) : NULL;
+ Specialized_List sl = tmpl->list;
+ Type_List tl = tmpl->call;
+ if(!tl) return GW_OK;
+ for(uint32_t i = 0; i < sl->len; i++) {
+ if (i >= tl->len) return GW_OK;
+ Type_Decl *td = *mp_vector_at(tl, Type_Decl*, i);
+// const Type t = td ? known_type(env, td) : NULL;
+ const Type t = known_type(env, td);
if (!t) return GW_OK;
- nspc_add_type(nspc, list->xid, t);
- call = call->next;
- } while ((list = list->next));
- return !call ? GW_OK : GW_ERROR;
+ Specialized *spec = mp_vector_at(sl, Specialized, i);
+ nspc_add_type(nspc, spec->xid, t);
+ };
+ return tl->len == sl->len ? GW_OK : GW_ERROR;
}
ANN static m_bool push_types(const Env env, const Nspc nspc, const Tmpl *tmpl) {
Type_List tl = td->types;
Specialized_List sl = t->info->cdef->base.tmpl
? t->info->cdef->base.tmpl->list : NULL;
-
- while (tl && sl) {
- DECL_OO(const Type, t, = known_type(env, tl->td));
- ID_List missing = miss_traits(t, sl);
- if (missing) {
- ERR_O(tl->td->pos, "does not implement requested trait '{/}%s{0}'",
- s_name(missing->xid));
+ for(uint32_t i = 0; i < tl->len; i++) {
+ Type_Decl *td = *mp_vector_at(tl, Type_Decl*, i);
+ DECL_OO(const Type, t, = known_type(env, td));
+ Specialized *spec = mp_vector_at(sl, Specialized, i);
+ if(spec->traits) {
+ Symbol missing = miss_traits(t, spec);
+ if (missing) {
+ ERR_O(td->pos, "does not implement requested trait '{/}%s{0}'",
+ s_name(missing));
+ }
}
- tl = tl->next;
- sl = sl->next;
}
struct Op_Import opi = {.op = insert_symbol("@scan"),
.lhs = t,
#include "gwion_env.h"
#include "traverse.h"
-ANN m_bool traverse_ast(const Env env, const Ast ast) {
+ANN m_bool traverse_ast(const Env env, const Ast *ast) {
CHECK_BB(scan0_ast(env, ast));
CHECK_BB(scan1_ast(env, ast));
CHECK_BB(scan2_ast(env, ast));
#include "parse.h"
ANN static Type _option(const Env env, Type_Decl *td, const uint8_t n) {
- struct Type_List_ tl = {.td = td};
+ Type_List tl = new_mp_vector(env->gwion->mp, sizeof(Type_Decl*), 1);
+ mp_vector_set(tl, Type_Decl*, 0, td);
Type_Decl tmp = {
- .xid = insert_symbol("Option"), .types = &tl, .pos = td->pos};
- return !(n - 1) ? known_type(env, &tmp) : _option(env, &tmp, n - 1);
+ .xid = insert_symbol("Option"), .types = tl, .pos = td->pos};
+ const Type t = !(n - 1) ? known_type(env, &tmp) : _option(env, &tmp, n - 1);
+ free_mp_vector(env->gwion->mp, sizeof(Type_Decl*), tl);
+ return t;
}
ANN static Type option(const Env env, Type_Decl *td) {
}
ANN static Type _ref(const Env env, Type_Decl *td) {
- struct Type_List_ tl = {.td = td};
- Type_Decl tmp = {.xid = insert_symbol("Ref"), .types = &tl, .pos = td->pos};
- return known_type(env, &tmp);
+ Type_List tl = new_mp_vector(env->gwion->mp, sizeof(Type_Decl*), 1);
+ mp_vector_set(tl, Type_Decl*, 0, td);
+ Type_Decl tmp = {.xid = insert_symbol("Ref"), .types = tl, .pos = td->pos};
+ const Type t = known_type(env, &tmp);
+ free_mp_vector(env->gwion->mp, sizeof(Type_Decl*), tl);
+ return t;
}
ANN static inline Type ref(const Env env, Type_Decl *td) {
const compilation_pass pass =
(compilation_pass)map_get(&gwion->data->passes->map, (vtype)sym);
if (!pass) {
+/*
+if(!strcmp(name, "none")) {
+ vector_clear(v);
+ return GW_OK;
+}
+*/
gw_err("Failed to set compilation passes, back to default\n");
pass_default(gwion);
return GW_ERROR;
}
}
-ANN static m_bool dependencies(struct Gwion_ *gwion, const Plug plug) {
+ANN static m_bool dependencies(struct Gwion_ *gwion, const Plug plug, const loc_t loc) {
const gwdeps dep = DLSYM(plug->dl, gwdeps, GWDEPEND_NAME);
if (dep) {
m_str *const base = dep();
m_str * deps = base;
while (*deps) {
- CHECK_BB(plugin_ini(gwion, *deps));
+ CHECK_BB(plugin_ini(gwion, *deps, loc));
++deps;
}
}
return GW_OK;
}
-ANN static m_bool _plugin_ini(struct Gwion_ *gwion, const m_str iname) {
+ANN static m_bool _plugin_ini(struct Gwion_ *gwion, const m_str iname, const loc_t loc) {
const Map map = &gwion->data->plug;
for (m_uint i = 0; i < map_size(map); ++i) {
const Plug plug = (Plug)VVAL(map, i);
plug->imp = 1;
const bool cdoc = gwion->data->cdoc;
gwion->data->cdoc = 0;
- CHECK_BB(dependencies(gwion, plug));
+ CHECK_BB(dependencies(gwion, plug, loc));
gwion->data->cdoc = cdoc;
const m_uint scope = env_push_global(gwion->env);
const m_str name = gwion->env->name;
return ret;
}
}
- gw_err("no such plugin '%s'\n", iname);
return GW_ERROR;
}
-ANN m_bool plugin_ini(struct Gwion_ *gwion, const m_str iname) {
- const Context ctx = gwion->env->context;
+ANN m_bool plugin_ini(struct Gwion_ *gwion, const m_str iname, const loc_t loc) {
+ const Env env = gwion->env;
+ const Context ctx = env->context;
gwion->env->context = NULL;
- const m_bool ret = _plugin_ini(gwion, iname);
+ const m_bool ret = _plugin_ini(gwion, iname, loc);
gwion->env->context = ctx;
- return ret;
+ if(ret > 0) return GW_OK;
+ env_err(env, loc, "no such plugin\n");
+ return GW_ERROR;
}
ANN m_bool driver_ini(const struct Gwion_ *gwion) {
reg += SZ_INT;
DISPATCH()
regpushmemderef:
- memcpy(reg, *(m_uint **)(mem + IVAL), VAL2);
+ memcpy(reg, *(m_bit **)(mem + IVAL), VAL2);
reg += VAL2;
DISPATCH()
pushnow:
DISPATCH()
autoloop: {
const M_Vector array = ARRAY(*(M_Object *)(mem + VAL2 - SZ_INT));
- *(m_bit **)(mem + VAL2 + SZ_INT) =
- m_vector_addr(array, ++*(m_uint *)(mem + VAL2));
- BRANCH_DISPATCH(m_vector_size(array) == *(m_uint *)(mem + VAL2));
+ const bool end = ++*(m_uint *)(mem + VAL2) == m_vector_size(array);
+ if(!end) {
+ *(m_bit **)(mem + VAL2 + SZ_INT) =
+ m_vector_addr(array, *(m_uint *)(mem + VAL2));
+ }
+ BRANCH_DISPATCH(end);
}
arraytop:
if (*(m_uint *)(reg - SZ_INT * 2) < *(m_uint *)(reg - SZ_INT))
DISPATCH()
gackend : {
m_str str = *(m_str *)(reg - SZ_INT);
- if (!VAL)
+ if (!VAL) {
gw_out("%s\n", str);
+fflush(stdout);
+}
else
*(M_Object *)(reg - SZ_INT) = new_string(vm->gwion, str);
if (str) mp_free2(vm->gwion->mp, strlen(str), str);
+++ /dev/null
-#! [contains] invalid format for expression
-1,(2,3);
+#! [contains] can't assign to pointer
class C {}
class D extends C {}
+++ /dev/null
-class C {
- funptr static void func_t:[A](A a);
- fun static void myfunc:[A](A a) { <<< a >>>; }
- myfunc @=> var static func_t ptr;
- ptr(1);
-}
-
-var C c;
+++ /dev/null
-class C:[A] {
- funptr static void func_t:[A](A a);
- fun static void myfunc:[A](A a) { <<< a >>>; }
- myfunc @=> var static func_t ptr;
- ptr(1);
-}
-
-var C:[int] c;
#include "import.h"
#include "gwi.h"
-ANN static m_bool pass(Env nv NUSED, Ast ast NUSED) { return GW_OK; }
+ANN static m_bool pass(Env nv NUSED, Ast *ast NUSED) { return GW_OK; }
GWION_IMPORT(array_test) {
gwi_register_pass(gwi, "dummy", pass);
-Subproject commit 186bade285100f2da04033429640b95d2f72cb2f
+Subproject commit 620ab68b3234178145f080e370b9ff5c0cede772
projects / gwion.git / commitdiff