more consistent type checking & conversion functions
This commit is contained in:
parent
734e9fc116
commit
59e947cc20
@ -83,19 +83,25 @@ Functions for converting/using basic types:
|
||||
m_c32(x) // codepoint → B
|
||||
m_i32(x) // i32 → B
|
||||
m_usz(x) // usz → B
|
||||
o2i(x) // B → i32, throw if impossible
|
||||
o2i64(x) // B → i64, throw if impossible
|
||||
o2u64(x) // B → u64, throw if impossible
|
||||
o2s(x) // B → usz, throw if impossible
|
||||
o2c(x) // B → c32, throw if impossible
|
||||
o2f(x) // B → f64, throw if impossible
|
||||
o2iu(x) // B → i32, assumes is valid (u ≡ unchecked)
|
||||
o2i64u(x) // B → i64, assumes is valid
|
||||
o2su(x) // B → usz, assumes is valid
|
||||
o2cu(x) // B → c32, assumes is valid
|
||||
o2fu(x) // B → f64, assumes is valid
|
||||
o2b(x) // B → bool, throw if impossible
|
||||
q_TYPE(x) // query if x is convertible to TYPE (see definitions in h.h)
|
||||
|
||||
// convert B to a basic type (first one errors on invalid, second assumes the conversion is doable losslessly):
|
||||
o2b(x) o2bG(x) // bool
|
||||
o2i(x) o2iG(x) // i32
|
||||
o2c(x) o2cG(x) // c32
|
||||
o2s(x) o2sG(x) // usz
|
||||
o2f(x) o2fG(x) // f64
|
||||
o2i64(x) o2i64G(x) // i64
|
||||
o2u64(x) o2u64G(x) // u64
|
||||
|
||||
// test if f64 or B fit in a specified type:
|
||||
q_fbit(x) q_bit(x)
|
||||
q_fi8(x) q_i8(x)
|
||||
q_fi16(x) q_i16(x)
|
||||
q_fi32(x) q_i32(x)
|
||||
q_fi64(x) q_i64(x)
|
||||
q_fu64(x) q_u64(x)
|
||||
q_fusz(x) q_usz(x)
|
||||
|
||||
q_N(x) // query if x is · (≡ bi_N)
|
||||
noFill(x) // if x represents undefined fill (returned by getFill*; ≡ bi_noFill)
|
||||
tag(x,*_TAG) // pointer → B
|
||||
|
||||
@ -124,15 +124,15 @@ B floor_c2(B, B, B);
|
||||
|
||||
#define REG_SA(NAME, EXPR) \
|
||||
if (xe==el_bit) return bit_sel1Fn(NAME##_c2,w,x,1); \
|
||||
if (xe==el_i8 && q_i8 (w)) { PI8 (x) i8 wc=o2iu(w); DOI8 (EXPR,x,wc,xp[i],sa8B ) } sa8B :; \
|
||||
if (xe==el_i16 && q_i16(w)) { PI16(x) i16 wc=o2iu(w); DOI16(EXPR,x,wc,xp[i],sa16B) } sa16B:; \
|
||||
if (xe==el_i32 && q_i32(w)) { PI32(x) i32 wc=o2iu(w); DOI32(EXPR,x,wc,xp[i],sa32B) } sa32B:; \
|
||||
if (xe==el_i8 && q_i8 (w)) { PI8 (x) i8 wc=o2iG(w); DOI8 (EXPR,x,wc,xp[i],sa8B ) } sa8B :; \
|
||||
if (xe==el_i16 && q_i16(w)) { PI16(x) i16 wc=o2iG(w); DOI16(EXPR,x,wc,xp[i],sa16B) } sa16B:; \
|
||||
if (xe==el_i32 && q_i32(w)) { PI32(x) i32 wc=o2iG(w); DOI32(EXPR,x,wc,xp[i],sa32B) } sa32B:; \
|
||||
if (xe==el_f64) { Rf64(x) PF(x) DOF(EXPR,w,w.f,xp[i]) goto dec_ret; }
|
||||
#define REG_AS(NAME, EXPR) \
|
||||
if (we==el_bit) return bit_sel1Fn(NAME##_c2,w,x,0); \
|
||||
if (we==el_i8 && q_i8 (x)) { PI8 (w) i8 xc=o2iu(x); DOI8 (EXPR,w,wp[i],xc,as8B ) } as8B :; \
|
||||
if (we==el_i16 && q_i16(x)) { PI16(w) i16 xc=o2iu(x); DOI16(EXPR,w,wp[i],xc,as16B) } as16B:; \
|
||||
if (we==el_i32 && q_i32(x)) { PI32(w) i32 xc=o2iu(x); DOI32(EXPR,w,wp[i],xc,as32B) } as32B:; \
|
||||
if (we==el_i8 && q_i8 (x)) { PI8 (w) i8 xc=o2iG(x); DOI8 (EXPR,w,wp[i],xc,as8B ) } as8B :; \
|
||||
if (we==el_i16 && q_i16(x)) { PI16(w) i16 xc=o2iG(x); DOI16(EXPR,w,wp[i],xc,as16B) } as16B:; \
|
||||
if (we==el_i32 && q_i32(x)) { PI32(w) i32 xc=o2iG(x); DOI32(EXPR,w,wp[i],xc,as32B) } as32B:; \
|
||||
if (we==el_f64) { Rf64(w) PF(w) DOF(EXPR,x,wp[i],x.f) goto dec_ret; }
|
||||
|
||||
static B bitAA0(B w, B x, usz ia) { UD; }
|
||||
@ -243,7 +243,7 @@ B floor_c2(B, B, B);
|
||||
AR_I_SA("⌈", ceil , wv>xv?wv:xv, REG_SA, {})
|
||||
AR_I_SA("+", add, wv+xv, SI_SA, {
|
||||
if (isC32(w) && xe==el_i32) {
|
||||
u32 wv = o2cu(w);
|
||||
u32 wv = o2cG(w);
|
||||
i32* xp = i32any_ptr(x); usz xia = IA(x);
|
||||
u32* rp; r = m_c32arrc(&rp, x);
|
||||
for (usz i = 0; i < xia; i++) {
|
||||
@ -258,7 +258,7 @@ B floor_c2(B, B, B);
|
||||
|
||||
AR_I_AS("-", sub, wv-xv, SI_AS, {
|
||||
if (we==el_c32 && isC32(x)) {
|
||||
i32 xv = (i32)o2cu(x);
|
||||
i32 xv = (i32)o2cG(x);
|
||||
u32* wp = c32any_ptr(w); usz wia = IA(w);
|
||||
i32* rp; r = m_i32arrc(&rp, w);
|
||||
for (usz i = 0; i < wia; i++) rp[i] = (i32)wp[i] - xv;
|
||||
@ -297,11 +297,11 @@ B floor_c2(B, B, B);
|
||||
}
|
||||
|
||||
AR_I_SCALAR("+", add, w.f+x.f, {
|
||||
if (isC32(w) & isF64(x)) { u64 r = (u64)(o2cu(w)+o2i64(x)); if(r>CHR_MAX)thrM("+: Invalid character"); return m_c32((u32)r); }
|
||||
if (isF64(w) & isC32(x)) { u64 r = (u64)(o2cu(x)+o2i64(w)); if(r>CHR_MAX)thrM("+: Invalid character"); return m_c32((u32)r); }
|
||||
if (isC32(w) & isF64(x)) { u64 r = (u64)(o2cG(w)+o2i64(x)); if(r>CHR_MAX)thrM("+: Invalid character"); return m_c32((u32)r); }
|
||||
if (isF64(w) & isC32(x)) { u64 r = (u64)(o2cG(x)+o2i64(w)); if(r>CHR_MAX)thrM("+: Invalid character"); return m_c32((u32)r); }
|
||||
});
|
||||
AR_I_SCALAR("-", sub, w.f-x.f, {
|
||||
if (isC32(w) & isF64(x)) { u64 r = (u64)((i32)o2cu(w)-o2i64(x)); if(r>CHR_MAX)thrM("-: Invalid character"); return m_c32((u32)r); }
|
||||
if (isC32(w) & isF64(x)) { u64 r = (u64)((i32)o2cG(w)-o2i64(x)); if(r>CHR_MAX)thrM("-: Invalid character"); return m_c32((u32)r); }
|
||||
if (isC32(w) & isC32(x)) return m_f64((i32)(u32)w.u - (i32)(u32)x.u);
|
||||
})
|
||||
AR_I_SCALAR("×", mul, w.f*x.f, {})
|
||||
|
||||
@ -80,13 +80,13 @@ CMP_AA("≠", "?", ne, !=, wv^xv, swapped=0;)
|
||||
u8 xe = TI(x, elType); if (xe==el_B) goto bad; AL(x) \
|
||||
switch(xe) { default: UD; \
|
||||
case el_bit: { if (!q_bit(w)) break; u64 wv=bitx(w); u64* xp=bitarr_ptr(x); for(usz i=0;i<bia;i++) { u64 xv=xp[i]; rp[i]=BX; } decG(x); return r; } \
|
||||
case el_i8: { if (!q_i8 (w)) break; i8 wv=o2iu(w); i8* xp=i8any_ptr (x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_i16: { if (!q_i16(w)) break; i16 wv=o2iu(w); i16* xp=i16any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_i32: { if (!q_i32(w)) break; i32 wv=o2iu(w); i32* xp=i32any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_c8: { if (!q_c8 (w)) break; u8 wv=o2cu(w); u8* xp=c8any_ptr (x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_c16: { if (!q_c16(w)) break; u16 wv=o2cu(w); u16* xp=c16any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_c32: { if (!q_c32(w)) break; u32 wv=o2cu(w); u32* xp=c32any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_f64: { if (!q_f64(w)) break; f64 wv=o2fu(w); f64* xp=f64any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_i8: { if (!q_i8 (w)) break; i8 wv=o2iG(w); i8* xp=i8any_ptr (x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_i16: { if (!q_i16(w)) break; i16 wv=o2iG(w); i16* xp=i16any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_i32: { if (!q_i32(w)) break; i32 wv=o2iG(w); i32* xp=i32any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_c8: { if (!q_c8 (w)) break; u8 wv=o2cG(w); u8* xp=c8any_ptr (x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_c16: { if (!q_c16(w)) break; u16 wv=o2cG(w); u16* xp=c16any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_c32: { if (!q_c32(w)) break; u32 wv=o2cG(w); u32* xp=c32any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
case el_f64: { if (!q_f64(w)) break; f64 wv=o2fG(w); f64* xp=f64any_ptr(x); for(usz i=0;i<ria;i++) bitp_set(rp,i,wv OP xp[i]); decG(x); return r; } \
|
||||
} \
|
||||
decG(r); \
|
||||
bad: return NAME##_rec(swapped, w, x); \
|
||||
|
||||
@ -204,7 +204,7 @@ B indexOf_c2(B t, B w, B x) {
|
||||
if (TI(w,elType)==el_i32) {
|
||||
if (q_i32(el)) {
|
||||
i32* wp = i32any_ptr(w);
|
||||
i32 v = o2iu(el);
|
||||
i32 v = o2iG(el);
|
||||
for (usz i = 0; i < wia; i++) {
|
||||
if (wp[i] == v) { res = i; break; }
|
||||
}
|
||||
|
||||
@ -124,7 +124,7 @@ B listVariations_c2(B t, B w, B x) {
|
||||
if (xe!=el_c8) for (usz i = 0; i < xia; i++) {
|
||||
B c = GetU(x, i);
|
||||
if (!isC32(c)) goto noSpec;
|
||||
if (o2cu(c)>max) max = o2cu(c);
|
||||
if (o2cG(c)>max) max = o2cG(c);
|
||||
}
|
||||
ac8 = max == (u8 )max;
|
||||
ac16 = max == (u16)max;
|
||||
|
||||
@ -236,7 +236,7 @@ B scan_c2(Md1D* d, B w, B x) { B f = d->f;
|
||||
u8 xe = TI(x,elType);
|
||||
if (xr==1 && q_i32(w) && elInt(xe) && isFun(f) && v(f)->flags) {
|
||||
u8 rtid = v(f)->flags-1;
|
||||
i32 wv = o2iu(w);
|
||||
i32 wv = o2iG(w);
|
||||
if (xe==el_bit) {
|
||||
u64* xp=bitarr_ptr(x);
|
||||
if (rtid==n_add) { i32* rp; B r=m_i32arrv(&rp, ia); i64 c=wv; for (usz i=0; i<ia; i++) { c+= bitp_get(xp,i); rp[i]=c; } decG(x); return r; }
|
||||
@ -366,7 +366,7 @@ B fold_c2(Md1D* d, B w, B x) { B f = d->f;
|
||||
usz ia = IA(x);
|
||||
u8 xe = TI(x,elType);
|
||||
if (q_i32(w) && isFun(f) && v(f)->flags && elInt(xe)) {
|
||||
i32 wi = o2iu(w);
|
||||
i32 wi = o2iG(w);
|
||||
u8 rtid = v(f)->flags-1;
|
||||
if (xe==el_bit) {
|
||||
u64* xp = bitarr_ptr(x);
|
||||
|
||||
@ -77,7 +77,7 @@ B repeat_replace(B g, B* q) { // doesn't consume
|
||||
for (usz i = 0; i < ia; i++) HARR_ADD(r, i, repeat_replace(GetU(g,i), q));
|
||||
return HARR_FC(r, g);
|
||||
} else {
|
||||
return inc(q[o2i64u(g)]);
|
||||
return inc(q[o2i64G(g)]);
|
||||
}
|
||||
}
|
||||
#define REPEAT_T(CN, END, ...) \
|
||||
@ -281,7 +281,7 @@ B rank_c1(Md2D* d, B x) { B f = d->f; B g = d->g;
|
||||
bool gf = isFun(g);
|
||||
if (RARE(gf)) g = c1(g, inc(x));
|
||||
if (LIKELY(isNum(g))) {
|
||||
kf = req_whole(o2fu(g));
|
||||
kf = req_whole(o2fG(g));
|
||||
} else {
|
||||
usz gia = check_rank_vec(g);
|
||||
SGetU(g); kf = GetU(g, gia==2).f;
|
||||
@ -344,7 +344,7 @@ B rank_c2(Md2D* d, B w, B x) { B f = d->f; B g = d->g;
|
||||
bool gf = isFun(g);
|
||||
if (RARE(gf)) g = c2(g, inc(w), inc(x));
|
||||
if (LIKELY(isNum(g))) {
|
||||
wf = xf = req_whole(o2fu(g));
|
||||
wf = xf = req_whole(o2fG(g));
|
||||
} else {
|
||||
usz gia = check_rank_vec(g);
|
||||
SGetU(g);
|
||||
|
||||
@ -316,7 +316,7 @@ B select_ucw(B t, B o, B w, B x) {
|
||||
mut_copyG(r, 0, x, 0, xia);
|
||||
SGet(rep)
|
||||
for (usz i = 0; i < wia; i++) {
|
||||
i64 cw = o2i64u(GetU(w, i)); if (RARE(cw<0)) cw+= (i64)xia;
|
||||
i64 cw = o2i64G(GetU(w, i)); if (RARE(cw<0)) cw+= (i64)xia;
|
||||
B cr = Get(rep, i);
|
||||
EQ(!equal(mut_getU(r, cw), cr));
|
||||
mut_rm(r, cw);
|
||||
|
||||
@ -30,7 +30,7 @@ B m_vec1(B a) {
|
||||
else { i32* rp; B r = m_i32arrv(&rp, 1); rp[0] = i; return r; }
|
||||
}
|
||||
if (isC32(a)) {
|
||||
u32 c = o2cu(a);
|
||||
u32 c = o2cG(a);
|
||||
if (LIKELY(c<U8_MAX )) { u8* rp; B r = m_c8arrv (&rp, 1); rp[0] = c; return r; }
|
||||
else if (LIKELY(c<U16_MAX)) { u16* rp; B r = m_c16arrv(&rp, 1); rp[0] = c; return r; }
|
||||
else { u32* rp; B r = m_c32arrv(&rp, 1); rp[0] = c; return r; }
|
||||
@ -46,14 +46,14 @@ FORCE_INLINE B m_vec2Base(B a, B b, bool fills) {
|
||||
if (isAtm(a)&isAtm(b)) {
|
||||
if (LIKELY(isNum(a)&isNum(b))) {
|
||||
i32 ai=a.f; i32 bi=b.f;
|
||||
if (RARE(ai!=a.f | bi!=b.f)) { f64* rp; B r = m_f64arrv(&rp, 2); rp[0]=o2fu(a); rp[1]=o2fu(b); return r; }
|
||||
if (RARE(ai!=a.f | bi!=b.f)) { f64* rp; B r = m_f64arrv(&rp, 2); rp[0]=o2fG(a); rp[1]=o2fG(b); return r; }
|
||||
else if (q_ibit(ai) & q_ibit(bi)) { u64* rp; B r = m_bitarrv(&rp, 2); rp[0]=ai | (bi<<1); return r; }
|
||||
else if (ai==(i8 )ai & bi==(i8 )bi) { i8* rp; B r = m_i8arrv (&rp, 2); rp[0]=ai; rp[1]=bi; return r; }
|
||||
else if (ai==(i16)ai & bi==(i16)bi) { i16* rp; B r = m_i16arrv(&rp, 2); rp[0]=ai; rp[1]=bi; return r; }
|
||||
else { i32* rp; B r = m_i32arrv(&rp, 2); rp[0]=ai; rp[1]=bi; return r; }
|
||||
}
|
||||
if (isC32(b)&isC32(a)) {
|
||||
u32 ac=o2cu(a); u32 bc=o2cu(b);
|
||||
u32 ac=o2cG(a); u32 bc=o2cG(b);
|
||||
if (ac==(u8 )ac & bc==(u8 )bc) { u8* rp; B r = m_c8arrv (&rp, 2); rp[0]=ac; rp[1]=bc; return r; }
|
||||
else if (ac==(u16)ac & bc==(u16)bc) { u16* rp; B r = m_c16arrv(&rp, 2); rp[0]=ac; rp[1]=bc; return r; }
|
||||
else { u32* rp; B r = m_c32arrv(&rp, 2); rp[0]=ac; rp[1]=bc; return r; }
|
||||
@ -228,7 +228,7 @@ B shape_c2(B t, B w, B x) {
|
||||
}
|
||||
if (isC32(x)) { decA(xf);
|
||||
u32* rp; Arr* r = m_c32arrp(&rp, nia); arr_shSetU(r, nr, sh);
|
||||
u32 c = o2cu(x);
|
||||
u32 c = o2cG(x);
|
||||
for (u64 i = 0; i < nia; i++) rp[i] = c;
|
||||
return taga(r);
|
||||
}
|
||||
@ -798,10 +798,10 @@ B slash_im(B t, B x) {
|
||||
usz ria = max+1;
|
||||
if (i==xia) {
|
||||
u64* rp; r = m_bitarrv(&rp, ria); for (usz i=0; i<BIT_N(ria); i++) rp[i]=0;
|
||||
for (usz i = 0; i < xia; i++) bitp_set(rp, o2i64u(xp[i]), 1);
|
||||
for (usz i = 0; i < xia; i++) bitp_set(rp, o2i64G(xp[i]), 1);
|
||||
} else {
|
||||
i32* rp; r = m_i32arrv(&rp, ria); for (usz i=0; i<ria; i++) rp[i]=0;
|
||||
for (usz i = 0; i < xia; i++) rp[o2i64u(xp[i])]++;
|
||||
for (usz i = 0; i < xia; i++) rp[o2i64G(xp[i])]++;
|
||||
}
|
||||
decG(x); return r;
|
||||
}
|
||||
@ -1374,7 +1374,7 @@ B group_c2(B t, B w, B x) {
|
||||
for (usz i = 0; i < xia; i++) {
|
||||
B cw = GetU(w, i);
|
||||
if (!q_i64(cw)) goto base;
|
||||
i64 c = o2i64u(cw);
|
||||
i64 c = o2i64G(cw);
|
||||
if (c>ria) ria = c;
|
||||
if (c<-1) thrM("⊔: 𝕨 can't contain elements less than ¯1");
|
||||
}
|
||||
@ -1383,7 +1383,7 @@ B group_c2(B t, B w, B x) {
|
||||
TALLOC(i32, lenO, ria+1); i32* len = lenO+1;
|
||||
TALLOC(i32, pos, ria);
|
||||
for (usz i = 0; i < ria; i++) len[i] = pos[i] = 0;
|
||||
for (usz i = 0; i < xia; i++) len[o2i64u(GetU(w, i))]++;
|
||||
for (usz i = 0; i < xia; i++) len[o2i64G(GetU(w, i))]++;
|
||||
|
||||
Arr* r = arr_shVec(m_fillarrp(ria)); fillarr_setFill(r, m_f64(0));
|
||||
B* rp = fillarr_ptr(r);
|
||||
@ -1402,7 +1402,7 @@ B group_c2(B t, B w, B x) {
|
||||
fillarr_setFill(r, taga(rf));
|
||||
SGet(x)
|
||||
for (usz i = 0; i < xia; i++) {
|
||||
i64 n = o2i64u(GetU(w, i));
|
||||
i64 n = o2i64G(GetU(w, i));
|
||||
if (n>=0) fillarr_ptr(a(rp[n]))[pos[n]++] = Get(x, i);
|
||||
}
|
||||
for (usz i = 0; i < ria; i++) a(rp[i])->ia = len[i];
|
||||
@ -1547,10 +1547,10 @@ B pick_ucw(B t, B o, B w, B x) {
|
||||
B arg = IGet(x, wi);
|
||||
B rep = c1(o, arg);
|
||||
if (reusable(x) && TI(x,canStore)(rep)) { REUSE(x);
|
||||
if (TI(x,elType)==el_i8 ) { i8* xp = i8any_ptr (x); xp[wi] = o2iu(rep); return x; }
|
||||
else if (TI(x,elType)==el_i16) { i16* xp = i16any_ptr(x); xp[wi] = o2iu(rep); return x; }
|
||||
else if (TI(x,elType)==el_i32) { i32* xp = i32any_ptr(x); xp[wi] = o2iu(rep); return x; }
|
||||
else if (TI(x,elType)==el_f64) { f64* xp = f64any_ptr(x); xp[wi] = o2fu(rep); return x; }
|
||||
if (TI(x,elType)==el_i8 ) { i8* xp = i8any_ptr (x); xp[wi] = o2iG(rep); return x; }
|
||||
else if (TI(x,elType)==el_i16) { i16* xp = i16any_ptr(x); xp[wi] = o2iG(rep); return x; }
|
||||
else if (TI(x,elType)==el_i32) { i32* xp = i32any_ptr(x); xp[wi] = o2iG(rep); return x; }
|
||||
else if (TI(x,elType)==el_f64) { f64* xp = f64any_ptr(x); xp[wi] = o2fG(rep); return x; }
|
||||
else if (TY(x)==t_harr) {
|
||||
B* xp = harr_ptr(x);
|
||||
dec(xp[wi]);
|
||||
@ -1607,7 +1607,7 @@ B slash_ucw(B t, B o, B w, B x) {
|
||||
SGetU(rep)
|
||||
MUTG_INIT(r);
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
i32 cw = o2iu(GetU(w, i));
|
||||
i32 cw = o2iG(GetU(w, i));
|
||||
if (cw) {
|
||||
B cr = Get(rep,repI);
|
||||
if (CHECK_VALID) for (i32 j = 1; j < cw; j++) if (!equal(GetU(rep,repI+j), cr)) { mut_pfree(r,i); thrM("𝔽⌾(a⊸/): Incompatible result elements"); }
|
||||
|
||||
@ -20,7 +20,7 @@ NOINLINE B num_squeezeF(B x, usz ia) {
|
||||
a = (Arr*) cpyF64Arr(x);
|
||||
goto retn;
|
||||
}
|
||||
i32 c = o2iu(cr);
|
||||
i32 c = o2iG(cr);
|
||||
or|= ((u32)c & ~1) ^ (u32)(c>>31);
|
||||
}
|
||||
a = or==0? (Arr*)cpyBitArr(x)
|
||||
@ -80,7 +80,7 @@ B num_squeeze(B x) {
|
||||
while (i<ia) if (!isF64(xp[i++])) goto r_x;
|
||||
goto r_f64;
|
||||
}
|
||||
i32 c = o2iu(xp[i]);
|
||||
i32 c = o2iG(xp[i]);
|
||||
or|= ((u32)c & ~1) ^ (u32)(c>>31);
|
||||
}
|
||||
goto mostI32;
|
||||
@ -148,7 +148,7 @@ B chr_squeeze(B x) {
|
||||
#else
|
||||
for (; i < ia; i++) {
|
||||
if (!isC32(xp[i])) goto r_x;
|
||||
or|= o2cu(xp[i]);
|
||||
or|= o2cG(xp[i]);
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
@ -156,7 +156,7 @@ B chr_squeeze(B x) {
|
||||
for (; i < ia; i++) {
|
||||
B cr = GetU(x,i);
|
||||
if (!isC32(cr)) goto r_x;
|
||||
or|= o2cu(cr);
|
||||
or|= o2cG(cr);
|
||||
}
|
||||
}
|
||||
if (or<=U8_MAX ) r_c8: return FL_SET(toC8Any(x), fl_squoze);
|
||||
|
||||
@ -123,7 +123,7 @@ B grLen_both(i64 ria, B x) {
|
||||
usz ia = IA(x);
|
||||
SGetU(x)
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
i64 c = o2i64u(GetU(x, i));
|
||||
i64 c = o2i64G(GetU(x, i));
|
||||
if (c>ria) ria = c;
|
||||
}
|
||||
if (ria > (i64)(USZ_MAX-1)) thrOOM();
|
||||
@ -133,7 +133,7 @@ B grLen_both(i64 ria, B x) {
|
||||
u64* rp; r = m_bitarrv(&rp, ria);
|
||||
for (usz i = 0; i < BIT_N(ria); i++) rp[i] = 0;
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
i64 n = o2i64u(GetU(x, i)); assert(n>=-1);
|
||||
i64 n = o2i64G(GetU(x, i)); assert(n>=-1);
|
||||
if (n>=0) {
|
||||
if (bitp_get(rp,n)) { decG(r); goto r_i32; }
|
||||
bitp_set(rp,n,1);
|
||||
@ -145,13 +145,13 @@ B grLen_both(i64 ria, B x) {
|
||||
i32* rp; r = m_i32arrv(&rp, ria);
|
||||
for (usz i = 0; i < ria; i++) rp[i] = 0;
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
i64 n = o2i64u(GetU(x, i)); assert(n>=-1);
|
||||
i64 n = o2i64G(GetU(x, i)); assert(n>=-1);
|
||||
if (n>=0) rp[n]++;
|
||||
}
|
||||
r_r: decG(x); return r;
|
||||
}
|
||||
B grLen_c1(B t, B x) { return grLen_both( -1, x); } // assumes valid arguments
|
||||
B grLen_c2(B t, B w, B x) { return grLen_both(o2i64u(w)-1, x); } // assumes valid arguments
|
||||
B grLen_c2(B t, B w, B x) { return grLen_both(o2i64G(w)-1, x); } // assumes valid arguments
|
||||
|
||||
B grOrd_c2(B t, B w, B x) { // assumes valid arguments
|
||||
usz wia = IA(w);
|
||||
@ -162,8 +162,8 @@ B grOrd_c2(B t, B w, B x) { // assumes valid arguments
|
||||
SGetU(x)
|
||||
TALLOC(usz, tmp, wia);
|
||||
tmp[0] = 0;
|
||||
for (usz i = 1; i < wia; i++) tmp[i] = tmp[i-1]+o2su(GetU(w,i-1));
|
||||
usz ria = tmp[wia-1]+o2su(GetU(w,wia-1));
|
||||
for (usz i = 1; i < wia; i++) tmp[i] = tmp[i-1]+o2sG(GetU(w,i-1));
|
||||
usz ria = tmp[wia-1]+o2sG(GetU(w,wia-1));
|
||||
i32* rp; B r = m_i32arrv(&rp, ria);
|
||||
if (xia>=I32_MAX) thrM("⊔: Too large");
|
||||
for (usz i = 0; i < xia; i++) {
|
||||
@ -175,17 +175,17 @@ B grOrd_c2(B t, B w, B x) { // assumes valid arguments
|
||||
}
|
||||
|
||||
B asrt_c1(B t, B x) {
|
||||
if (LIKELY(isF64(x) && o2fu(x)==1)) return x;
|
||||
if (LIKELY(isF64(x) && o2fG(x)==1)) return x;
|
||||
if (isF64(x)) thrM("Assertion error");
|
||||
thr(x);
|
||||
}
|
||||
B asrt_c2(B t, B w, B x) {
|
||||
if (LIKELY(isF64(x) && o2fu(x)==1)) { dec(w); return x; }
|
||||
if (LIKELY(isF64(x) && o2fG(x)==1)) { dec(w); return x; }
|
||||
dec(x);
|
||||
thr(w);
|
||||
}
|
||||
B casrt_c2(B t, B w, B x) {
|
||||
if (LIKELY(isF64(x) && o2fu(x)==1)) { dec(w); return x; }
|
||||
if (LIKELY(isF64(x) && o2fG(x)==1)) { dec(w); return x; }
|
||||
unwindCompiler();
|
||||
dec(x);
|
||||
if (isArr(w) && IA(w)==2) {
|
||||
@ -216,7 +216,7 @@ B casrt_c2(B t, B w, B x) {
|
||||
thr(w);
|
||||
}
|
||||
B casrt_c1(B t, B x) {
|
||||
if (LIKELY(isF64(x) && o2fu(x)==1)) return x;
|
||||
if (LIKELY(isF64(x) && o2fG(x)==1)) return x;
|
||||
casrt_c2(t, inc(x), x); UD;
|
||||
}
|
||||
|
||||
@ -377,7 +377,7 @@ B rand_range_c2(B t, B w, B x) {
|
||||
default: {
|
||||
usz* sh = arr_shAlloc(r, wia);
|
||||
SGetU(w);
|
||||
for (usz i = 0; i < wia; i++) sh[i] = o2su(GetU(w, i));
|
||||
for (usz i = 0; i < wia; i++) sh[i] = o2sG(GetU(w, i));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@ -835,7 +835,7 @@ B fromUtf8_c1(B t, B x) {
|
||||
for (u64 i = 0; i < ia; i++) {
|
||||
B c = GetU(x,i);
|
||||
if (isC32(c)) {
|
||||
u32 v = o2cu(c);
|
||||
u32 v = o2cG(c);
|
||||
if (v>=256) thrF("•FromUTF8: Argument contained a character with codepoint %i", v);
|
||||
chrs[i] = v;
|
||||
} else {
|
||||
|
||||
@ -182,7 +182,7 @@ NOINLINE B m_atomUnit(B x) {
|
||||
else if (xi==(i16)xi) { i16 v=xi; memcpy(&data, &v, sizeof(v)); t=t_i16arr; }
|
||||
else { i32 v=xi; memcpy(&data, &v, sizeof(v)); t=t_i32arr; }
|
||||
} else if (isC32(x)) {
|
||||
u32 xi = o2cu(x);
|
||||
u32 xi = o2cG(x);
|
||||
if (xi==(u8 )xi) { u8 v=xi; memcpy(&data, &v, sizeof(v)); t=t_c8arr; }
|
||||
else if (xi==(u16)xi) { u16 v=xi; memcpy(&data, &v, sizeof(v)); t=t_c16arr; }
|
||||
else { u32 v=xi; memcpy(&data, &v, sizeof(v)); t=t_c32arr; }
|
||||
|
||||
@ -40,7 +40,7 @@ static inline u64 bitp_l1(u64* arr, u64 ia) { // last u64 of the array, with the
|
||||
return ia&63? arr[ia>>6]|~((1ULL<<(ia&63))-1) : ~0ULL;
|
||||
}
|
||||
static inline u64 bitx(B x) { // repeats the boolean across all 64 bits
|
||||
return o2bu(x)? ~(u64)0 : 0;
|
||||
return o2bG(x)? ~(u64)0 : 0;
|
||||
}
|
||||
|
||||
// BitArr
|
||||
|
||||
@ -597,7 +597,7 @@ bool isPureFn(B x) { // doesn't consume
|
||||
B2B dcf = TI(x,decompose);
|
||||
B xd = dcf(inc(x));
|
||||
B* xdp = harr_ptr(xd);
|
||||
i32 t = o2iu(xdp[0]);
|
||||
i32 t = o2iG(xdp[0]);
|
||||
if (t<2) { decG(xd); return t==0; }
|
||||
usz xdia = IA(xd);
|
||||
for (u64 i = 1; i<xdia; i++) if(!isPureFn(xdp[i])) { decG(xd); return false; }
|
||||
|
||||
@ -200,8 +200,8 @@ void noop_visit(Value* x);
|
||||
#define CMP(W,X) ({ AUTO wt = (W); AUTO xt = (X); (wt>xt?1:0)-(wt<xt?1:0); })
|
||||
NOINLINE i32 compareF(B w, B x);
|
||||
static i32 compare(B w, B x) { // doesn't consume; -1 if w<x, 1 if w>x, 0 if w≡x; 0==compare(NaN,NaN)
|
||||
if (isNum(w) & isNum(x)) return CMP(o2fu(w), o2fu(x));
|
||||
if (isC32(w) & isC32(x)) return CMP(o2cu(w), o2cu(x));
|
||||
if (isNum(w) & isNum(x)) return CMP(o2fG(w), o2fG(x));
|
||||
if (isC32(w) & isC32(x)) return CMP(o2cG(w), o2cG(x));
|
||||
return compareF(w, x);
|
||||
}
|
||||
#undef CMP
|
||||
|
||||
30
src/ffi.c
30
src/ffi.c
@ -35,10 +35,10 @@ static void freeTagged(BQNV v) { }
|
||||
|
||||
#define DIRECT_BQNV 1
|
||||
|
||||
double bqn_toF64 (BQNV v) { double r = o2fu(getB(v)); freeTagged(v); return r; }
|
||||
uint32_t bqn_toChar(BQNV v) { uint32_t r = o2cu(getB(v)); freeTagged(v); return r; }
|
||||
double bqn_readF64 (BQNV v) { return o2fu(getB(v)); }
|
||||
uint32_t bqn_readChar(BQNV v) { return o2cu(getB(v)); }
|
||||
double bqn_toF64 (BQNV v) { double r = o2fG(getB(v)); freeTagged(v); return r; }
|
||||
uint32_t bqn_toChar(BQNV v) { uint32_t r = o2cG(getB(v)); freeTagged(v); return r; }
|
||||
double bqn_readF64 (BQNV v) { return o2fG(getB(v)); }
|
||||
uint32_t bqn_readChar(BQNV v) { return o2cG(getB(v)); }
|
||||
|
||||
void bqn_init() {
|
||||
cbqn_init();
|
||||
@ -222,7 +222,7 @@ typedef struct BQNFFIType {
|
||||
|
||||
B vfyStr(B x, char* name, char* arg);
|
||||
static void printFFIType(FILE* f, B x) {
|
||||
if (isC32(x)) fprintf(f, "%d", o2cu(x));
|
||||
if (isC32(x)) fprintf(f, "%d", o2cG(x));
|
||||
else fprint(f, x);
|
||||
}
|
||||
|
||||
@ -298,7 +298,7 @@ BQNFFIEnt ffi_parseTypeStr(u32** src, bool inPtr) { // parse actual type
|
||||
else thrM("FFI: Bad integer width");
|
||||
ro = m_c32(scty);
|
||||
}
|
||||
parseRepr = !inPtr; myWidth = sty_w[o2cu(ro)];
|
||||
parseRepr = !inPtr; myWidth = sty_w[o2cG(ro)];
|
||||
canRetype = inPtr;
|
||||
break;
|
||||
|
||||
@ -333,7 +333,7 @@ BQNFFIEnt ffi_parseTypeStr(u32** src, bool inPtr) { // parse actual type
|
||||
if (t=='u') if (n!=1 & n!=8 & n!=16 & n!=32) goto badW;
|
||||
if (t=='f') if (n!=64) goto badW;
|
||||
|
||||
if (isC32(ro) && n > myWidth*8) thrF("FFI: Representation wider than the value for \"%S:%c%i\"", sty_names[o2cu(ro)], t, n);
|
||||
if (isC32(ro) && n > myWidth*8) thrF("FFI: Representation wider than the value for \"%S:%c%i\"", sty_names[o2cG(ro)], t, n);
|
||||
// TODO figure out what to do with i32:i32 etc
|
||||
|
||||
B roP = ro;
|
||||
@ -440,7 +440,7 @@ usz genObj(BQNFFIEnt ent, B c, bool anyMut) {
|
||||
// printFFIType(stdout,ent.o); printf(" = "); print(c); printf("\n");
|
||||
usz pos;
|
||||
if (isC32(ent.o)) { // scalar
|
||||
u32 t = o2cu(ent.o);
|
||||
u32 t = o2cG(ent.o);
|
||||
pos = ffiTmpAA(t==0? sizeof(BQNV) : 8);
|
||||
void* ptr = ffiTmpS+pos;
|
||||
f64 f = c.f;
|
||||
@ -466,10 +466,10 @@ usz genObj(BQNFFIEnt ent, B c, bool anyMut) {
|
||||
if (!isC32(e)) thrM("FFI: Complex pointer elements NYI");
|
||||
inc(c);
|
||||
B cG;
|
||||
if (!isArr(c)) thrF("FFI: Expected array corresponding to \"*%S\"", sty_names[o2cu(e)]);
|
||||
if (!isArr(c)) thrF("FFI: Expected array corresponding to \"*%S\"", sty_names[o2cG(e)]);
|
||||
usz ia = IA(c);
|
||||
bool mut = t->a[0].mutPtr;
|
||||
switch(o2cu(e)) { default: thrF("FFI: \"*%S\" argument type NYI", sty_names[o2cu(e)]);
|
||||
switch(o2cG(e)) { default: thrF("FFI: \"*%S\" argument type NYI", sty_names[o2cG(e)]);
|
||||
case sty_i8: cG = mut? taga(cpyI8Arr (c)) : toI8Any (c); break;
|
||||
case sty_i16: cG = mut? taga(cpyI16Arr(c)) : toI16Any(c); break;
|
||||
case sty_i32: cG = mut? taga(cpyI32Arr(c)) : toI32Any(c); break;
|
||||
@ -488,7 +488,7 @@ usz genObj(BQNFFIEnt ent, B c, bool anyMut) {
|
||||
u8 reW = t->a[0].reWidth;
|
||||
if (isC32(o2)) { // scalar:any
|
||||
pos = ffiTmpAA(8);
|
||||
u8 et = o2cu(o2);
|
||||
u8 et = o2cG(o2);
|
||||
u8 etw = sty_w[et]*8;
|
||||
if (!isArr(c)) thrF("FFI: Expected array corresponding to \"%S:%c%i\"", sty_names[et], reT, 1<<reW);
|
||||
if (IA(c) != etw>>reW) thrM("FFI: Bad input array length");
|
||||
@ -532,7 +532,7 @@ B buildObj(BQNFFIEnt ent, bool anyMut, B* objs, usz* objPos) {
|
||||
bool mut = t->a[0].mutPtr;
|
||||
if (mut) {
|
||||
usz ia = IA(f);
|
||||
switch(o2cu(e)) { default: UD;
|
||||
switch(o2cG(e)) { default: UD;
|
||||
case sty_i8: case sty_i16: case sty_i32: case sty_f64: return inc(f);
|
||||
case sty_u8: { u8* tp=tyarr_ptr(f); i16* rp; B r=m_i16arrv(&rp, ia); for (usz i=0; i<ia; i++) rp[i]=tp[i]; return r; }
|
||||
case sty_u16: { u16* tp=tyarr_ptr(f); i32* rp; B r=m_i32arrv(&rp, ia); for (usz i=0; i<ia; i++) rp[i]=tp[i]; return r; }
|
||||
@ -585,13 +585,13 @@ B libffiFn_c2(B t, B w, B x) {
|
||||
bool simpleRes = isC32(ents[0].o);
|
||||
u32 resCType;
|
||||
if (simpleRes) {
|
||||
resCType = o2cu(ents[0].o);
|
||||
resCType = o2cG(ents[0].o);
|
||||
} else {
|
||||
BQNFFIType* t = c(BQNFFIType, ents[0].o);
|
||||
if (t->ty == cty_repr) {
|
||||
B o2 = t->a[0].o;
|
||||
if (!isC32(o2)) thrM("FFI: Unimplemented result type");
|
||||
resCType = o2cu(o2);
|
||||
resCType = o2cG(o2);
|
||||
} else thrM("FFI: Unimplemented result type");
|
||||
}
|
||||
resPos = ffiTmpAA(resCType==sty_a? sizeof(BQNV) : sizeof(ffi_arg)>8? sizeof(ffi_arg) : 8);
|
||||
@ -626,7 +626,7 @@ B libffiFn_c2(B t, B w, B x) {
|
||||
}
|
||||
} else { // cty_repr, scalar:x
|
||||
BQNFFIType* t = c(BQNFFIType, ents[0].o);
|
||||
u8 et = o2cu(t->a[0].o);
|
||||
u8 et = o2cG(t->a[0].o);
|
||||
u8 reT = t->a[0].reType;
|
||||
u8 reW = t->a[0].reWidth;
|
||||
u8 etw = sty_w[et];
|
||||
|
||||
54
src/h.h
54
src/h.h
@ -417,40 +417,32 @@ FORCE_INLINE bool isPrim(B x) { return isCallable(x) && v(x)->flags; }
|
||||
static B m_f64(f64 n) { assert(isF64(b(n))); return b(n); } // assert just to make sure we're actually creating a float
|
||||
static B m_c32(u32 n) { return tagu64(n,C32_TAG); } // TODO check validity?
|
||||
static B m_i32(i32 n) { return m_f64(n); }
|
||||
static B m_usz(usz n) { return n<I32_MAX? m_i32((i32)n) : m_f64(n); }
|
||||
|
||||
static bool o2b (B x) { i32 t=(i32)x.f; if(t!=x.f || t!=0&t!=1)thrM("Expected boolean"); return t; }
|
||||
static bool o2bu (B x) { return (x.u<<1) != 0; }
|
||||
static bool q_bit(B x) { return isNum(x) & (x.f==0 | x.f==1); }
|
||||
static bool q_c8 (B x) { return isC32(x) && ((u32)x.u) == ((u8 )x.u); }
|
||||
static bool q_c16(B x) { return isC32(x) && ((u32)x.u) == ((u16)x.u); }
|
||||
static bool q_c32(B x) { return isC32(x); }
|
||||
static bool q_f64(B x) { return isF64(x); }
|
||||
static B m_usz(usz n) { return m_f64(n); }
|
||||
|
||||
// two integer casts for i8 & i16 because clang on armv8 otherwise skips the sign extending step
|
||||
FORCE_INLINE bool q_fi8 (f64 x) { return x==(f64)(i8 )(i32)x; } static bool q_i8 (B x) { return q_fi8 (x.f); }
|
||||
FORCE_INLINE bool q_fi16(f64 x) { return x==(f64)(i16)(i32)x; } static bool q_i16(B x) { return q_fi16(x.f); }
|
||||
FORCE_INLINE bool q_fi32(f64 x) { return x==(f64)(i32) x; } static bool q_i32(B x) { return q_fi32(x.f); }
|
||||
FORCE_INLINE bool q_fi64(f64 x) { return x==(f64)(i64) x; } static bool q_i64(B x) { return q_fi64(x.f); }
|
||||
FORCE_INLINE bool q_fu64(f64 x) { return x==(f64)(u64) x; } static bool q_u64(B x) { return q_fu64(x.f); }
|
||||
FORCE_INLINE bool q_fusz(f64 x) { return x==(f64)(usz) x; } static bool q_usz(B x) { return q_fusz(x.f); }
|
||||
static bool q_ibit(i64 x) { return x==0 | x==1; }
|
||||
static bool q_ubit(u64 x) { return x==0 | x==1; }
|
||||
static bool q_fbit(f64 x) { return x==0 | x==1; }
|
||||
FORCE_INLINE bool q_fbit(f64 x) { return x==0 | x==1; } FORCE_INLINE bool q_bit(B x) { return isNum(x) & (x.f==0 | x.f==1); }
|
||||
FORCE_INLINE bool q_fi8 (f64 x) { return x==(f64)(i8 )(i32)x; } FORCE_INLINE bool q_i8 (B x) { return q_fi8 (x.f); }
|
||||
FORCE_INLINE bool q_fi16(f64 x) { return x==(f64)(i16)(i32)x; } FORCE_INLINE bool q_i16(B x) { return q_fi16(x.f); }
|
||||
FORCE_INLINE bool q_fi32(f64 x) { return x==(f64)(i32) x; } FORCE_INLINE bool q_i32(B x) { return q_fi32(x.f); }
|
||||
FORCE_INLINE bool q_fi64(f64 x) { return x==(f64)(i64) x; } FORCE_INLINE bool q_i64(B x) { return q_fi64(x.f); }
|
||||
FORCE_INLINE bool q_fu64(f64 x) { return x==(f64)(u64) x; } FORCE_INLINE bool q_u64(B x) { return q_fu64(x.f); }
|
||||
FORCE_INLINE bool q_fusz(f64 x) { return x==(f64)(usz) x; } FORCE_INLINE bool q_usz(B x) { return q_fusz(x.f); }
|
||||
/*no need for a q_ff64*/ FORCE_INLINE bool q_f64(B x) { return isF64(x); }
|
||||
FORCE_INLINE bool q_ibit(i64 x) { return x==0 | x==1; }
|
||||
FORCE_INLINE bool q_ubit(u64 x) { return x==0 | x==1; }
|
||||
FORCE_INLINE bool q_c8 (B x) { return x.u>>8 == ((u64)C32_TAG)<<40; }
|
||||
FORCE_INLINE bool q_c16(B x) { return x.u>>16 == ((u64)C32_TAG)<<32; }
|
||||
FORCE_INLINE bool q_c32(B x) { return isC32(x); }
|
||||
FORCE_INLINE bool q_N (B x) { return x.u==bi_N.u; } // is ·
|
||||
FORCE_INLINE bool noFill(B x) { return x.u==bi_noFill.u; }
|
||||
|
||||
static bool q_N (B x) { return x.u==bi_N.u; } // is ·
|
||||
static bool noFill(B x) { return x.u==bi_noFill.u; }
|
||||
static i32 o2i (B x) { if (!q_i32(x)) thrM("Expected integer"); return (i32)x.f; } // i have no clue whether these consume or not, but it doesn't matter
|
||||
static usz o2s (B x) { if (!q_usz(x)) thrM("Expected non-negative integer"); return (usz)x.f; }
|
||||
static i64 o2i64 (B x) { if (!q_i64(x)) thrM("Expected integer"); return (i64)x.f; }
|
||||
static u64 o2u64 (B x) { if (!q_u64(x)) thrM("Expected integer"); return (u64)x.f; }
|
||||
static f64 o2f (B x) { if (!isNum(x)) thrM("Expected number"); return x.f; }
|
||||
static u32 o2c (B x) { if (!isC32(x)) thrM("Expected character"); return (u32)x.u; }
|
||||
static i32 o2iu (B x) { return (i32)x.f; }
|
||||
static u32 o2cu (B x) { return (u32)x.u; }
|
||||
static usz o2su (B x) { return (usz)x.f; }
|
||||
static f64 o2fu (B x) { return x.f; }
|
||||
static i64 o2i64u(B x) { return (i64)x.f; }
|
||||
FORCE_INLINE bool o2bG(B x) { return(x.u<<1)!=0;} FORCE_INLINE bool o2b(B x) { i32 t=(i32)x.f; if(t!=x.f || t!=0&t!=1)thrM("Expected boolean"); return o2bG(x); }
|
||||
FORCE_INLINE i32 o2iG(B x) { return (i32)x.f; } FORCE_INLINE i32 o2i(B x) { if (!q_i32(x)) thrM("Expected integer"); return o2iG(x); }
|
||||
FORCE_INLINE u32 o2cG(B x) { return (u32)x.u; } FORCE_INLINE u32 o2c(B x) { if (!isC32(x)) thrM("Expected character"); return o2cG(x); }
|
||||
FORCE_INLINE usz o2sG(B x) { return (usz)x.f; } FORCE_INLINE usz o2s(B x) { if (!q_usz(x)) thrM("Expected non-negative integer"); return o2sG(x); }
|
||||
FORCE_INLINE f64 o2fG(B x) { return x.f; } FORCE_INLINE f64 o2f(B x) { if (!isNum(x)) thrM("Expected number"); return o2fG(x); }
|
||||
FORCE_INLINE i64 o2i64G(B x) { return (i64)x.f; } FORCE_INLINE i64 o2i64(B x) { if (!q_i64(x)) thrM("Expected integer"); return o2i64G(x); }
|
||||
FORCE_INLINE u64 o2u64G(B x) { return (u64)x.f; } FORCE_INLINE u64 o2u64(B x) { if (!q_u64(x)) thrM("Expected integer"); return o2u64G(x); }
|
||||
|
||||
|
||||
typedef struct Slice {
|
||||
|
||||
@ -248,7 +248,7 @@ void init_comp(B* set, B prim) {
|
||||
B gv = GetU(prim, i);
|
||||
B v = IGet(gv, 1);
|
||||
i32 t = isFun(v)? 0 : isMd1(v)? 1 : isMd2(v)? 2 : 3;
|
||||
*(gl[t]++) = o2cu(IGet(gv, 0));
|
||||
*(gl[t]++) = o2cG(IGet(gv, 0));
|
||||
prh.a[np[t]++] = v;
|
||||
}
|
||||
|
||||
@ -284,7 +284,7 @@ B rebqn_exec(B str, B path, B args, B o) {
|
||||
comp_currRe = inc(o);
|
||||
|
||||
B* op = harr_ptr(o);
|
||||
i32 replMode = o2iu(op[0]);
|
||||
i32 replMode = o2iG(op[0]);
|
||||
Scope* sc = c(Scope, op[1]);
|
||||
B res;
|
||||
if (replMode>0) {
|
||||
|
||||
@ -135,7 +135,7 @@ void cbqn_runLine0(char* ln, i64 read) {
|
||||
if (IA(c) != len) continue;
|
||||
SGetU(c)
|
||||
bool ok = true;
|
||||
for (i32 j = 0; j < len; j++) ok&= o2cu(GetU(c, j))==name[j];
|
||||
for (i32 j = 0; j < len; j++) ok&= o2cG(GetU(c, j))==name[j];
|
||||
if (ok) {
|
||||
B val = e->vars[i];
|
||||
e->vars[i] = bi_noVar;
|
||||
|
||||
@ -235,7 +235,7 @@ B dyArith_SA(DyTableSA* table, B w, B x) {
|
||||
table = t2;
|
||||
|
||||
|
||||
wa = o2cu(w);
|
||||
wa = o2cG(w);
|
||||
newXEc:
|
||||
switch(xe) { default: UD;
|
||||
case el_bit: goto bitsel;
|
||||
@ -269,15 +269,15 @@ B dyArith_SA(DyTableSA* table, B w, B x) {
|
||||
case el_B: goto rec;
|
||||
}
|
||||
|
||||
wint: wa=(u32)o2iu(w); goto f1;
|
||||
wint: wa=(u32)o2iG(w); goto f1;
|
||||
wf64: wa=w.u; goto f1;
|
||||
|
||||
iwiden_i8: if (q_i16(w)) { wa=(u32)o2iu(w); type=t_i16arr; goto cpy_i16; }
|
||||
iwiden_i16: if (q_i32(w)) { wa=(u32)o2iu(w); type=t_i32arr; goto cpy_i32; }
|
||||
iwiden_i8: if (q_i16(w)) { wa=(u32)o2iG(w); type=t_i16arr; goto cpy_i16; }
|
||||
iwiden_i16: if (q_i32(w)) { wa=(u32)o2iG(w); type=t_i32arr; goto cpy_i32; }
|
||||
iwiden_i32: { wa=w.u; type=t_f64arr; goto cpy_f64; }
|
||||
|
||||
iwiden_c8: if (q_i16(w)) { wa=(u32)o2iu(w); type=t_c16arr; goto cpy_c16; }
|
||||
iwiden_c16: if (q_i32(w)) { wa=(u32)o2iu(w); type=t_c32arr; goto cpy_c32; }
|
||||
iwiden_c8: if (q_i16(w)) { wa=(u32)o2iG(w); type=t_c16arr; goto cpy_c16; }
|
||||
iwiden_c16: if (q_i32(w)) { wa=(u32)o2iG(w); type=t_c32arr; goto cpy_c32; }
|
||||
goto rec;
|
||||
|
||||
// TODO reuse the copied array for the result; maybe even alternate copy & operation to stay in cache
|
||||
@ -323,15 +323,15 @@ static void powAAu_f64_f64_f64(u8* r, u8* w, u8* x, u64 len) { for (u64 i = 0;
|
||||
static void stileAAu_f64_f64_f64(u8* r, u8* w, u8* x, u64 len) { for (u64 i = 0; i < len; i++) ((f64*)r)[i] = pfmod(((f64*)x)[i], ((f64*)w)[i]); }
|
||||
static void logAAu_f64_f64_f64(u8* r, u8* w, u8* x, u64 len) { for (u64 i = 0; i < len; i++) ((f64*)r)[i] = log(((f64*)x)[i])/log(((f64*)w)[i]); }
|
||||
|
||||
bool add_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fu(w); r[0] = m_f64(f+0); r[1] = m_f64(f+1); return true; }
|
||||
bool sub_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fu(w); r[0] = m_f64(f-0); r[1] = m_f64(f-1); return true; }
|
||||
bool subR_forBitselNN_SA(DyTableSA* table, B w, B* r) { f64 f=o2fu(w); r[0] = m_f64(0-f); r[1] = m_f64(1-f); return true; }
|
||||
bool mul_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fu(w); r[0] = m_f64(f*0); r[1] = m_f64(f*1); return true; }
|
||||
bool min_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fu(w); r[0] = m_f64(f<=0?f:0); r[1] = m_f64(f<=1?f:1); return true; }
|
||||
bool max_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fu(w); r[0] = m_f64(f>=0?f:0); r[1] = m_f64(f>=1?f:1); return true; }
|
||||
bool add_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fG(w); r[0] = m_f64(f+0); r[1] = m_f64(f+1); return true; }
|
||||
bool sub_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fG(w); r[0] = m_f64(f-0); r[1] = m_f64(f-1); return true; }
|
||||
bool subR_forBitselNN_SA(DyTableSA* table, B w, B* r) { f64 f=o2fG(w); r[0] = m_f64(0-f); r[1] = m_f64(1-f); return true; }
|
||||
bool mul_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fG(w); r[0] = m_f64(f*0); r[1] = m_f64(f*1); return true; }
|
||||
bool min_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fG(w); r[0] = m_f64(f<=0?f:0); r[1] = m_f64(f<=1?f:1); return true; }
|
||||
bool max_forBitselNN_SA (DyTableSA* table, B w, B* r) { f64 f=o2fG(w); r[0] = m_f64(f>=0?f:0); r[1] = m_f64(f>=1?f:1); return true; }
|
||||
|
||||
bool add_forBitselCN_SA(DyTableSA* table, B w, B* r) { u32 wc=o2cu(w); if(wc+1<=CHR_MAX) return false; r[0] = m_c32(wc); r[1] = m_c32(wc+1); return true; }
|
||||
bool sub_forBitselCN_SA(DyTableSA* table, B w, B* r) { u32 wc=o2cu(w); if(wc !=0 ) return false; r[0] = m_c32(wc); r[1] = m_c32(wc-1); return true; }
|
||||
bool add_forBitselCN_SA(DyTableSA* table, B w, B* r) { u32 wc=o2cG(w); if(wc+1<=CHR_MAX) return false; r[0] = m_c32(wc); r[1] = m_c32(wc+1); return true; }
|
||||
bool sub_forBitselCN_SA(DyTableSA* table, B w, B* r) { u32 wc=o2cG(w); if(wc !=0 ) return false; r[0] = m_c32(wc); r[1] = m_c32(wc-1); return true; }
|
||||
|
||||
B sub_c2R(B t, B w, B x) { return sub_c2(t, x, w); }
|
||||
|
||||
@ -339,7 +339,7 @@ static NOINLINE B or_SA(B t, B w, B x) {
|
||||
if (!isF64(w)) return arith_recd(or_c2, w, x);
|
||||
if (LIKELY(TI(x,elType)==el_bit)) {
|
||||
bitsel:
|
||||
f64 wf = o2fu(w);
|
||||
f64 wf = o2fG(w);
|
||||
return bit_sel(x, m_f64(bqn_or(wf, 0)), 1, m_f64(bqn_or(wf, 1)), 1);
|
||||
}
|
||||
x = num_squeezeChk(x);
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
def bcall{T, f, x} = emit{T, 'BCALL', f, x}
|
||||
def from_B{T, x & T==f64} = bcall{T, 'o2fu', x}
|
||||
def from_B{T, x & T<=i32 & issigned{T}} = bcall{T, 'o2iu', x}
|
||||
def from_B{T, x & T<=u32 & isunsigned{T}} = bcall{T, 'o2cu', x}
|
||||
def from_B{T, x & T==f64} = bcall{T, 'o2fG', x}
|
||||
def from_B{T, x & T<=i32 & issigned{T}} = bcall{T, 'o2iG', x}
|
||||
def from_B{T, x & T<=u32 & isunsigned{T}} = bcall{T, 'o2cG', x}
|
||||
|
||||
def q_f64{x} = bcall{u1, 'q_f64', x}
|
||||
def q_chr{x} = bcall{u1, 'q_c32', x}
|
||||
|
||||
@ -11,8 +11,8 @@ NOINLINE B bit_sel(B b, B e0, bool h0, B e1, bool h1) {
|
||||
u64* bp = bitarr_ptr(b);
|
||||
usz ia = IA(b);
|
||||
if (elNum(t0) && elNum(t1)) { B r;
|
||||
f64 f0 = o2fu(e0); i32 i0 = f0;
|
||||
f64 f1 = o2fu(e1); i32 i1 = f1;
|
||||
f64 f0 = o2fG(e0); i32 i0 = f0;
|
||||
f64 f1 = o2fG(e1); i32 i1 = f1;
|
||||
u8 tM = t0>t1? t0 : t1;
|
||||
if (tM==el_bit) {
|
||||
if (i0) {
|
||||
@ -28,7 +28,7 @@ NOINLINE B bit_sel(B b, B e0, bool h0, B e1, bool h1) {
|
||||
else if (tM==el_i32) { i32* rp; r=m_i32arrc(&rp, b); for (usz i = 0; i < ia; i++) rp[i] = bitp_get(bp,i)? i1 : i0; }
|
||||
else { f64* rp; r=m_f64arrc(&rp, b); for (usz i = 0; i < ia; i++) rp[i] = bitp_get(bp,i)? f1 : f0; }
|
||||
decG(b); return r;
|
||||
} else if (elChr(t0) && elChr(t1)) { B r; u32 u0 = o2cu(e0); u32 u1 = o2cu(e1);
|
||||
} else if (elChr(t0) && elChr(t1)) { B r; u32 u0 = o2cG(e0); u32 u1 = o2cG(e1);
|
||||
if (t0<=el_c8 & t1<=el_c8 ) { u8* rp; r=m_c8arrc (&rp, b); for (usz i = 0; i < ia; i++) rp[i] = bitp_get(bp,i)? u1 : u0; }
|
||||
else if (t0<=el_c16 & t1<=el_c16) { u16* rp; r=m_c16arrc(&rp, b); for (usz i = 0; i < ia; i++) rp[i] = bitp_get(bp,i)? u1 : u0; }
|
||||
else { u32* rp; r=m_c32arrc(&rp, b); for (usz i = 0; i < ia; i++) rp[i] = bitp_get(bp,i)? u1 : u0; }
|
||||
|
||||
@ -77,7 +77,7 @@ B eachm_fn(B fo, B x, BB2B f) { // TODO definitely rewrite this. Probably still
|
||||
B r; i32* rp;
|
||||
if (reuse && TY(x)==t_i32arr) { r=incG(REUSE(x)); rp = xp; }
|
||||
else r = m_i32arrc(&rp, x);
|
||||
rp[i++] = o2iu(cr);
|
||||
rp[i++] = o2iG(cr);
|
||||
for (; i < ia; i++) {
|
||||
cr = f(fo, m_i32(xp[i]));
|
||||
if (!q_i32(cr)) {
|
||||
@ -86,7 +86,7 @@ B eachm_fn(B fo, B x, BB2B f) { // TODO definitely rewrite this. Probably still
|
||||
decG(r);
|
||||
goto fallback;
|
||||
}
|
||||
rp[i] = o2iu(cr);
|
||||
rp[i] = o2iG(cr);
|
||||
}
|
||||
decG(x);
|
||||
return num_squeeze(r);
|
||||
@ -95,7 +95,7 @@ B eachm_fn(B fo, B x, BB2B f) { // TODO definitely rewrite this. Probably still
|
||||
B r; f64* rp;
|
||||
if (reuse && TY(x)==t_f64arr) { r=incG(REUSE(x)); rp = xp; }
|
||||
else r = m_f64arrc(&rp, x);
|
||||
rp[i++] = o2fu(cr);
|
||||
rp[i++] = o2fG(cr);
|
||||
for (; i < ia; i++) {
|
||||
cr = f(fo, m_f64(xp[i]));
|
||||
if (!q_f64(cr)) {
|
||||
@ -104,7 +104,7 @@ B eachm_fn(B fo, B x, BB2B f) { // TODO definitely rewrite this. Probably still
|
||||
decG(r);
|
||||
goto fallback;
|
||||
}
|
||||
rp[i] = o2fu(cr);
|
||||
rp[i] = o2fG(cr);
|
||||
}
|
||||
decG(x);
|
||||
return num_squeeze(r);
|
||||
|
||||
@ -102,18 +102,18 @@ B path_rel(B base, B rel) { // consumes rel; assumes base is a char vector or bi
|
||||
usz ria = IA(rel);
|
||||
if (RNK(rel)!=1) thrM("Paths must be character vectors");
|
||||
guaranteeStr(rel);
|
||||
if (ria>0 && o2cu(GetU(rel, 0))=='/') return rel;
|
||||
if (ria>0 && o2cG(GetU(rel, 0))=='/') return rel;
|
||||
if (q_N(base)) thrM("Using relative path with no absolute base path known");
|
||||
if (ria==0) { dec(rel); return incG(base); }
|
||||
usz bia = IA(base);
|
||||
if (bia==0) return rel;
|
||||
SGetU(base)
|
||||
bool has = o2cu(GetU(base, bia-1))=='/';
|
||||
bool has = o2cG(GetU(base, bia-1))=='/';
|
||||
u32* rp; B r = m_c32arrv(&rp, bia+ria+(has?0:1));
|
||||
usz ri = 0;
|
||||
for (usz i = 0; i < bia-(has?1:0); i++) rp[ri++] = o2cu(GetU(base, i));
|
||||
for (usz i = 0; i < bia-(has?1:0); i++) rp[ri++] = o2cG(GetU(base, i));
|
||||
rp[ri++] = '/';
|
||||
for (usz i = 0; i < ria; i++) rp[ri++] = o2cu(GetU(rel, i));
|
||||
for (usz i = 0; i < ria; i++) rp[ri++] = o2cG(GetU(rel, i));
|
||||
dec(rel);
|
||||
return r;
|
||||
}
|
||||
@ -125,9 +125,9 @@ B path_parent(B path) {
|
||||
if (pia==0) thrM("Empty file path");
|
||||
guaranteeStr(path);
|
||||
for (i64 i = (i64)pia-2; i >= 0; i--) {
|
||||
if (o2cu(GetU(path, i))=='/') return taga(arr_shVec(TI(path,slice)(path, 0, i+1)));
|
||||
if (o2cG(GetU(path, i))=='/') return taga(arr_shVec(TI(path,slice)(path, 0, i+1)));
|
||||
}
|
||||
if (o2cu(GetU(path, 0))=='/') return path;
|
||||
if (o2cG(GetU(path, 0))=='/') return path;
|
||||
dec(path);
|
||||
u32* rp; B r = m_c32arrv(&rp, 2); rp[0] = '.'; rp[1] = '/';
|
||||
return r;
|
||||
@ -139,7 +139,7 @@ B path_name(B path) {
|
||||
if (pia==0) thrM("Empty file path");
|
||||
guaranteeStr(path);
|
||||
for (i64 i = (i64)pia-1; i >= 0; i--) {
|
||||
if (o2cu(GetU(path, i))=='/') {
|
||||
if (o2cG(GetU(path, i))=='/') {
|
||||
if (i == pia-1) thrF("File path ended with a slash: \"%R\"", path);
|
||||
return taga(arr_shVec(TI(path,slice)(path, i+1, pia - (i+1))));
|
||||
}
|
||||
@ -180,7 +180,7 @@ CharBuf get_chars(B x) {
|
||||
SGetU(x)
|
||||
for (u64 i = 0; i < len; i++) {
|
||||
B c = GetU(x,i);
|
||||
buf[i] = isNum(c)? o2iu(c) : o2c(c);
|
||||
buf[i] = isNum(c)? o2iG(c) : o2c(c);
|
||||
}
|
||||
}
|
||||
return (CharBuf){.data=buf, .alloc=alloc};
|
||||
|
||||
@ -90,25 +90,25 @@ B vec_join(B w, B x) {
|
||||
static RT m_##N##G_##TY ARGS
|
||||
|
||||
DEF_S(void, set, MAX, false, x, (void* a, usz ms, B x), ms, x) { err("m_setG_MAX"); }
|
||||
DEF_S(void, set, bit, q_bit(x), x, (void* a, usz ms, B x), ms, x) { bitp_set((u64*)a, ms, o2bu(x)); }
|
||||
DEF_S(void, set, i8, q_i8 (x), x, (void* a, usz ms, B x), ms, x) { (( i8*)a)[ms] = o2iu(x); }
|
||||
DEF_S(void, set, i16, q_i16(x), x, (void* a, usz ms, B x), ms, x) { ((i16*)a)[ms] = o2iu(x); }
|
||||
DEF_S(void, set, i32, q_i32(x), x, (void* a, usz ms, B x), ms, x) { ((i32*)a)[ms] = o2iu(x); }
|
||||
DEF_S(void, set, c8, q_c8 (x), x, (void* a, usz ms, B x), ms, x) { (( u8*)a)[ms] = o2cu(x); }
|
||||
DEF_S(void, set, c16, q_c16(x), x, (void* a, usz ms, B x), ms, x) { ((u16*)a)[ms] = o2cu(x); }
|
||||
DEF_S(void, set, c32, q_c32(x), x, (void* a, usz ms, B x), ms, x) { ((u32*)a)[ms] = o2cu(x); }
|
||||
DEF_S(void, set, f64, q_f64(x), x, (void* a, usz ms, B x), ms, x) { ((f64*)a)[ms] = o2fu(x); }
|
||||
DEF_S(void, set, bit, q_bit(x), x, (void* a, usz ms, B x), ms, x) { bitp_set((u64*)a, ms, o2bG(x)); }
|
||||
DEF_S(void, set, i8, q_i8 (x), x, (void* a, usz ms, B x), ms, x) { (( i8*)a)[ms] = o2iG(x); }
|
||||
DEF_S(void, set, i16, q_i16(x), x, (void* a, usz ms, B x), ms, x) { ((i16*)a)[ms] = o2iG(x); }
|
||||
DEF_S(void, set, i32, q_i32(x), x, (void* a, usz ms, B x), ms, x) { ((i32*)a)[ms] = o2iG(x); }
|
||||
DEF_S(void, set, c8, q_c8 (x), x, (void* a, usz ms, B x), ms, x) { (( u8*)a)[ms] = o2cG(x); }
|
||||
DEF_S(void, set, c16, q_c16(x), x, (void* a, usz ms, B x), ms, x) { ((u16*)a)[ms] = o2cG(x); }
|
||||
DEF_S(void, set, c32, q_c32(x), x, (void* a, usz ms, B x), ms, x) { ((u32*)a)[ms] = o2cG(x); }
|
||||
DEF_S(void, set, f64, q_f64(x), x, (void* a, usz ms, B x), ms, x) { ((f64*)a)[ms] = o2fG(x); }
|
||||
DEF_G(void, set, B, (void* a, usz ms, B x), ms, x) { (( B*)a)[ms] = x; }
|
||||
|
||||
DEF_S(void, fill, MAX, false, x, (void* a, usz ms, B x, usz l), ms, x, l) { err("m_fillG_MAX"); }
|
||||
DEF_S(void, fill, bit, q_bit(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { u64* p = (u64*)a;bool v = o2bu(x); for (usz i = 0; i < l; i++) bitp_set(p, ms+i, v); }
|
||||
DEF_S(void, fill, i8 , q_i8 (x), x, (void* a, usz ms, B x, usz l), ms, x, l) { i8* p = ms+( i8*)a; i8 v = o2iu(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, i16, q_i16(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { i16* p = ms+(i16*)a; i16 v = o2iu(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, i32, q_i32(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { i32* p = ms+(i32*)a; i32 v = o2iu(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, c8 , q_c8 (x), x, (void* a, usz ms, B x, usz l), ms, x, l) { u8* p = ms+( u8*)a; u8 v = o2cu(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, c16, q_c16(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { u16* p = ms+(u16*)a; u16 v = o2cu(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, c32, q_c32(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { u32* p = ms+(u32*)a; u32 v = o2cu(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, f64, isF64(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { f64* p = ms+(f64*)a; f64 v = o2fu(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, bit, q_bit(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { u64* p = (u64*)a;bool v = o2bG(x); for (usz i = 0; i < l; i++) bitp_set(p, ms+i, v); }
|
||||
DEF_S(void, fill, i8 , q_i8 (x), x, (void* a, usz ms, B x, usz l), ms, x, l) { i8* p = ms+( i8*)a; i8 v = o2iG(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, i16, q_i16(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { i16* p = ms+(i16*)a; i16 v = o2iG(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, i32, q_i32(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { i32* p = ms+(i32*)a; i32 v = o2iG(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, c8 , q_c8 (x), x, (void* a, usz ms, B x, usz l), ms, x, l) { u8* p = ms+( u8*)a; u8 v = o2cG(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, c16, q_c16(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { u16* p = ms+(u16*)a; u16 v = o2cG(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, c32, q_c32(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { u32* p = ms+(u32*)a; u32 v = o2cG(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_S(void, fill, f64, isF64(x), x, (void* a, usz ms, B x, usz l), ms, x, l) { f64* p = ms+(f64*)a; f64 v = o2fG(x); for (usz i = 0; i < l; i++) p[i] = v; }
|
||||
DEF_G(void, fill, B , (void* a, usz ms, B x, usz l), ms, x, l) {
|
||||
B* p = ms + (B*)a;
|
||||
for (usz i = 0; i < l; i++) p[i] = x;
|
||||
@ -246,11 +246,11 @@ DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, x
|
||||
else decG(x); \
|
||||
return (T##Arr*)r; \
|
||||
}
|
||||
#define BIT_PUT(V) bitp_set((u64*)rp, i, o2bu(V))
|
||||
#define BIT_PUT(V) bitp_set((u64*)rp, i, o2bG(V))
|
||||
#define H2T_COPY(T) copy##T##Fns[el_MAX]((u8*)bxp, rp, ia, xRaw)
|
||||
#define MAKE_TYCPY(T, E, F, ...) MAKE_CPY(1, T##Atom* rp; Arr* r = m_##E##arrp(&rp, ia), getU, ((T##Atom*)rp)[i] = F, rp, H2T_COPY(T), T, __VA_ARGS__)
|
||||
#define MAKE_CCPY(T,E) MAKE_TYCPY(T, E, o2cu, {badCopy, badCopy, badCopy, badCopy, badCopy, COPY_FN(c8,E),COPY_FN(c16,E),COPY_FN(c32,E),cpy##T##Arr_B,COPY_FN(B,E)})
|
||||
#define MAKE_ICPY(T,E) MAKE_TYCPY(T, E, o2fu, {COPY_FN(1,E),COPY_FN(i8,E),COPY_FN(i16,E),COPY_FN(i32,E),COPY_FN(f64,E),badCopy, badCopy, badCopy, cpy##T##Arr_B,COPY_FN(f64,E)})
|
||||
#define MAKE_CCPY(T,E) MAKE_TYCPY(T, E, o2cG, {badCopy, badCopy, badCopy, badCopy, badCopy, COPY_FN(c8,E),COPY_FN(c16,E),COPY_FN(c32,E),cpy##T##Arr_B,COPY_FN(B,E)})
|
||||
#define MAKE_ICPY(T,E) MAKE_TYCPY(T, E, o2fG, {COPY_FN(1,E),COPY_FN(i8,E),COPY_FN(i16,E),COPY_FN(i32,E),COPY_FN(f64,E),badCopy, badCopy, badCopy, cpy##T##Arr_B,COPY_FN(f64,E)})
|
||||
MAKE_CPY(0, HArr_p p = m_harrUp(ia); Arr* r = (Arr*)p.c, get, ((B*)rp)[i] =, p.a, for (usz i=0; i<ia; i++) ((B*)rp)[i] = inc(bxp[i]),
|
||||
H, {COPY_FN(1,B),COPY_FN(i8,B),COPY_FN(i16,B),COPY_FN(i32,B),COPY_FN(f64,B),COPY_FN(c8,B),COPY_FN(c16,B),COPY_FN(c32,B),cpyHArr_B, COPY_FN(f64,B)})
|
||||
MAKE_CPY(1, u64* rp; Arr* r = m_bitarrp(&rp, ia), getU, BIT_PUT, rp, H2T_COPY(Bit),
|
||||
@ -299,8 +299,8 @@ DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, x
|
||||
else if (xe==el_f64) { f64* xp = f64any_ptr(x); for(usz i=0; i<ia; i++) rp[i]=xp[i]; } \
|
||||
else { \
|
||||
B* xp = arr_bptr(x); \
|
||||
if (xp!=NULL) { for (usz i=0; i<ia; i++) rp[i]=o2fu(xp[i] ); } \
|
||||
else { SGetU(x) for (usz i=0; i<ia; i++) rp[i]=o2fu(GetU(x,i)); } \
|
||||
if (xp!=NULL) { for (usz i=0; i<ia; i++) rp[i]=o2fG(xp[i] ); } \
|
||||
else { SGetU(x) for (usz i=0; i<ia; i++) rp[i]=o2fG(GetU(x,i)); } \
|
||||
} \
|
||||
ptr_decT(a(x)); \
|
||||
return (T##Arr*)r; \
|
||||
@ -317,8 +317,8 @@ DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, x
|
||||
else if (xe==el_c32) { u32* xp = c32any_ptr(x); for(usz i=0; i<ia; i++) rp[i]=xp[i]; } \
|
||||
else { \
|
||||
B* xp = arr_bptr(x); \
|
||||
if (xp!=NULL) { for (usz i=0; i<ia; i++) rp[i]=o2cu(xp[i] ); } \
|
||||
else { SGetU(x) for (usz i=0; i<ia; i++) rp[i]=o2cu(GetU(x,i)); } \
|
||||
if (xp!=NULL) { for (usz i=0; i<ia; i++) rp[i]=o2cG(xp[i] ); } \
|
||||
else { SGetU(x) for (usz i=0; i<ia; i++) rp[i]=o2cG(GetU(x,i)); } \
|
||||
} \
|
||||
ptr_decT(a(x)); \
|
||||
return (T##Arr*)r; \
|
||||
@ -356,8 +356,8 @@ DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, x
|
||||
else if (xe==el_f64) { f64* xp = f64any_ptr(x); for(usz i=0; i<ia; i++) bitp_set(rp,i,xp[i]); }
|
||||
else {
|
||||
B* xp = arr_bptr(x);
|
||||
if (xp!=NULL) { for (usz i=0; i<ia; i++) bitp_set(rp,i,o2fu(xp[i] )); }
|
||||
else { SGetU(x) for (usz i=0; i<ia; i++) bitp_set(rp,i,o2fu(GetU(x,i))); }
|
||||
if (xp!=NULL) { for (usz i=0; i<ia; i++) bitp_set(rp,i,o2fG(xp[i] )); }
|
||||
else { SGetU(x) for (usz i=0; i<ia; i++) bitp_set(rp,i,o2fG(GetU(x,i))); }
|
||||
}
|
||||
ptr_decT(a(x));
|
||||
return (BitArr*)r;
|
||||
|
||||
@ -209,14 +209,14 @@ static inline bool inplace_add(B w, B x) { // consumes x if returns true; fails
|
||||
u64 wsz = mm_size(v(w));
|
||||
u8 wt = TY(w);
|
||||
switch (wt) {
|
||||
case t_bitarr: if (BITARR_SZ( ria)<wsz && q_bit(x)) { bitp_set(bitarr_ptr(w),wia,o2bu(x)); goto ok; } break;
|
||||
case t_i8arr: if (TYARR_SZ(I8, ria)<wsz && q_i8 (x)) { i8arr_ptr (w)[wia]=o2iu(x); goto ok; } break;
|
||||
case t_i16arr: if (TYARR_SZ(I16,ria)<wsz && q_i16(x)) { i16arr_ptr(w)[wia]=o2iu(x); goto ok; } break;
|
||||
case t_i32arr: if (TYARR_SZ(I32,ria)<wsz && q_i32(x)) { i32arr_ptr(w)[wia]=o2iu(x); goto ok; } break;
|
||||
case t_c8arr: if (TYARR_SZ(C8, ria)<wsz && q_c8 (x)) { c8arr_ptr (w)[wia]=o2cu(x); goto ok; } break;
|
||||
case t_c16arr: if (TYARR_SZ(C16,ria)<wsz && q_c16(x)) { c16arr_ptr(w)[wia]=o2cu(x); goto ok; } break;
|
||||
case t_c32arr: if (TYARR_SZ(C32,ria)<wsz && q_c32(x)) { c32arr_ptr(w)[wia]=o2cu(x); goto ok; } break;
|
||||
case t_f64arr: if (TYARR_SZ(F64,ria)<wsz && q_f64(x)) { f64arr_ptr(w)[wia]=o2fu(x); goto ok; } break;
|
||||
case t_bitarr: if (BITARR_SZ( ria)<wsz && q_bit(x)) { bitp_set(bitarr_ptr(w),wia,o2bG(x)); goto ok; } break;
|
||||
case t_i8arr: if (TYARR_SZ(I8, ria)<wsz && q_i8 (x)) { i8arr_ptr (w)[wia]=o2iG(x); goto ok; } break;
|
||||
case t_i16arr: if (TYARR_SZ(I16,ria)<wsz && q_i16(x)) { i16arr_ptr(w)[wia]=o2iG(x); goto ok; } break;
|
||||
case t_i32arr: if (TYARR_SZ(I32,ria)<wsz && q_i32(x)) { i32arr_ptr(w)[wia]=o2iG(x); goto ok; } break;
|
||||
case t_c8arr: if (TYARR_SZ(C8, ria)<wsz && q_c8 (x)) { c8arr_ptr (w)[wia]=o2cG(x); goto ok; } break;
|
||||
case t_c16arr: if (TYARR_SZ(C16,ria)<wsz && q_c16(x)) { c16arr_ptr(w)[wia]=o2cG(x); goto ok; } break;
|
||||
case t_c32arr: if (TYARR_SZ(C32,ria)<wsz && q_c32(x)) { c32arr_ptr(w)[wia]=o2cG(x); goto ok; } break;
|
||||
case t_f64arr: if (TYARR_SZ(F64,ria)<wsz && q_f64(x)) { f64arr_ptr(w)[wia]=o2fG(x); goto ok; } break;
|
||||
case t_harr: if (fsizeof(HArr,a,B,ria)<wsz) {
|
||||
harr_ptr(w)[wia] = x;
|
||||
goto ok;
|
||||
|
||||
@ -84,7 +84,7 @@ void toUTF8(B x, char* p) {
|
||||
SGetU(x)
|
||||
usz ia = IA(x);
|
||||
for (usz i = 0; i < ia; i++) {
|
||||
u32 c = o2cu(GetU(x,i));
|
||||
u32 c = o2cG(GetU(x,i));
|
||||
if (c<128) { *p++ = c; }
|
||||
else if (c<=0x07FF) { *p++ = 0xC0|c>>6 ; *p++ = 0x80|(c &0x3F); }
|
||||
else if (c<=0xFFFF) { *p++ = 0xE0|c>>12; *p++ = 0x80|(c>>6 &0x3F);*p++ = 0x80|(c &0x3F); }
|
||||
|
||||
16
src/vm.c
16
src/vm.c
@ -1289,27 +1289,27 @@ NOINLINE B vm_fmtPoint(B src, B prepend, B path, usz cs, usz ce) { // consumes p
|
||||
SGetU(src)
|
||||
usz srcL = IA(src);
|
||||
usz srcS = cs;
|
||||
while (srcS>0 && o2cu(GetU(src,srcS-1))!='\n') srcS--;
|
||||
while (srcS>0 && o2cG(GetU(src,srcS-1))!='\n') srcS--;
|
||||
usz srcE = srcS;
|
||||
while (srcE<srcL) { if(o2cu(GetU(src, srcE))=='\n') break; srcE++; }
|
||||
while (srcE<srcL) { if(o2cG(GetU(src, srcE))=='\n') break; srcE++; }
|
||||
if (ce>srcE) ce = srcE;
|
||||
|
||||
i64 ln = 1;
|
||||
for (usz i = 0; i < srcS; i++) if(o2cu(GetU(src, i))=='\n') ln++;
|
||||
for (usz i = 0; i < srcS; i++) if(o2cG(GetU(src, i))=='\n') ln++;
|
||||
B s = prepend;
|
||||
if (isArr(path) && (IA(path)>1 || (IA(path)==1 && IGetU(path,0).u!=m_c32('.').u))) AFMT("%R:%l:\n ", path, ln);
|
||||
else AFMT("at ");
|
||||
i64 padEnd = (i64)IA(s);
|
||||
i64 padStart = padEnd;
|
||||
SGetU(s)
|
||||
while (padStart>0 && o2cu(GetU(s,padStart-1))!='\n') padStart--;
|
||||
while (padStart>0 && o2cG(GetU(s,padStart-1))!='\n') padStart--;
|
||||
|
||||
AJOIN(taga(arr_shVec(TI(src,slice)(incG(src),srcS, srcE-srcS))));
|
||||
cs-= srcS;
|
||||
ce-= srcS;
|
||||
ACHR('\n');
|
||||
for (i64 i = padStart; i < padEnd; i++) ACHR(' ');
|
||||
for (u64 i = 0; i < cs; i++) ACHR(o2cu(GetU(src, srcS+i))=='\t'? '\t' : ' '); // ugh tabs
|
||||
for (u64 i = 0; i < cs; i++) ACHR(o2cG(GetU(src, srcS+i))=='\t'? '\t' : ' '); // ugh tabs
|
||||
for (u64 i = cs; i < ce; i++) ACHR('^');
|
||||
return s;
|
||||
}
|
||||
@ -1341,8 +1341,8 @@ native_print:
|
||||
int start = fprintf(stderr, "at ");
|
||||
usz srcL = IA(src);
|
||||
SGetU(src)
|
||||
usz srcS = cs; while (srcS>0 && o2cu(GetU(src,srcS-1))!='\n') srcS--;
|
||||
usz srcE = srcS; while (srcE<srcL) { u32 chr = o2cu(GetU(src, srcE)); if(chr=='\n')break; fprintUTF8(stderr, chr); srcE++; }
|
||||
usz srcS = cs; while (srcS>0 && o2cG(GetU(src,srcS-1))!='\n') srcS--;
|
||||
usz srcE = srcS; while (srcE<srcL) { u32 chr = o2cG(GetU(src, srcE)); if(chr=='\n')break; fprintUTF8(stderr, chr); srcE++; }
|
||||
if (ce>srcE) ce = srcE;
|
||||
cs-= srcS; ce-= srcS;
|
||||
fputc('\n', stderr);
|
||||
@ -1534,7 +1534,7 @@ void profiler_displayResults() {
|
||||
usz pi = 0;
|
||||
i32 curr = 0;
|
||||
for (usz i = 0; i < sia; i++) {
|
||||
u32 c = o2cu(GetU(src, i));
|
||||
u32 c = o2cG(GetU(src, i));
|
||||
curr+= m[i];
|
||||
if (c=='\n' || i==sia-1) {
|
||||
Arr* sl = arr_shVec(TI(src,slice)(incG(src), pi, i-pi+(c=='\n'?0:1)));
|
||||
|
||||
Loading…
Reference in New Issue
Block a user