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);
|
u8 xe = TI(x,elType);
|
||||||
SGet(x)
|
SGet(x)
|
||||||
C8Arr* wc = toC8Arr(w);
|
C8Arr* wc = toC8Arr(w);
|
||||||
u8* wp = wc->a;
|
u8* wp = c8arrv_ptr(wc);
|
||||||
u8* wpE = wp+wc->ia;
|
u8* wpE = wp+wc->ia;
|
||||||
if (wc->ia==0) thrM("•internal.Variation: Zero-length 𝕨");
|
if (wc->ia==0) thrM("•internal.Variation: Zero-length 𝕨");
|
||||||
B res;
|
B res;
|
||||||
|
|||||||
@ -1093,42 +1093,46 @@ B select_ucw(B t, B o, B w, B x) {
|
|||||||
bool reuse = reusable(x);
|
bool reuse = reusable(x);
|
||||||
if (me==el_i32) {
|
if (me==el_i32) {
|
||||||
I32Arr* xn = reuse? toI32Arr(REUSE(x)) : cpyI32Arr(x);
|
I32Arr* xn = reuse? toI32Arr(REUSE(x)) : cpyI32Arr(x);
|
||||||
|
i32* xp = i32arrv_ptr(xn);
|
||||||
rep = toI32Any(rep); i32* rp = i32any_ptr(rep);
|
rep = toI32Any(rep); i32* rp = i32any_ptr(rep);
|
||||||
for (usz i = 0; i < wia; i++) {
|
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
|
i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia; // we're free to assume w is valid
|
||||||
i32 cr = rp[i];
|
i32 cr = rp[i];
|
||||||
EQ(cr != xn->a[cw]);
|
EQ(cr != xp[cw]);
|
||||||
xn->a[cw] = cr;
|
xp[cw] = cr;
|
||||||
}
|
}
|
||||||
dec(w); dec(rep); FREE_CHECK; return taga(xn);
|
dec(w); dec(rep); FREE_CHECK; return taga(xn);
|
||||||
} else if (me==el_i16) {
|
} else if (me==el_i16) {
|
||||||
I16Arr* xn = reuse? toI16Arr(REUSE(x)) : cpyI16Arr(x);
|
I16Arr* xn = reuse? toI16Arr(REUSE(x)) : cpyI16Arr(x);
|
||||||
|
i16* xp = i16arrv_ptr(xn);
|
||||||
rep = toI16Any(rep); i16* rp = i16any_ptr(rep);
|
rep = toI16Any(rep); i16* rp = i16any_ptr(rep);
|
||||||
for (usz i = 0; i < wia; i++) {
|
for (usz i = 0; i < wia; i++) {
|
||||||
i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia;
|
i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia;
|
||||||
i16 cr = rp[i];
|
i16 cr = rp[i];
|
||||||
EQ(cr != xn->a[cw]);
|
EQ(cr != xp[cw]);
|
||||||
xn->a[cw] = cr;
|
xp[cw] = cr;
|
||||||
}
|
}
|
||||||
dec(w); dec(rep); FREE_CHECK; return taga(xn);
|
dec(w); dec(rep); FREE_CHECK; return taga(xn);
|
||||||
} else if (me==el_i8) {
|
} else if (me==el_i8) {
|
||||||
I8Arr* xn = reuse? toI8Arr(REUSE(x)) : cpyI8Arr(x);
|
I8Arr* xn = reuse? toI8Arr(REUSE(x)) : cpyI8Arr(x);
|
||||||
|
i8* xp = i8arrv_ptr(xn);
|
||||||
rep = toI8Any(rep); i8* rp = i8any_ptr(rep);
|
rep = toI8Any(rep); i8* rp = i8any_ptr(rep);
|
||||||
for (usz i = 0; i < wia; i++) {
|
for (usz i = 0; i < wia; i++) {
|
||||||
i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia;
|
i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia;
|
||||||
i8 cr = rp[i];
|
i8 cr = rp[i];
|
||||||
EQ(cr != xn->a[cw]);
|
EQ(cr != xp[cw]);
|
||||||
xn->a[cw] = cr;
|
xp[cw] = cr;
|
||||||
}
|
}
|
||||||
dec(w); dec(rep); FREE_CHECK; return taga(xn);
|
dec(w); dec(rep); FREE_CHECK; return taga(xn);
|
||||||
} else if (me==el_bit) {
|
} else if (me==el_bit) {
|
||||||
BitArr* xn = reuse? toBitArr(REUSE(x)) : cpyBitArr(x);
|
BitArr* xn = reuse? toBitArr(REUSE(x)) : cpyBitArr(x);
|
||||||
|
u64* xp = bitarrv_ptr(xn);
|
||||||
rep = taga(toBitArr(rep)); u64* rp = bitarr_ptr(rep);
|
rep = taga(toBitArr(rep)); u64* rp = bitarr_ptr(rep);
|
||||||
for (usz i = 0; i < wia; i++) {
|
for (usz i = 0; i < wia; i++) {
|
||||||
i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia;
|
i64 cw = wp[i]; if (RARE(cw<0)) cw+= (i64)xia;
|
||||||
bool cr = bitp_get(rp, i);
|
bool cr = bitp_get(rp, i);
|
||||||
EQ(cr != bitp_get(xn->a,cw));
|
EQ(cr != bitp_get(xp,cw));
|
||||||
bitp_set(xn->a,cw,cr);
|
bitp_set(xp,cw,cr);
|
||||||
}
|
}
|
||||||
dec(w); dec(rep); FREE_CHECK; return taga(xn);
|
dec(w); dec(rep); FREE_CHECK; return taga(xn);
|
||||||
} else UD;
|
} else UD;
|
||||||
|
|||||||
@ -11,6 +11,9 @@
|
|||||||
#define TU C32
|
#define TU C32
|
||||||
#define TP(W,X) W##c32##X
|
#define TP(W,X) W##c32##X
|
||||||
#include "tyarrTemplate.h"
|
#include "tyarrTemplate.h"
|
||||||
|
#define C8Arr TyArr
|
||||||
|
#define C16Arr TyArr
|
||||||
|
#define C32Arr TyArr
|
||||||
|
|
||||||
|
|
||||||
B m_str8(usz sz, char* s);
|
B m_str8(usz sz, char* s);
|
||||||
|
|||||||
@ -3,6 +3,15 @@
|
|||||||
#define I32Atom i32
|
#define I32Atom i32
|
||||||
#define F64Atom f64
|
#define F64Atom f64
|
||||||
|
|
||||||
|
typedef struct TyArr {
|
||||||
|
struct Arr;
|
||||||
|
char a[];
|
||||||
|
} TyArr;
|
||||||
|
typedef struct TySlice {
|
||||||
|
struct Slice;
|
||||||
|
void* a;
|
||||||
|
} TySlice;
|
||||||
|
|
||||||
#define TU I8
|
#define TU I8
|
||||||
#define TP(W,X) W##i8##X
|
#define TP(W,X) W##i8##X
|
||||||
#include "tyarrTemplate.h"
|
#include "tyarrTemplate.h"
|
||||||
@ -15,6 +24,11 @@
|
|||||||
#define TU F64
|
#define TU F64
|
||||||
#define TP(W,X) W##f64##X
|
#define TP(W,X) W##f64##X
|
||||||
#include "tyarrTemplate.h"
|
#include "tyarrTemplate.h"
|
||||||
|
#define I8Arr TyArr
|
||||||
|
#define I16Arr TyArr
|
||||||
|
#define I32Arr TyArr
|
||||||
|
#define F64Arr TyArr
|
||||||
|
#define BitArr TyArr
|
||||||
|
|
||||||
// bit array stuff
|
// bit array stuff
|
||||||
#define BIT_N(IA) (((IA)+63) >> 6) // u64 count needed to store IA bits
|
#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
|
// BitArr
|
||||||
typedef struct BitArr {
|
|
||||||
struct Arr;
|
|
||||||
u64 a[];
|
|
||||||
} BitArr;
|
|
||||||
#define BITARR_SZ(IA) fsizeof(BitArr, a, u64, BIT_N(IA))
|
#define BITARR_SZ(IA) fsizeof(BitArr, a, u64, BIT_N(IA))
|
||||||
static B m_bitarrv(u64** p, usz ia) {
|
static B m_bitarrv(u64** p, usz ia) {
|
||||||
BitArr* r = m_arr(BITARR_SZ(ia), t_bitarr, ia);
|
BitArr* r = m_arr(BITARR_SZ(ia), t_bitarr, ia);
|
||||||
arr_shVec((Arr*)r);
|
arr_shVec((Arr*)r);
|
||||||
*p = r->a;
|
*p = (u64*)r->a;
|
||||||
return taga(r);
|
return taga(r);
|
||||||
}
|
}
|
||||||
static B m_bitarrc(u64** p, B x) { assert(isArr(x));
|
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);
|
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);
|
arr_shCopy((Arr*)r, x);
|
||||||
return taga(r);
|
return taga(r);
|
||||||
}
|
}
|
||||||
static Arr* m_bitarrp(u64** p, usz ia) {
|
static Arr* m_bitarrp(u64** p, usz ia) {
|
||||||
BitArr* r = m_arr(BITARR_SZ(ia), t_bitarr, ia);
|
BitArr* r = m_arr(BITARR_SZ(ia), t_bitarr, ia);
|
||||||
*p = r->a;
|
*p = (u64*)r->a;
|
||||||
return (Arr*)r;
|
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
|
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
|
// 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 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; })
|
#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;
|
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 bool bitarr_canStore(B x) { return q_bit(x); }
|
||||||
|
|
||||||
static void bitarr_init() {
|
static void bitarr_init() {
|
||||||
|
|||||||
@ -1,20 +1,18 @@
|
|||||||
#define T_ARR TP(t_,arr)
|
#define T_ARR TP(t_,arr)
|
||||||
#define T_SLICE TP(t_,slice)
|
#define T_SLICE TP(t_,slice)
|
||||||
#define TArr JOIN(TU,Arr)
|
|
||||||
#define TSlice JOIN(TU,Slice)
|
|
||||||
#define TEl JOIN(TU,Atom)
|
#define TEl JOIN(TU,Atom)
|
||||||
|
|
||||||
static Arr* TP(m_,slice) (Arr* p, TEl* ptr, usz ia) {
|
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->p = p;
|
||||||
r->a = ptr;
|
r->a = ptr;
|
||||||
return (Arr*)r;
|
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(,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, c(TSlice,x)->a+s, ia); dec(x); return r; }
|
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(,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_,) (((TSlice*)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 bool TP(,arr_canStore) (B x) { return TP(q_,) (x); }
|
||||||
|
|
||||||
static void TP(,arr_init)() {
|
static void TP(,arr_init)() {
|
||||||
@ -32,7 +30,5 @@ static void TP(,arr_init)() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#undef TEl
|
#undef TEl
|
||||||
#undef TSlice
|
|
||||||
#undef TArr
|
|
||||||
#undef TU
|
#undef TU
|
||||||
#undef TP
|
#undef TP
|
||||||
|
|||||||
@ -1,42 +1,29 @@
|
|||||||
#define T_ARR TP(t_,arr)
|
#define T_ARR TP(t_,arr)
|
||||||
#define T_SLICE TP(t_,slice)
|
#define T_SLICE TP(t_,slice)
|
||||||
#define TArr JOIN(TU,Arr)
|
|
||||||
#define TSlice JOIN(TU,Slice)
|
|
||||||
#define TEl JOIN(TU,Atom)
|
#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) {
|
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);
|
arr_shVec((Arr*)r);
|
||||||
*p = r->a;
|
*p = (TEl*)r->a;
|
||||||
return taga(r);
|
return taga(r);
|
||||||
}
|
}
|
||||||
static B TP(m_,arrc) (TEl** p, B x) { assert(isArr(x));
|
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);
|
TyArr* r = m_arr(TYARR_SZ2(TU,a(x)->ia), T_ARR, a(x)->ia);
|
||||||
*p = r->a;
|
*p = (TEl*)r->a;
|
||||||
arr_shCopy((Arr*)r, x);
|
arr_shCopy((Arr*)r, x);
|
||||||
return taga(r);
|
return taga(r);
|
||||||
}
|
}
|
||||||
static Arr* TP(m_,arrp) (TEl** p, usz ia) {
|
static Arr* TP(m_,arrp) (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);
|
||||||
*p = r->a;
|
*p = (TEl*)r->a;
|
||||||
return (Arr*)r;
|
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(,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 c(TArr,x)->a; assert(t==T_SLICE); return c(TSlice,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 TEl
|
||||||
#undef TSlice
|
|
||||||
#undef TArr
|
|
||||||
#undef TU
|
#undef TU
|
||||||
#undef TP
|
#undef TP
|
||||||
|
|||||||
@ -50,25 +50,7 @@ FN_LUT(avx2, ge, AA)
|
|||||||
|
|
||||||
static void* tyany_ptr(B x) {
|
static void* tyany_ptr(B x) {
|
||||||
u8 t = v(x)->type;
|
u8 t = v(x)->type;
|
||||||
if (IS_SLICE(t)) switch (t) { default: UD;
|
return IS_SLICE(t)? c(TySlice,x)->a : c(TyArr,x)->a;
|
||||||
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;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#define AL(X) u64* rp; B r = m_bitarrc(&rp, X); usz ria=a(r)->ia;
|
#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
|
#endif
|
||||||
switch(n) { default: UD;
|
switch(n) { default: UD;
|
||||||
case el_bit: { BitArr* t=cpyBitArr(taga(m->val)); m->val=(Arr*)t; m->abit=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->ai8 =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->ai16=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->ai32=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->ac8 =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->ac16=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->ac32=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->af64=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->aB =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;
|
usz ia;
|
||||||
Arr* val;
|
Arr* val;
|
||||||
union {
|
union {
|
||||||
|
void* a; B* aB;
|
||||||
i8* ai8; i16* ai16; i32* ai32;
|
i8* ai8; i16* ai16; i32* ai32;
|
||||||
u8* ac8; u16* ac16; u32* ac32;
|
u8* ac8; u16* ac16; u32* ac32;
|
||||||
f64* af64; u64* abit; B* aB;
|
f64* af64; u64* abit;
|
||||||
};
|
};
|
||||||
} Mut;
|
} Mut;
|
||||||
#define MAKE_MUT(N, IA) Mut N##_val; N##_val.type = el_MAX; N##_val.ia = (IA); Mut* N = &N##_val;
|
#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);
|
Arr* a = m_arr(sz, ty, ia);
|
||||||
m->val = a;
|
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
|
m->a = ((TyArr*)a)->a;
|
||||||
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;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
void mut_to(Mut* m, u8 n);
|
void mut_to(Mut* m, u8 n);
|
||||||
|
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user