delay tagging
This commit is contained in:
parent
c62369c0c5
commit
d8b2ac0268
@ -35,11 +35,11 @@ B fork_c2(B t, B w, B x);
|
||||
B md2H_c1(B d, B x);
|
||||
B md2H_c2(B d, B w, B x);
|
||||
// consume all args
|
||||
static B m_md1D(B m, B f ) { B r = mm_alloc(sizeof(Md1D), t_md1D, ftag(FUN_TAG)); c(Md1D,r)->f = f; c(Md1D,r)->m1 = m; c(Md1D,r)->c1=md1D_c1; c(Md1D,r)->c2=md1D_c2; return r; }
|
||||
static B m_md2D(B m, B f, B g) { B r = mm_alloc(sizeof(Md2D), t_md2D, ftag(FUN_TAG)); c(Md2D,r)->f = f; c(Md2D,r)->m2 = m; c(Md2D,r)->g = g; c(Md2D,r)->c1=md2D_c1; c(Md2D,r)->c2=md2D_c2; return r; }
|
||||
static B m_md2H(B m, B g) { B r = mm_alloc(sizeof(Md2H), t_md2H, ftag(MD1_TAG)); c(Md2H,r)->m2 = m; c(Md2H,r)->g = g; c(Md2H,r)->c1=md2H_c1; c(Md2H,r)->c2=md2H_c2; return r; }
|
||||
static B m_fork(B f, B g, B h) { B r = mm_alloc(sizeof(Fork), t_fork, ftag(FUN_TAG)); c(Fork,r)->f = f; c(Fork,r)->g = g; c(Fork,r)->h = h; c(Fork,r)->c1=fork_c1; c(Fork,r)->c2=fork_c2; return r; }
|
||||
static B m_atop( B g, B h) { B r = mm_alloc(sizeof(Atop), t_atop, ftag(FUN_TAG)); c(Atop,r)->g = g; c(Atop,r)->h = h; c(Atop,r)->c1=tr2D_c1; c(Atop,r)->c2=tr2D_c2; return r; }
|
||||
static B m_md1D(B m, B f ) { Md1D* r = mm_allocN(sizeof(Md1D), t_md1D); r->f = f; r->m1 = m; r->c1=md1D_c1; r->c2=md1D_c2; return tag(r,FUN_TAG); }
|
||||
static B m_md2D(B m, B f, B g) { Md2D* r = mm_allocN(sizeof(Md2D), t_md2D); r->f = f; r->m2 = m; r->g = g; r->c1=md2D_c1; r->c2=md2D_c2; return tag(r,FUN_TAG); }
|
||||
static B m_md2H(B m, B g) { Md2H* r = mm_allocN(sizeof(Md2H), t_md2H); r->m2 = m; r->g = g; r->c1=md2H_c1; r->c2=md2H_c2; return tag(r,MD1_TAG); }
|
||||
static B m_fork(B f, B g, B h) { Fork* r = mm_allocN(sizeof(Fork), t_fork); r->f = f; r->g = g; r->h = h; r->c1=fork_c1; r->c2=fork_c2; return tag(r,FUN_TAG); }
|
||||
static B m_atop( B g, B h) { Atop* r = mm_allocN(sizeof(Atop), t_atop); r->g = g; r->h = h; r->c1=tr2D_c1; r->c2=tr2D_c2; return tag(r,FUN_TAG); }
|
||||
|
||||
// consume all args
|
||||
static B m1_d(B m, B f ) { if(isMd1(m)) return TI(m).m1_d(m, f ); thrM("Interpreting non-1-modifier as 1-modifier"); }
|
||||
|
||||
@ -140,10 +140,10 @@ INS B i_FLDO(B ns, u32 p, Scope* sc) {
|
||||
return r;
|
||||
}
|
||||
INS B i_NSPM(B o, u32 l) {
|
||||
B a = mm_alloc(sizeof(FldAlias), t_fldAlias, ftag(OBJ_TAG));
|
||||
c(FldAlias,a)->obj = o;
|
||||
c(FldAlias,a)->p = l;
|
||||
return a;
|
||||
FldAlias* a = mm_allocN(sizeof(FldAlias), t_fldAlias);
|
||||
a->obj = o;
|
||||
a->p = l;
|
||||
return tag(a,OBJ_TAG);
|
||||
}
|
||||
INS B i_CHKV(B x, u32* bc, B* cStack) {
|
||||
if(isNothing(x)) { POS_UPD; GS_UPD; thrM("Unexpected Nothing (·)"); }
|
||||
|
||||
18
src/load.c
18
src/load.c
@ -384,25 +384,25 @@ static inline void base_init() { // very first init function
|
||||
ti[t_funBI].free = ti[t_md1BI].free = ti[t_md2BI].free = builtin_free;
|
||||
assert((MD1_TAG>>1) == (MD2_TAG>>1)); // just to be sure it isn't changed incorrectly, `isMd` depends on this
|
||||
|
||||
#define FA(N,X) { B t=bi_##N = mm_alloc(sizeof(BFn), t_funBI, ftag(FUN_TAG)); BFn*f=c(BFn,t); f->c2=N##_c2 ; f->c1=N##_c1 ; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(t); }
|
||||
#define FM(N,X) { B t=bi_##N = mm_alloc(sizeof(BFn), t_funBI, ftag(FUN_TAG)); BFn*f=c(BFn,t); f->c2=c2_invalid; f->c1=N##_c1 ; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(t); }
|
||||
#define FD(N,X) { B t=bi_##N = mm_alloc(sizeof(BFn), t_funBI, ftag(FUN_TAG)); BFn*f=c(BFn,t); f->c2=N##_c2 ; f->c1=c1_invalid; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(t); }
|
||||
#define FA(N,X) { BFn* f = mm_allocN(sizeof(BFn), t_funBI); f->c2=N##_c2 ; f->c1=N##_c1 ; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
#define FM(N,X) { BFn* f = mm_allocN(sizeof(BFn), t_funBI); f->c2=c2_invalid; f->c1=N##_c1 ; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
#define FD(N,X) { BFn* f = mm_allocN(sizeof(BFn), t_funBI); f->c2=N##_c2 ; f->c1=c1_invalid; f->extra=pf_##N; f->ident=bi_N; f->uc1=def_fn_uc1; f->ucw=def_fn_ucw; gc_add(bi_##N = tag(f,FUN_TAG)); }
|
||||
FOR_PFN(FA,FM,FD)
|
||||
#undef FA
|
||||
#undef FM
|
||||
#undef FD
|
||||
|
||||
#define FA(N,X) { B t = bi_##N = mm_alloc(sizeof(Md1), t_md1BI, ftag(MD1_TAG)); c(Md1,t)->c2 = N##_c2 ; c(Md1,t)->c1 = N##_c1 ; c(Md1,t)->extra=pm1_##N; gc_add(t); }
|
||||
#define FM(N,X) { B t = bi_##N = mm_alloc(sizeof(Md1), t_md1BI, ftag(MD1_TAG)); c(Md1,t)->c2 = c2_invalid; c(Md1,t)->c1 = N##_c1 ; c(Md1,t)->extra=pm1_##N; gc_add(t); }
|
||||
#define FD(N,X) { B t = bi_##N = mm_alloc(sizeof(Md1), t_md1BI, ftag(MD1_TAG)); c(Md1,t)->c2 = N##_c2 ; c(Md1,t)->c1 = c1_invalid; c(Md1,t)->extra=pm1_##N; gc_add(t); }
|
||||
#define FA(N,X) { Md1* m = mm_allocN(sizeof(Md1), t_md1BI); m->c2 = N##_c2 ; m->c1 = N##_c1 ; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
#define FM(N,X) { Md1* m = mm_allocN(sizeof(Md1), t_md1BI); m->c2 = c2_invalid; m->c1 = N##_c1 ; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
#define FD(N,X) { Md1* m = mm_allocN(sizeof(Md1), t_md1BI); m->c2 = N##_c2 ; m->c1 = c1_invalid; m->extra=pm1_##N; gc_add(bi_##N = tag(m,MD1_TAG)); }
|
||||
FOR_PM1(FA,FM,FD)
|
||||
#undef FA
|
||||
#undef FM
|
||||
#undef FD
|
||||
|
||||
#define FA(N,X) { B t=bi_##N=mm_alloc(sizeof(BMd2), t_md2BI, ftag(MD2_TAG)); BMd2*m=c(BMd2,t); m->c2 = N##_c2 ; m->c1 = N##_c1; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(t); }
|
||||
#define FM(N,X) { B t=bi_##N=mm_alloc(sizeof(BMd2), t_md2BI, ftag(MD2_TAG)); BMd2*m=c(BMd2,t); m->c2 = N##_c2 ; m->c1 = c1_invalid; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(t); }
|
||||
#define FD(N,X) { B t=bi_##N=mm_alloc(sizeof(BMd2), t_md2BI, ftag(MD2_TAG)); BMd2*m=c(BMd2,t); m->c2 = c2_invalid; m->c1 = N##_c1; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(t); }
|
||||
#define FA(N,X) { BMd2* m = mm_allocN(sizeof(BMd2), t_md2BI); m->c2 = N##_c2 ; m->c1 = N##_c1; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
#define FM(N,X) { BMd2* m = mm_allocN(sizeof(BMd2), t_md2BI); m->c2 = N##_c2 ; m->c1 = c1_invalid; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
#define FD(N,X) { BMd2* m = mm_allocN(sizeof(BMd2), t_md2BI); m->c2 = c2_invalid; m->c1 = N##_c1; m->extra=pm2_##N; m->uc1=def_m2_uc1; m->ucw=def_m2_ucw; gc_add(bi_##N = tag(m,MD2_TAG)); }
|
||||
FOR_PM2(FA,FM,FD)
|
||||
#undef FA
|
||||
#undef FM
|
||||
|
||||
27
src/ns.c
27
src/ns.c
@ -10,32 +10,31 @@ void m_nsDesc(Body* body, bool imm, u8 ty, B nameList, B varIDs, B exported) { /
|
||||
i32 vam = ia+off;
|
||||
if (vam != body->varAm) thrM("Bad namespace description information");
|
||||
|
||||
NSDesc* rc = c(NSDesc, mm_alloc(fsizeof(NSDesc, expIDs, i32, vam), t_nsDesc, ftag(OBJ_TAG)));
|
||||
rc->nameList = nameList;
|
||||
rc->varAm = vam;
|
||||
NSDesc* r = mm_allocN(fsizeof(NSDesc, expIDs, i32, vam), t_nsDesc);
|
||||
r->nameList = nameList;
|
||||
r->varAm = vam;
|
||||
BS2B getIDU = TI(varIDs).getU;
|
||||
BS2B getOnU = TI(exported).getU;
|
||||
for (i32 i = 0; i < off; i++) {
|
||||
body->varIDs[i] = -1;
|
||||
rc ->expIDs[i] = -1;
|
||||
r ->expIDs[i] = -1;
|
||||
}
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
i32 cid = o2i(getIDU(varIDs, i));
|
||||
bool cexp = o2b(getOnU(exported, i));
|
||||
body->varIDs[i+off] = cid;
|
||||
rc->expIDs[i+off] = cexp? cid : -1;
|
||||
r->expIDs[i+off] = cexp? cid : -1;
|
||||
}
|
||||
// printf("def %p:\n", rc);
|
||||
// for (usz i = 0; i < vam; i++) printf(" %d: %d %d\n", i, body->varIDs[i], rc->expIDs[i]);
|
||||
body->nsDesc = rc;
|
||||
// printf("def %p:\n", r);
|
||||
// for (usz i = 0; i < vam; i++) printf(" %d: %d %d\n", i, body->varIDs[i], r->expIDs[i]);
|
||||
body->nsDesc = r;
|
||||
}
|
||||
B m_ns(Scope* sc, NSDesc* desc) { // consumes both
|
||||
B r = mm_alloc(sizeof(NS), t_ns, ftag(NSP_TAG));
|
||||
NS* rc = c(NS,r);
|
||||
rc->desc = desc;
|
||||
rc->nameList = rc->desc->nameList;
|
||||
rc->sc = sc;
|
||||
return r;
|
||||
NS* r = mm_allocN(sizeof(NS), t_ns);
|
||||
r->desc = desc;
|
||||
r->nameList = r->desc->nameList;
|
||||
r->sc = sc;
|
||||
return tag(r, NSP_TAG);
|
||||
}
|
||||
|
||||
B ns_getU(B ns, B cNL, i32 nameID) { VTY(ns, t_ns);
|
||||
|
||||
66
src/rtwrap.c
66
src/rtwrap.c
@ -153,49 +153,47 @@ B rtWrap_wrap(B t) {
|
||||
#ifdef RT_VERIFY
|
||||
if(v(t)->flags==0) return t;
|
||||
#endif
|
||||
B r = mm_alloc(sizeof(WFun), t_funWrap, ftag(FUN_TAG));
|
||||
c(Value,r)->extra = v(t)->extra;
|
||||
c(Value,r)->flags = v(t)->flags;
|
||||
c(Fun,r)->c1 = wf_c1;
|
||||
c(Fun,r)->c2 = wf_c2;
|
||||
c(WFun,r)->v = t;
|
||||
c(WFun,r)->prev = lastWF;
|
||||
lastWF = c(WFun,r);
|
||||
WFun* r = mm_allocN(sizeof(WFun), t_funWrap);
|
||||
r->extra = v(t)->extra;
|
||||
r->flags = v(t)->flags;
|
||||
r->c1 = wf_c1;
|
||||
r->c2 = wf_c2;
|
||||
r->v = t;
|
||||
r->prev = lastWF;
|
||||
lastWF = r;
|
||||
#ifdef RT_VERIFY
|
||||
c(WFun,r)->r1 = r1Objs[v(t)->flags-1];
|
||||
r->r1 = r1Objs[v(t)->flags-1];
|
||||
#else
|
||||
c(WFun,r)->c1t = 0; c(WFun,r)->c1a = 0;
|
||||
c(WFun,r)->c2t = 0; c(WFun,r)->c2a = 0;
|
||||
r->c1t = 0; r->c1a = 0;
|
||||
r->c2t = 0; r->c2a = 0;
|
||||
#endif
|
||||
return r;
|
||||
return tag(r, FUN_TAG);
|
||||
}
|
||||
#ifdef RT_PERF
|
||||
if (isMd1(t)) {
|
||||
B r = mm_alloc(sizeof(WMd1), t_md1Wrap, ftag(MD1_TAG));
|
||||
c(Value,r)->extra = v(t)->extra;
|
||||
c(Value,r)->flags = v(t)->flags;
|
||||
c(Md1,r)->c1 = wm1_c1;
|
||||
c(Md1,r)->c2 = wm1_c2;
|
||||
c(WMd1,r)->v = t;
|
||||
c(WMd1,r)->prev = lastWM1;
|
||||
c(WMd1,r)->c1t = 0; c(WMd1,r)->c1a = 0;
|
||||
c(WMd1,r)->c2t = 0; c(WMd1,r)->c2a = 0;
|
||||
lastWM1 = c(WMd1,r);
|
||||
return r;
|
||||
WMd1* r = mm_allocN(sizeof(WMd1), t_md1Wrap);
|
||||
r->extra = v(t)->extra;
|
||||
r->flags = v(t)->flags;
|
||||
r->c1 = wm1_c1;
|
||||
r->c2 = wm1_c2;
|
||||
r->v = t;
|
||||
r->prev = lastWM1;
|
||||
lastWM1 = r;
|
||||
r->c1a = 0; r->c2a = 0;
|
||||
return tag(r, MD1_TAG);
|
||||
}
|
||||
if (isMd2(t)) {
|
||||
Md2* fc = c(Md2,t);
|
||||
B r = mm_alloc(sizeof(WMd2), t_md2Wrap, ftag(MD2_TAG));
|
||||
c(Md2,r)->c1 = wm2_c1;
|
||||
c(Md2,r)->c2 = wm2_c2;
|
||||
c(Md2,r)->extra = fc->extra;
|
||||
c(Md2,r)->flags = fc->flags;
|
||||
c(WMd2,r)->v = t;
|
||||
c(WMd2,r)->prev = lastWM2;
|
||||
c(WMd2,r)->c1t = 0; c(WMd2,r)->c1a = 0;
|
||||
c(WMd2,r)->c2t = 0; c(WMd2,r)->c2a = 0;
|
||||
lastWM2 = c(WMd2,r);
|
||||
return r;
|
||||
WMd2* r = mm_allocN(sizeof(WMd2), t_md2Wrap);
|
||||
r->c1 = wm2_c1;
|
||||
r->c2 = wm2_c2;
|
||||
r->extra = fc->extra;
|
||||
r->flags = fc->flags;
|
||||
r->v = t;
|
||||
r->prev = lastWM2;
|
||||
lastWM2 = r;
|
||||
r->c1a = 0; r->c2a = 0;
|
||||
return tag(r, MD2_TAG);
|
||||
}
|
||||
#endif
|
||||
return t;
|
||||
|
||||
44
src/vm.c
44
src/vm.c
@ -539,10 +539,10 @@ B evalBC(Body* b, Scope* sc) { // doesn't consume
|
||||
goto end;
|
||||
}
|
||||
case NSPM: { P(o) u32 l = *bc++;
|
||||
B a = mm_alloc(sizeof(FldAlias), t_fldAlias, ftag(OBJ_TAG));
|
||||
c(FldAlias,a)->obj = o;
|
||||
c(FldAlias,a)->p = l;
|
||||
ADD(a);
|
||||
FldAlias* a = mm_allocN(sizeof(FldAlias), t_fldAlias);
|
||||
a->obj = o;
|
||||
a->p = l;
|
||||
ADD(tag(a,OBJ_TAG));
|
||||
break;
|
||||
}
|
||||
case RETN: goto end;
|
||||
@ -650,28 +650,28 @@ B md2Bl_c1(B D, B x) { Md2D* d=c(Md2D,D); Md2Block* b=c(Md2Block, d->m2); p
|
||||
B md2Bl_c2(B D, B w, B x) { Md2D* d=c(Md2D,D); Md2Block* b=c(Md2Block, d->m2); ptr_inc(d); return execBlock(b->bl, b->sc, 6, (B[]){D, x, w , inc(d->m2), inc(d->f), inc(d->g)}); }
|
||||
B m_funBlock(Block* bl, Scope* psc) { // doesn't consume anything
|
||||
if (bl->imm) return execBlock(bl, psc, 0, NULL);
|
||||
B r = mm_alloc(sizeof(FunBlock), t_fun_block, ftag(FUN_TAG));
|
||||
c(FunBlock, r)->bl = bl; ptr_inc(bl);
|
||||
c(FunBlock, r)->sc = psc; ptr_inc(psc);
|
||||
c(FunBlock, r)->c1 = funBl_c1;
|
||||
c(FunBlock, r)->c2 = funBl_c2;
|
||||
return r;
|
||||
FunBlock* r = mm_allocN(sizeof(FunBlock), t_fun_block);
|
||||
r->bl = bl; ptr_inc(bl);
|
||||
r->sc = psc; ptr_inc(psc);
|
||||
r->c1 = funBl_c1;
|
||||
r->c2 = funBl_c2;
|
||||
return tag(r, FUN_TAG);
|
||||
}
|
||||
B m_md1Block(Block* bl, Scope* psc) {
|
||||
B r = mm_alloc(sizeof(Md1Block), t_md1_block, ftag(MD1_TAG));
|
||||
c(Md1Block, r)->bl = bl; ptr_inc(bl);
|
||||
c(Md1Block, r)->sc = psc; ptr_inc(psc);
|
||||
c(Md1Block, r)->c1 = md1Bl_c1;
|
||||
c(Md1Block, r)->c2 = md1Bl_c2;
|
||||
return r;
|
||||
Md1Block* r = mm_allocN(sizeof(Md1Block), t_md1_block);
|
||||
r->bl = bl; ptr_inc(bl);
|
||||
r->sc = psc; ptr_inc(psc);
|
||||
r->c1 = md1Bl_c1;
|
||||
r->c2 = md1Bl_c2;
|
||||
return tag(r, MD1_TAG);
|
||||
}
|
||||
B m_md2Block(Block* bl, Scope* psc) {
|
||||
B r = mm_alloc(sizeof(Md2Block), t_md2_block, ftag(MD2_TAG));
|
||||
c(Md2Block, r)->bl = bl; ptr_inc(bl);
|
||||
c(Md2Block, r)->sc = psc; ptr_inc(psc);
|
||||
c(Md2Block, r)->c1 = md2Bl_c1;
|
||||
c(Md2Block, r)->c2 = md2Bl_c2;
|
||||
return r;
|
||||
Md2Block* r = mm_allocN(sizeof(Md2Block), t_md2_block);
|
||||
r->bl = bl; ptr_inc(bl);
|
||||
r->sc = psc; ptr_inc(psc);
|
||||
r->c1 = md2Bl_c1;
|
||||
r->c2 = md2Bl_c2;
|
||||
return tag(r, MD2_TAG);
|
||||
}
|
||||
|
||||
void scope_free(Value* x) {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user