diff --git a/src/builtins/md2.c b/src/builtins/md2.c index 2742608e..0cc31ed9 100644 --- a/src/builtins/md2.c +++ b/src/builtins/md2.c @@ -3,8 +3,8 @@ #include "../utils/talloc.h" #include "../builtins.h" -B md2BI_uc1(B t, B o, B f, B g, B x) { return c(BMd2,t)->uc1(t, o, f, g, x); } -B md2BI_ucw(B t, B o, B f, B g, B w, B x) { return c(BMd2,t)->ucw(t, o, f, g, w, x); } +B md2BI_uc1(Md2* t, B o, B f, B g, B x) { return ((BMd2*)t)->uc1(t, o, f, g, x); } +B md2BI_ucw(Md2* t, B o, B f, B g, B w, B x) { return ((BMd2*)t)->ucw(t, o, f, g, w, x); } B val_c1(Md2D* d, B x) { return c1(d->f, x); } @@ -161,7 +161,7 @@ B under_c2(Md2D* d, B w, B x) { B f=d->f; B g=d->g; return r; } -B before_uc1(B t, B o, B f, B g, B x) { +B before_uc1(Md2* t, B o, B f, B g, B x) { if (!isFun(g)) return def_m2_uc1(t, o, f, g, x); return TI(g,fn_ucw)(g, o, inc(f), x); } diff --git a/src/core.h b/src/core.h index 43687e30..3279e33f 100644 --- a/src/core.h +++ b/src/core.h @@ -45,13 +45,13 @@ typedef struct BFn { } BFn; typedef struct BMd1 { struct Md1; - M1C1 im; - M1C2 iw; - M1C2 ix; + D1C1 im; + D1C2 iw; + D1C2 ix; } BMd1; typedef struct BMd2 { struct Md2; - BBBBB2B uc1; - BBBBBB2B ucw; + M2C4 uc1; + M2C5 ucw; } BMd2; diff --git a/src/core/derv.c b/src/core/derv.c index 569a7ff8..c50cf2b4 100644 --- a/src/core/derv.c +++ b/src/core/derv.c @@ -46,8 +46,8 @@ B fork_c2(B t, B w, B x) { return c2(c(Fork,t)->g, inc(f), c2(h,w,x)); } } -B md2H_c1(Md1D* m, B x) { Md2H* t=(Md2H*) m->m1; return md2D_c1(m_md2D(tag(t->m2,MD2_TAG), m->f, t->g), x); } -B md2H_c2(Md1D* m, B w, B x) { Md2H* t=(Md2H*) m->m1; return md2D_c2(m_md2D(tag(t->m2,MD2_TAG), m->f, t->g), w, x); } +B md2H_c1(Md1D* m, B x) { Md2H* t=(Md2H*) m->m1; return md2D_c1(m_md2D(t->m2, m->f, t->g), x); } +B md2H_c2(Md1D* m, B w, B x) { Md2H* t=(Md2H*) m->m1; return md2D_c2(m_md2D(t->m2, m->f, t->g), w, x); } static B md1D_decompose(B x) { B r=m_hVec3(m_i32(4),inc(c(Md1D,x)->f),tag(ptr_inc(c(Md1D,x)->m1),MD1_TAG) ); decR(x); return r; } static B md2D_decompose(B x) { B r=m_hVec4(m_i32(5),inc(c(Md2D,x)->f),tag(ptr_inc(c(Md2D,x)->m2),MD2_TAG), inc(c(Md2D,x)->g)); decR(x); return r; } @@ -59,7 +59,7 @@ static B md2D_uc1(B t, B o, B x) { Md2* m = c(Md2D, t)->m2; B f = c(Md2D, t)->f; B g = c(Md2D, t)->g; - return TIv(m,m2_uc1)(tag(m,MD2_TAG), o, f, g, x); + return TIv(m,m2_uc1)(m, o, f, g, x); } static B toConstant(B x) { // doesn't consume x @@ -98,7 +98,8 @@ static B md1D_ix(B t, B w, B x) { Md1D* d = c(Md1D,t); return TIv(d->m1,m1_ix)(d static B md2D_im(B t, B x) { Md2D* d = c(Md2D,t); return TIv(d->m2,m2_im)(d, x); } static B md2D_iw(B t, B w, B x) { Md2D* d = c(Md2D,t); return TIv(d->m2,m2_iw)(d, w, x); } static B md2D_ix(B t, B w, B x) { Md2D* d = c(Md2D,t); return TIv(d->m2,m2_ix)(d, w, x); } - +static B m1BI_d(B t, B f ) { return m_md1D(c(Md1,t), f ); } +static B m2BI_d(B t, B f, B g) { return m_md2D(c(Md2,t), f, g); } void derv_init() { TIi(t_md1D,freeO) = md1D_freeO; TIi(t_md1D,freeF) = md1D_freeF; TIi(t_md1D,visit) = md1D_visit; TIi(t_md1D,print) = md1D_print; TIi(t_md1D,decompose) = md1D_decompose; @@ -106,8 +107,8 @@ void derv_init() { TIi(t_md2H,freeO) = md2H_freeO; TIi(t_md2H,freeF) = md2H_freeF; TIi(t_md2H,visit) = md2H_visit; TIi(t_md2H,print) = md2H_print; TIi(t_md2H,decompose) = md2H_decompose; TIi(t_fork,freeO) = fork_freeO; TIi(t_fork,freeF) = fork_freeF; TIi(t_fork,visit) = fork_visit; TIi(t_fork,print) = fork_print; TIi(t_fork,decompose) = fork_decompose; TIi(t_atop,freeO) = atop_freeO; TIi(t_atop,freeF) = atop_freeF; TIi(t_atop,visit) = atop_visit; TIi(t_atop,print) = atop_print; TIi(t_atop,decompose) = atop_decompose; - TIi(t_md1BI,m1_d) = m_md1D; - TIi(t_md2BI,m2_d) = m_md2D; + TIi(t_md1BI,m1_d) = m1BI_d; + TIi(t_md2BI,m2_d) = m2BI_d; TIi(t_md2D,fn_uc1) = md2D_uc1; // not in post so later init can utilize it TIi(t_md1D,fn_im) = md1D_im; TIi(t_md2D,fn_im) = md2D_im; TIi(t_md1D,fn_iw) = md1D_iw; TIi(t_md2D,fn_iw) = md2D_iw; diff --git a/src/core/derv.h b/src/core/derv.h index 0aeacf2c..4efe96b4 100644 --- a/src/core/derv.h +++ b/src/core/derv.h @@ -35,13 +35,13 @@ B fork_c2(B t, B w, B x); B md2H_c1(Md1D* d, B x); B md2H_c2(Md1D* d, B w, B x); // consume all args -static B m_md1D(B m, B f ) { Md1D* r = mm_alloc(sizeof(Md1D), t_md1D); r->f = f; r->m1 = c(Md1,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_alloc(sizeof(Md2D), t_md2D); r->f = f; r->m2 = c(Md2,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_alloc(sizeof(Md2H), t_md2H); r->m2 = c(Md2,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_alloc(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_alloc(sizeof(Atop), t_atop); r->g = g; r->h = h; r->c1=tr2D_c1; r->c2=tr2D_c2; return tag(r,FUN_TAG); } +static B m_md1D(Md1* m, B f ) { Md1D* r = mm_alloc(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(Md2* m, B f, B g) { Md2D* r = mm_alloc(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(Md2* m, B g) { Md2H* r = mm_alloc(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_alloc(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_alloc(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"); } static B m2_d(B m, B f, B g) { if(isMd2(m)) return TI(m,m2_d)(m, f, g); thrM("Interpreting non-2-modifier as 2-modifier"); } -static B m2_h(B m, B g) { return m_md2H(m, g); } +static B m2_h(B m, B g) { if(isMd2(m)) return m_md2H(c(Md2,m), g); thrM("Interpreting non-2-modifier as 2-modifier"); } diff --git a/src/core/stuff.c b/src/core/stuff.c index 092dec00..28436458 100644 --- a/src/core/stuff.c +++ b/src/core/stuff.c @@ -58,10 +58,10 @@ static B rtUnder_cw(B f, B g, B w, B x) { // consumes w,x } B def_fn_uc1(B t, B o, B x) { return rtUnder_c1(o, t, x); } B def_fn_ucw(B t, B o, B w, B x) { return rtUnder_cw(o, t, w, x); } -B def_m1_uc1(B t, B o, B f, B x) { B t2 = m1_d(inc(t),inc(f) ); B r = rtUnder_c1(o, t2, x); dec(t2); return r; } -B def_m1_ucw(B t, B o, B f, B w, B x) { B t2 = m1_d(inc(t),inc(f) ); B r = rtUnder_cw(o, t2, w, x); dec(t2); return r; } -B def_m2_uc1(B t, B o, B f, B g, B x) { B t2 = m2_d(inc(t),inc(f),inc(g)); B r = rtUnder_c1(o, t2, x); dec(t2); return r; } -B def_m2_ucw(B t, B o, B f, B g, B w, B x) { B t2 = m2_d(inc(t),inc(f),inc(g)); B r = rtUnder_cw(o, t2, w, x); dec(t2); return r; } +B def_m1_uc1(Md1* t, B o, B f, B x) { B t2 = m1_d(tag(ptr_inc(t),MD1_TAG),inc(f) ); B r = rtUnder_c1(o, t2, x); dec(t2); return r; } +B def_m1_ucw(Md1* t, B o, B f, B w, B x) { B t2 = m1_d(tag(ptr_inc(t),MD1_TAG),inc(f) ); B r = rtUnder_cw(o, t2, w, x); dec(t2); return r; } +B def_m2_uc1(Md2* t, B o, B f, B g, B x) { B t2 = m2_d(tag(ptr_inc(t),MD2_TAG),inc(f),inc(g)); B r = rtUnder_c1(o, t2, x); dec(t2); return r; } +B def_m2_ucw(Md2* t, B o, B f, B g, B w, B x) { B t2 = m2_d(tag(ptr_inc(t),MD2_TAG),inc(f),inc(g)); B r = rtUnder_cw(o, t2, w, x); dec(t2); return r; } B def_decompose(B x) { return m_hVec2(m_i32(isCallable(x)? (isImpureBuiltin(x)? 1 : 0) : -1),x); } diff --git a/src/core/stuff.h b/src/core/stuff.h index d591d219..d4c9e077 100644 --- a/src/core/stuff.h +++ b/src/core/stuff.h @@ -157,10 +157,10 @@ static inline B chr_squeezeChk(B x) { return FL_HAS(x,fl_squoze)? x : chr_squeez B def_fn_uc1(B t, B o, B x); B def_fn_ucw(B t, B o, B w, B x); -B def_m1_uc1(B t, B o, B f, B x); -B def_m1_ucw(B t, B o, B f, B w, B x); -B def_m2_uc1(B t, B o, B f, B g, B x); -B def_m2_ucw(B t, B o, B f, B g, B w, B x); +B def_m1_uc1(Md1* t, B o, B f, B x); +B def_m1_ucw(Md1* t, B o, B f, B w, B x); +B def_m2_uc1(Md2* t, B o, B f, B g, B x); +B def_m2_ucw(Md2* t, B o, B f, B g, B w, B x); B def_fn_im(B t, B x); B def_fn_is(B t, B x); B def_fn_iw(B t, B w, B x); diff --git a/src/h.h b/src/h.h index ba6121f0..7356b57d 100644 --- a/src/h.h +++ b/src/h.h @@ -419,6 +419,10 @@ void slice_freeO(Value* x); void slice_freeF(Value* x); void slice_visit(Value* x); void slice_print(B x); +typedef struct Md1 Md1; +typedef struct Md2 Md2; +typedef struct Md1D Md1D; +typedef struct Md2D Md2D; typedef bool (* B2b)(B); typedef void (* B2v)(B); @@ -430,14 +434,16 @@ typedef B (* B2B)(B); typedef B (* BB2B)(B, B); typedef B (* BBB2B)(B, B, B); typedef B (* BBBB2B)(B, B, B, B); -typedef B (* BBBBB2B)(B, B, B, B, B); -typedef B (*BBBBBB2B)(B, B, B, B, B, B); -typedef struct Md1D Md1D; -typedef struct Md2D Md2D; -typedef B (*M1C1)(Md1D*, B); -typedef B (*M1C2)(Md1D*, B, B); -typedef B (*M2C1)(Md2D*, B); -typedef B (*M2C2)(Md2D*, B, B); + +typedef B (*M1C3)(Md1*, B, B, B); +typedef B (*M1C4)(Md1*, B, B, B, B); +typedef B (*M2C4)(Md2*, B, B, B, B); +typedef B (*M2C5)(Md2*, B, B, B, B, B); + +typedef B (*D1C1)(Md1D*, B); +typedef B (*D1C2)(Md1D*, B, B); +typedef B (*D2C1)(Md2D*, B); +typedef B (*D2C2)(Md2D*, B, B); #define FOR_TI(F) \ F(V2v, freeF) /* expects refc==0, includes mm_free */ \ @@ -450,21 +456,21 @@ typedef B (*M2C2)(Md2D*, B, B); \ F( BBB2B, fn_uc1) /* t,o, x→r; r≡O⌾( T ) x; consumes x */ \ F( BBBB2B, fn_ucw) /* t,o, w,x→r; r≡O⌾(w⊸ T ) x; consumes w,x */ \ - F( BBBB2B, m1_uc1) /* t,o,f, x→r; r≡O⌾( F _T ) x; consumes x */ \ - F( BBBBB2B, m1_ucw) /* t,o,f, w,x→r; r≡O⌾(w⊸(F _T )) x; consumes w,x */ \ - F( BBBBB2B, m2_uc1) /* t,o,f,g, x→r; r≡O⌾( F _T_ G ) x; consumes x */ \ - F(BBBBBB2B, m2_ucw) /* t,o,f,g,w,x→r; r≡O⌾(w⊸(F _T_ G)) x; consumes w,x */ \ + F(M1C3, m1_uc1) /* t,o,f, x→r; r≡O⌾( F _T ) x; consumes x */ \ + F(M1C4, m1_ucw) /* t,o,f, w,x→r; r≡O⌾(w⊸(F _T )) x; consumes w,x */ \ + F(M2C4, m2_uc1) /* t,o,f,g, x→r; r≡O⌾( F _T_ G ) x; consumes x */ \ + F(M2C5, m2_ucw) /* t,o,f,g,w,x→r; r≡O⌾(w⊸(F _T_ G)) x; consumes w,x */ \ \ F( BB2B, fn_im) /* t, x; function monadic inverse; consumes x */ \ F( BB2B, fn_is) /* t, x; function equal-arg inverse; consumes x */ \ F(BBB2B, fn_iw) /* t,w,x; function dyadic 𝕨-inverse; consumes w,x */ \ F(BBB2B, fn_ix) /* t,w,x; function dyadic 𝕩-inverse; consumes w,x */ \ - F( M1C1, m1_im) /* d, x; 1-modifier monadic inverse; consumes x */ \ - F( M1C2, m1_iw) /* d,w,x; 1-modifier dyadic 𝕨-inverse; consumes w,x */ \ - F( M1C2, m1_ix) /* d,w,x; 1-modifier dyadic 𝕩-inverse; consumes w,x */ \ - F( M2C1, m2_im) /* d, x; 2-modifier monadic inverse; consumes x */ \ - F( M2C2, m2_iw) /* d,w,x; 2-modifier dyadic 𝕨-inverse; consumes w,x */ \ - F( M2C2, m2_ix) /* d,w,x; 2-modifier dyadic 𝕩-inverse; consumes w,x */ \ + F( D1C1, m1_im) /* d, x; 1-modifier monadic inverse; consumes x */ \ + F( D1C2, m1_iw) /* d,w,x; 1-modifier dyadic 𝕨-inverse; consumes w,x */ \ + F( D1C2, m1_ix) /* d,w,x; 1-modifier dyadic 𝕩-inverse; consumes w,x */ \ + F( D2C1, m2_im) /* d, x; 2-modifier monadic inverse; consumes x */ \ + F( D2C2, m2_iw) /* d,w,x; 2-modifier dyadic 𝕨-inverse; consumes w,x */ \ + F( D2C2, m2_ix) /* d,w,x; 2-modifier dyadic 𝕩-inverse; consumes w,x */ \ \ F(B2b, canStore) /* doesn't consume */ \ F(u8, elType) /* guarantees that the corresponding i32any_ptr/f64any_ptr/c32any_ptr/… always succeeds */ \ @@ -591,22 +597,22 @@ static B c2iWX(B f, B w, B x) { // c2 but implicit inc(w);inc(x) } -typedef struct Md1 { +struct Md1 { struct Value; - M1C1 c1; // f(md1d{this,f}, x); consumes x - M1C2 c2; // f(md1d{this,f},w,x); consumes w,x -} Md1; -typedef struct Md2 { + D1C1 c1; // f(md1d{this,f}, x); consumes x + D1C2 c2; // f(md1d{this,f},w,x); consumes w,x +}; +struct Md2 { struct Value; - M2C1 c1; // f(md2d{this,f,g}, x); consumes x - M2C2 c2; // f(md2d{this,f,g},w,x); consumes w,x -} Md2; + D2C1 c1; // f(md2d{this,f,g}, x); consumes x + D2C2 c2; // f(md2d{this,f,g},w,x); consumes w,x +}; static B m1_d(B m, B f ); static B m2_d(B m, B f, B g); static B m2_h(B m, B g); -static B m_md1D(B m, B f ); -static B m_md2D(B m, B f, B g); -static B m_md2H(B m, B g); +static B m_md1D(Md1* m, B f ); +static B m_md2D(Md2* m, B f, B g); +static B m_md2H(Md2* m, B g); static B m_fork(B f, B g, B h); static B m_atop( B g, B h); diff --git a/src/load.c b/src/load.c index 5a1b6324..893de675 100644 --- a/src/load.c +++ b/src/load.c @@ -559,7 +559,7 @@ static NOINLINE B m_bfn(BB2B c1, BBB2B c2, u8 id) { B r = tag(f,FUN_TAG); gc_add(r); return r; } -static NOINLINE B m_bm1(M1C1 c1, M1C2 c2, u8 id) { +static NOINLINE B m_bm1(D1C1 c1, D1C2 c2, u8 id) { BMd1* m = mm_alloc(sizeof(BMd1), t_md1BI); m->c1 = c1; m->c2 = c2; @@ -571,7 +571,7 @@ static NOINLINE B m_bm1(M1C1 c1, M1C2 c2, u8 id) { return r; } -static NOINLINE B m_bm2(M2C1 c1, M2C2 c2, u8 id) { +static NOINLINE B m_bm2(D2C1 c1, D2C2 c2, u8 id) { BMd2* m = mm_alloc(sizeof(BMd2), t_md2BI); m->c1 = c1; m->c2 = c2; diff --git a/src/rtwrap.c b/src/rtwrap.c index 86020b8f..e9e1d2b3 100644 --- a/src/rtwrap.c +++ b/src/rtwrap.c @@ -232,17 +232,19 @@ B rtWrap_unwrap(B x) { } -B wfn_uc1(B t, B o, B x) { B t2 = c(WFun,t)->v; return TI(t2,fn_uc1)(t2, o, x); } -B wfn_ucw(B t, B o, B w, B x) { B t2 = c(WFun,t)->v; return TI(t2,fn_ucw)(t2, o, w, x); } -B wm1_uc1(B t, B o, B f, B x) { B t2 = c(WMd1,t)->v; return TI(t2,m1_uc1)(t2, o, f, x); } -B wm1_ucw(B t, B o, B f, B w, B x) { B t2 = c(WMd1,t)->v; return TI(t2,m1_ucw)(t2, o, f, w, x); } -B wm2_uc1(B t, B o, B f, B g, B x) { B t2 = c(WMd2,t)->v; return TI(t2,m2_uc1)(t2, o, f, g, x); } -B wm2_ucw(B t, B o, B f, B g, B w, B x) { B t2 = c(WMd2,t)->v; return TI(t2,m2_ucw)(t2, o, f, g, w, x); } +B wfn_uc1(B t, B o, B x) { B t2 = c(WFun,t)->v; return TI(t2,fn_uc1)( t2, o, x); } +B wfn_ucw(B t, B o, B w, B x) { B t2 = c(WFun,t)->v; return TI(t2,fn_ucw)( t2, o, w, x); } +B wm1_uc1(Md1* t, B o, B f, B x) { B t2 = ((WMd1*)t)->v; return TI(t2,m1_uc1)(c(Md1,t2), o, f, x); } +B wm1_ucw(Md1* t, B o, B f, B w, B x) { B t2 = ((WMd1*)t)->v; return TI(t2,m1_ucw)(c(Md1,t2), o, f, w, x); } +B wm2_uc1(Md2* t, B o, B f, B g, B x) { B t2 = ((WMd2*)t)->v; return TI(t2,m2_uc1)(c(Md2,t2), o, f, g, x); } +B wm2_ucw(Md2* t, B o, B f, B g, B w, B x) { B t2 = ((WMd2*)t)->v; return TI(t2,m2_ucw)(c(Md2,t2), o, f, g, w, x); } +static B m1BI_d(B t, B f ) { return m_md1D(c(Md1,t), f ); } +static B m2BI_d(B t, B f, B g) { return m_md2D(c(Md2,t), f, g); } void rtWrap_init() { TIi(t_funWrap,visit) = wf_visit; TIi(t_funWrap,identity) = wf_identity; - TIi(t_md1Wrap,visit) = wm1_visit; TIi(t_md1Wrap,m1_d) = m_md1D; - TIi(t_md2Wrap,visit) = wm2_visit; TIi(t_md2Wrap,m2_d) = m_md2D; + TIi(t_md1Wrap,visit) = wm1_visit; TIi(t_md1Wrap,m1_d) = m1BI_d; + TIi(t_md2Wrap,visit) = wm2_visit; TIi(t_md2Wrap,m2_d) = m2BI_d; TIi(t_funWrap,fn_uc1) = wfn_uc1; TIi(t_funWrap,fn_ucw) = wfn_ucw; TIi(t_md1Wrap,m1_uc1) = wm1_uc1; diff --git a/src/vm.c b/src/vm.c index 224a46ee..fafeb5c8 100644 --- a/src/vm.c +++ b/src/vm.c @@ -856,8 +856,8 @@ B md2Bl_im(Md2D* d, B x) { Md2Block* b=(Md2Block*)d->m2; ptr_inc(d); return B md2Bl_iw(Md2D* d, B w, B x) { Md2Block* b=(Md2Block*)d->m2; ptr_inc(d); return execBlock(b->bl, b->bl->invWBody, b->sc, 6, (B[]){tag(d,FUN_TAG), x, w , inc(tag(d->m2,MD2_TAG)), inc(d->f), inc(d->g)}); } B md2Bl_ix(Md2D* d, B w, B x) { Md2Block* b=(Md2Block*)d->m2; ptr_inc(d); return execBlock(b->bl, b->bl->invXBody, b->sc, 6, (B[]){tag(d,FUN_TAG), x, w , inc(tag(d->m2,MD2_TAG)), inc(d->f), inc(d->g)}); } -B md1Bl_d(B m, B f ) { Md1Block* c = c(Md1Block,m); Block* bl=c(Md1Block, m)->bl; return c->bl->imm? execBlock(bl, bl->bodies[0], c(Md1Block, m)->sc, 2, (B[]){m, f }) : m_md1D(m,f ); } -B md2Bl_d(B m, B f, B g) { Md2Block* c = c(Md2Block,m); Block* bl=c(Md2Block, m)->bl; return c->bl->imm? execBlock(bl, bl->bodies[0], c(Md2Block, m)->sc, 3, (B[]){m, f, g}) : m_md2D(m,f,g); } +B md1Bl_d(B m, B f ) { Md1Block* c = c(Md1Block,m); Block* bl=c(Md1Block, m)->bl; return c->bl->imm? execBlock(bl, bl->bodies[0], c(Md1Block, m)->sc, 2, (B[]){m, f }) : m_md1D((Md1*)c,f ); } +B md2Bl_d(B m, B f, B g) { Md2Block* c = c(Md2Block,m); Block* bl=c(Md2Block, m)->bl; return c->bl->imm? execBlock(bl, bl->bodies[0], c(Md2Block, m)->sc, 3, (B[]){m, f, g}) : m_md2D((Md2*)c,f,g); } B m_funBlock(Block* bl, Scope* psc) { // doesn't consume anything if (bl->imm) return execBlock(bl, bl->bodies[0], psc, 0, NULL);