merged typed types
This commit is contained in:
parent
4ca34e3f8e
commit
d42dd3dcf9
@ -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;
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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; })
|
||||
|
||||
@ -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() {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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; }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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);
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user