diff --git a/src/builtins/internal.c b/src/builtins/internal.c index 2a9f920a..58f958d6 100644 --- a/src/builtins/internal.c +++ b/src/builtins/internal.c @@ -170,7 +170,7 @@ B variation_c2(B t, B w, B x) { u8 xe = TI(x,elType); SGet(x) C8Arr* wc = toC8Arr(w); - u8* wp = wc->a; + u8* wp = c8arrv_ptr(wc); u8* wpE = wp+wc->ia; if (wc->ia==0) thrM("•internal.Variation: Zero-length 𝕨"); B res; diff --git a/src/builtins/sfns.c b/src/builtins/sfns.c index 8dd83565..f7b711cf 100644 --- a/src/builtins/sfns.c +++ b/src/builtins/sfns.c @@ -1093,42 +1093,46 @@ B select_ucw(B t, B o, B w, B x) { bool reuse = reusable(x); if (me==el_i32) { I32Arr* xn = reuse? toI32Arr(REUSE(x)) : cpyI32Arr(x); + i32* xp = i32arrv_ptr(xn); rep = toI32Any(rep); i32* rp = i32any_ptr(rep); for (usz i = 0; i < wia; i++) { i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia; // we're free to assume w is valid i32 cr = rp[i]; - EQ(cr != xn->a[cw]); - xn->a[cw] = cr; + EQ(cr != xp[cw]); + xp[cw] = cr; } dec(w); dec(rep); FREE_CHECK; return taga(xn); } else if (me==el_i16) { I16Arr* xn = reuse? toI16Arr(REUSE(x)) : cpyI16Arr(x); + i16* xp = i16arrv_ptr(xn); rep = toI16Any(rep); i16* rp = i16any_ptr(rep); for (usz i = 0; i < wia; i++) { i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia; i16 cr = rp[i]; - EQ(cr != xn->a[cw]); - xn->a[cw] = cr; + EQ(cr != xp[cw]); + xp[cw] = cr; } dec(w); dec(rep); FREE_CHECK; return taga(xn); } else if (me==el_i8) { I8Arr* xn = reuse? toI8Arr(REUSE(x)) : cpyI8Arr(x); + i8* xp = i8arrv_ptr(xn); rep = toI8Any(rep); i8* rp = i8any_ptr(rep); for (usz i = 0; i < wia; i++) { i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia; i8 cr = rp[i]; - EQ(cr != xn->a[cw]); - xn->a[cw] = cr; + EQ(cr != xp[cw]); + xp[cw] = cr; } dec(w); dec(rep); FREE_CHECK; return taga(xn); } else if (me==el_bit) { BitArr* xn = reuse? toBitArr(REUSE(x)) : cpyBitArr(x); + u64* xp = bitarrv_ptr(xn); rep = taga(toBitArr(rep)); u64* rp = bitarr_ptr(rep); for (usz i = 0; i < wia; i++) { i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia; bool cr = bitp_get(rp, i); - EQ(cr != bitp_get(xn->a,cw)); - bitp_set(xn->a,cw,cr); + EQ(cr != bitp_get(xp,cw)); + bitp_set(xp,cw,cr); } dec(w); dec(rep); FREE_CHECK; return taga(xn); } else UD; diff --git a/src/core/chrarr.h b/src/core/chrarr.h index db858b70..62f20fb4 100644 --- a/src/core/chrarr.h +++ b/src/core/chrarr.h @@ -11,6 +11,9 @@ #define TU C32 #define TP(W,X) W##c32##X #include "tyarrTemplate.h" +#define C8Arr TyArr +#define C16Arr TyArr +#define C32Arr TyArr B m_str8(usz sz, char* s); diff --git a/src/core/numarr.h b/src/core/numarr.h index 81b908c7..0b9a7268 100644 --- a/src/core/numarr.h +++ b/src/core/numarr.h @@ -3,6 +3,15 @@ #define I32Atom i32 #define F64Atom f64 +typedef struct TyArr { + struct Arr; + char a[]; +} TyArr; +typedef struct TySlice { + struct Slice; + void* a; +} TySlice; + #define TU I8 #define TP(W,X) W##i8##X #include "tyarrTemplate.h" @@ -15,6 +24,11 @@ #define TU F64 #define TP(W,X) W##f64##X #include "tyarrTemplate.h" +#define I8Arr TyArr +#define I16Arr TyArr +#define I32Arr TyArr +#define F64Arr TyArr +#define BitArr TyArr // bit array stuff #define BIT_N(IA) (((IA)+63) >> 6) // u64 count needed to store IA bits @@ -39,29 +53,26 @@ static inline u64 bitx(B x) { // repeats the boolean across all 64 bits } // BitArr -typedef struct BitArr { - struct Arr; - u64 a[]; -} BitArr; #define BITARR_SZ(IA) fsizeof(BitArr, a, u64, BIT_N(IA)) static B m_bitarrv(u64** p, usz ia) { BitArr* r = m_arr(BITARR_SZ(ia), t_bitarr, ia); arr_shVec((Arr*)r); - *p = r->a; + *p = (u64*)r->a; return taga(r); } static B m_bitarrc(u64** p, B x) { assert(isArr(x)); BitArr* r = m_arr(BITARR_SZ(a(x)->ia), t_bitarr, a(x)->ia); - *p = r->a; + *p = (u64*)r->a; arr_shCopy((Arr*)r, x); return taga(r); } static Arr* m_bitarrp(u64** p, usz ia) { BitArr* r = m_arr(BITARR_SZ(ia), t_bitarr, ia); - *p = r->a; + *p = (u64*)r->a; return (Arr*)r; } -static u64* bitarr_ptr(B x) { VTY(x, t_bitarr); return c(BitArr,x)->a; } +static u64* bitarr_ptr(B x) { VTY(x, t_bitarr); return (u64*)c(BitArr,x)->a; } +static u64* bitarrv_ptr(TyArr* x) { return (u64*)x->a; } I8Arr* cpyI8Arr (B x); // consumes diff --git a/src/core/stuff.h b/src/core/stuff.h index 335036cb..47aac655 100644 --- a/src/core/stuff.h +++ b/src/core/stuff.h @@ -23,7 +23,7 @@ static void decSh(Value* x) { if (RARE(prnk(x)>1)) ptr_dec(shObjP(x));} // some array stuff -#define TYARR_SZ(T,IA) fsizeof(T##Arr, a, T##Atom, IA) +#define TYARR_SZ(T,IA) fsizeof(TyArr, a, T##Atom, IA) #define TYARR_SZ2(T,IA) TYARR_SZ(T,IA) #define WRAP(X,IA,MSG) ({ i64 wV=(i64)(X); u64 iaW=(IA); if(RARE((u64)wV >= iaW)) { if(wV<0) wV+= iaW; if((u64)wV >= iaW) {MSG;} }; (usz)wV; }) diff --git a/src/core/tyarr.c b/src/core/tyarr.c index 4d1bbcfe..85d8b55c 100644 --- a/src/core/tyarr.c +++ b/src/core/tyarr.c @@ -114,7 +114,7 @@ static Arr* bitarr_slice(B x, usz s, usz ia) { return r; } -static B bitarr_get(Arr* x, usz n) { assert(x->type==t_bitarr); return bitp_get(((BitArr*)x)->a, n)? m_f64(1) : m_f64(0); } +static B bitarr_get(Arr* x, usz n) { assert(x->type==t_bitarr); return bitp_get((u64*)((BitArr*)x)->a, n)? m_f64(1) : m_f64(0); } static bool bitarr_canStore(B x) { return q_bit(x); } static void bitarr_init() { diff --git a/src/core/tyarrTemplate.c b/src/core/tyarrTemplate.c index b909759e..644f32ed 100644 --- a/src/core/tyarrTemplate.c +++ b/src/core/tyarrTemplate.c @@ -1,20 +1,18 @@ #define T_ARR TP(t_,arr) #define T_SLICE TP(t_,slice) -#define TArr JOIN(TU,Arr) -#define TSlice JOIN(TU,Slice) #define TEl JOIN(TU,Atom) static Arr* TP(m_,slice) (Arr* p, TEl* ptr, usz ia) { - TSlice* r = m_arr(sizeof(TSlice), T_SLICE, ia); + TySlice* r = m_arr(sizeof(TySlice), T_SLICE, ia); r->p = p; r->a = ptr; return (Arr*)r; } -static Arr* TP(,arr_slice) (B x, usz s, usz ia) { return TP(m_,slice) (a(x), c(TArr,x)->a+s, ia); } -static Arr* TP(,slice_slice) (B x, usz s, usz ia) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = TP(m_,slice) (p, c(TSlice,x)->a+s, ia); dec(x); return r; } +static Arr* TP(,arr_slice) (B x, usz s, usz ia) { return TP(m_,slice) (a(x), ((TEl*)c(TyArr,x)->a)+s, ia); } +static Arr* TP(,slice_slice) (B x, usz s, usz ia) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = TP(m_,slice) (p, ((TEl*)c(TySlice,x)->a)+s, ia); dec(x); return r; } -static B TP(,arr_get) (Arr* x, usz n) { assert(x->type==T_ARR ); return TP(m_,) (((TArr* )x)->a[n]); } -static B TP(,slice_get) (Arr* x, usz n) { assert(x->type==T_SLICE); return TP(m_,) (((TSlice*)x)->a[n]); } +static B TP(,arr_get) (Arr* x, usz n) { assert(x->type==T_ARR ); return TP(m_,) (((TEl*)((TyArr* )x)->a)[n]); } +static B TP(,slice_get) (Arr* x, usz n) { assert(x->type==T_SLICE); return TP(m_,) (((TEl*)((TySlice*)x)->a)[n]); } static bool TP(,arr_canStore) (B x) { return TP(q_,) (x); } static void TP(,arr_init)() { @@ -32,7 +30,5 @@ static void TP(,arr_init)() { } #undef TEl -#undef TSlice -#undef TArr #undef TU #undef TP diff --git a/src/core/tyarrTemplate.h b/src/core/tyarrTemplate.h index 6494ef50..fd6a5e59 100644 --- a/src/core/tyarrTemplate.h +++ b/src/core/tyarrTemplate.h @@ -1,42 +1,29 @@ #define T_ARR TP(t_,arr) #define T_SLICE TP(t_,slice) -#define TArr JOIN(TU,Arr) -#define TSlice JOIN(TU,Slice) #define TEl JOIN(TU,Atom) -typedef struct TArr { - struct Arr; - TEl a[]; -} TArr; -typedef struct TSlice { - struct Slice; - TEl* a; -} TSlice; - - static B TP(m_,arrv) (TEl** p, usz ia) { - TArr* r = m_arr(TYARR_SZ2(TU,ia), T_ARR, ia); + TyArr* r = m_arr(TYARR_SZ2(TU,ia), T_ARR, ia); arr_shVec((Arr*)r); - *p = r->a; + *p = (TEl*)r->a; return taga(r); } static B TP(m_,arrc) (TEl** p, B x) { assert(isArr(x)); - TArr* r = m_arr(TYARR_SZ2(TU,a(x)->ia), T_ARR, a(x)->ia); - *p = r->a; + TyArr* r = m_arr(TYARR_SZ2(TU,a(x)->ia), T_ARR, a(x)->ia); + *p = (TEl*)r->a; arr_shCopy((Arr*)r, x); return taga(r); } static Arr* TP(m_,arrp) (TEl** p, usz ia) { - TArr* r = m_arr(TYARR_SZ2(TU,ia), T_ARR, ia); - *p = r->a; + TyArr* r = m_arr(TYARR_SZ2(TU,ia), T_ARR, ia); + *p = (TEl*)r->a; return (Arr*)r; } +static TEl* TP(,arrv_ptr) (TyArr* x) { return (TEl*)x->a; } -static TEl* TP(,arr_ptr) (B x) { VTY(x, T_ARR); return c(TArr,x)->a; } -static TEl* TP(,any_ptr) (B x) { assert(isArr(x)); u8 t=v(x)->type; if(t==T_ARR) return c(TArr,x)->a; assert(t==T_SLICE); return c(TSlice,x)->a; } +static TEl* TP(,arr_ptr) (B x) { VTY(x, T_ARR); return (TEl*)c(TyArr,x)->a; } +static TEl* TP(,any_ptr) (B x) { assert(isArr(x)); u8 t=v(x)->type; if(t==T_ARR) return (TEl*)c(TyArr,x)->a; assert(t==T_SLICE); return (TEl*)c(TySlice,x)->a; } #undef TEl -#undef TSlice -#undef TArr #undef TU #undef TP diff --git a/src/singeli/builtins/cmp.c b/src/singeli/builtins/cmp.c index 2bc81e52..36d985e2 100644 --- a/src/singeli/builtins/cmp.c +++ b/src/singeli/builtins/cmp.c @@ -50,25 +50,7 @@ FN_LUT(avx2, ge, AA) static void* tyany_ptr(B x) { u8 t = v(x)->type; - if (IS_SLICE(t)) switch (t) { default: UD; - case t_i8slice: return c(I8Slice,x)->a; - case t_i16slice: return c(I16Slice,x)->a; - case t_i32slice: return c(I32Slice,x)->a; - case t_c8slice: return c(C8Slice,x)->a; - case t_c16slice: return c(C16Slice,x)->a; - case t_c32slice: return c(C32Slice,x)->a; - case t_f64slice: return c(F64Slice,x)->a; - } - switch (t) { default: UD; - case t_bitarr: return c(BitArr,x)->a; - case t_i8arr: return c(I8Arr, x)->a; - case t_i16arr: return c(I16Arr,x)->a; - case t_i32arr: return c(I32Arr,x)->a; - case t_c8arr: return c(C8Arr, x)->a; - case t_c16arr: return c(C16Arr,x)->a; - case t_c32arr: return c(C32Arr,x)->a; - case t_f64arr: return c(F64Arr,x)->a; - } + return IS_SLICE(t)? c(TySlice,x)->a : c(TyArr,x)->a; } #define AL(X) u64* rp; B r = m_bitarrc(&rp, X); usz ria=a(r)->ia; diff --git a/src/utils/mut.c b/src/utils/mut.c index 7ca36f01..827f30d6 100644 --- a/src/utils/mut.c +++ b/src/utils/mut.c @@ -21,15 +21,15 @@ NOINLINE void mut_to(Mut* m, u8 n) { } #endif switch(n) { default: UD; - case el_bit: { BitArr* t=cpyBitArr(taga(m->val)); m->val=(Arr*)t; m->abit=t->a; return; } - case el_i8: { I8Arr* t=cpyI8Arr (taga(m->val)); m->val=(Arr*)t; m->ai8 =t->a; return; } - case el_i16: { I16Arr* t=cpyI16Arr(taga(m->val)); m->val=(Arr*)t; m->ai16=t->a; return; } - case el_i32: { I32Arr* t=cpyI32Arr(taga(m->val)); m->val=(Arr*)t; m->ai32=t->a; return; } - case el_c8: { C8Arr* t=cpyC8Arr (taga(m->val)); m->val=(Arr*)t; m->ac8 =t->a; return; } - case el_c16: { C16Arr* t=cpyC16Arr(taga(m->val)); m->val=(Arr*)t; m->ac16=t->a; return; } - case el_c32: { C32Arr* t=cpyC32Arr(taga(m->val)); m->val=(Arr*)t; m->ac32=t->a; return; } - case el_f64: { F64Arr* t=cpyF64Arr(taga(m->val)); m->val=(Arr*)t; m->af64=t->a; return; } - case el_B : { HArr* t=cpyHArr (taga(m->val)); m->val=(Arr*)t; m->aB =t->a; return; } + case el_bit: { BitArr* t=cpyBitArr(taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } + case el_i8: { I8Arr* t=cpyI8Arr (taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } + case el_i16: { I16Arr* t=cpyI16Arr(taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } + case el_i32: { I32Arr* t=cpyI32Arr(taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } + case el_c8: { C8Arr* t=cpyC8Arr (taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } + case el_c16: { C16Arr* t=cpyC16Arr(taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } + case el_c32: { C32Arr* t=cpyC32Arr(taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } + case el_f64: { F64Arr* t=cpyF64Arr(taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } + case el_B : { HArr* t=cpyHArr (taga(m->val)); m->val=(Arr*)t; m->a = t->a; return; } } } } diff --git a/src/utils/mut.h b/src/utils/mut.h index 5b7b40b1..76103918 100644 --- a/src/utils/mut.h +++ b/src/utils/mut.h @@ -18,9 +18,10 @@ typedef struct Mut { usz ia; Arr* val; union { + void* a; B* aB; i8* ai8; i16* ai16; i32* ai32; u8* ac8; u16* ac16; u32* ac32; - f64* af64; u64* abit; B* aB; + f64* af64; u64* abit; }; } Mut; #define MAKE_MUT(N, IA) Mut N##_val; N##_val.type = el_MAX; N##_val.ia = (IA); Mut* N = &N##_val; @@ -48,11 +49,7 @@ static void mut_init(Mut* m, u8 n) { } Arr* a = m_arr(sz, ty, ia); m->val = a; - switch(n) { default: UD; // gcc generates horrible code for this (which should just be two instructions), but that's what gcc does - case el_i8: m->ai8 = ((I8Arr*)a)->a; break; case el_i16: m->ai16 = ((I16Arr*)a)->a; break; case el_i32: m->ai32 = ((I32Arr*)a)->a; break; - case el_c8: m->ac8 = ((C8Arr*)a)->a; break; case el_c16: m->ac16 = ((C16Arr*)a)->a; break; case el_c32: m->ac32 = ((C32Arr*)a)->a; break; - case el_f64: m->af64 = ((F64Arr*)a)->a; break; case el_bit: m->abit = ((BitArr*)a)->a; break; - } + m->a = ((TyArr*)a)->a; } void mut_to(Mut* m, u8 n);