initialize ia on allocation always
This commit is contained in:
parent
8d7a31c8e9
commit
849eeff465
@ -58,7 +58,7 @@ B ud_c1(B t, B x) {
|
||||
B* rp = fillarr_ptr(r);
|
||||
for (usz i = 0; i < ria; i++) rp[i] = m_f64(0); // don't break if allocation errors
|
||||
|
||||
usz* rsh = arr_shAllocI(r, ria, xia);
|
||||
usz* rsh = arr_shAlloc(r, xia);
|
||||
if (rsh) memcpy(rsh, sh, sizeof(usz)*xia);
|
||||
|
||||
i32 pos[xia]; B* crp = rp;
|
||||
@ -234,7 +234,7 @@ B indexOf_c2(B t, B w, B x) {
|
||||
}
|
||||
dec(w); dec(x);
|
||||
i32* rp; Arr* r = m_i32arrp(&rp, 1);
|
||||
arr_shAllocR(r, 0);
|
||||
arr_shAlloc(r, 0);
|
||||
rp[0] = res;
|
||||
return taga(r);
|
||||
} else if (rnk(x)==1) {
|
||||
|
||||
@ -192,7 +192,7 @@ B variation_c2(B t, B w, B x) {
|
||||
else for (usz i = 0; i < xia; i++) rp[i] = xget(x,i);
|
||||
} else thrF("•internal.Variation: Bad type \"%R\"", taga(wc));
|
||||
if (slice) {
|
||||
Arr* slice = TI(res,slice)(res, 0);
|
||||
Arr* slice = TI(res,slice)(res, 0, a(res)->ia);
|
||||
arr_shCopy(slice, res);
|
||||
res = taga(slice);
|
||||
}
|
||||
|
||||
@ -343,12 +343,11 @@ B cell_c1(B d, B x) { B f = c(Md1D,d)->f;
|
||||
memcpy(csh->a, a(x)->sh+1, sizeof(usz)*cr);
|
||||
}
|
||||
usz i = 0;
|
||||
BS2A slice = TI(x,slice);
|
||||
BSS2A slice = TI(x,slice);
|
||||
HArr_p r = m_harrs(cam, &i);
|
||||
usz p = 0;
|
||||
for (; i < cam; i++) {
|
||||
Arr* s = slice(inc(x), p);
|
||||
arr_shSetI(s, csz, cr, csh);
|
||||
Arr* s = slice(inc(x), p, csz); arr_shSetI(s, cr, csh);
|
||||
r.a[i] = c1(f, taga(s));
|
||||
p+= csz;
|
||||
}
|
||||
|
||||
@ -25,8 +25,7 @@ B shape_c1(B t, B x) {
|
||||
rp[0] = o2cu(x);
|
||||
return r;
|
||||
}
|
||||
Arr* ra = m_fillarrp(1);
|
||||
arr_shVec(ra, 1);
|
||||
Arr* ra = m_fillarrp(1); arr_shVec(ra);
|
||||
fillarr_setFill(ra, asFill(inc(x)));
|
||||
fillarr_ptr(ra)[0] = x;
|
||||
return taga(ra);
|
||||
@ -39,12 +38,10 @@ B shape_c1(B t, B x) {
|
||||
goto unit;
|
||||
}
|
||||
if (reusable(x)) {
|
||||
decSh(v(x));
|
||||
arr_shVec(a(x), ia);
|
||||
decSh(v(x)); arr_shVec(a(x));
|
||||
return x;
|
||||
}
|
||||
Arr* r = TI(x,slice)(x, 0);
|
||||
arr_shVec(r, ia);
|
||||
Arr* r = TI(x,slice)(x, 0, ia); arr_shVec(r);
|
||||
return taga(r);
|
||||
}
|
||||
}
|
||||
@ -127,7 +124,7 @@ B shape_c2(B t, B w, B x) {
|
||||
if (nia <= xia) {
|
||||
B r; Arr* ra;
|
||||
if (reusable(x) && xia==nia) { r = x; decSh(v(x)); ra = (Arr*)v(r); }
|
||||
else { ra = TI(x,slice)(x, 0); ra->ia = nia; r = taga(ra); }
|
||||
else { ra = TI(x,slice)(x, 0, nia); r = taga(ra); }
|
||||
arr_shSetU(ra, nr, sh);
|
||||
return r;
|
||||
} else {
|
||||
@ -177,7 +174,7 @@ B shape_c2(B t, B w, B x) {
|
||||
for (u64 i = 0; i < nia; i++) rp[i] = c;
|
||||
return taga(r);
|
||||
}
|
||||
Arr* r = m_fillarrp(nia); r->ia=nia; arr_shSetU(r, nr, sh);
|
||||
Arr* r = m_fillarrp(nia); arr_shSetU(r, nr, sh);
|
||||
B* rp = fillarr_ptr(r);
|
||||
if (nia) incBy(x, nia-1);
|
||||
else dec(x);
|
||||
@ -214,14 +211,11 @@ B select_c1(B t, B x) {
|
||||
ur xr = rnk(x);
|
||||
if (xr==0) thrM("⊏: Argument cannot be rank 0");
|
||||
if (a(x)->sh[0]==0) thrF("⊏: Argument shape cannot start with 0 (%H ≡ ≢𝕩)", x);
|
||||
Arr* r = TI(x,slice)(inc(x),0);
|
||||
usz* sh = arr_shAllocR(r, xr-1);
|
||||
usz ia = 1;
|
||||
for (i32 i = 1; i < xr; i++) {
|
||||
if (sh) sh[i-1] = a(x)->sh[i];
|
||||
ia*= a(x)->sh[i];
|
||||
}
|
||||
r->ia = ia;
|
||||
for (i32 i = 1; i < xr; i++) ia*= a(x)->sh[i];
|
||||
Arr* r = TI(x,slice)(inc(x),0, ia);
|
||||
usz* sh = arr_shAlloc(r, xr-1);
|
||||
if (sh) for (i32 i = 1; i < xr; i++) sh[i-1] = a(x)->sh[i];
|
||||
dec(x);
|
||||
return taga(r);
|
||||
}
|
||||
@ -233,8 +227,8 @@ B select_c2(B t, B w, B x) {
|
||||
usz csz = arr_csz(x);
|
||||
usz cam = a(x)->sh[0];
|
||||
usz wi = WRAP(o2i64(w), cam, thrF("⊏: Indexing out-of-bounds (𝕨≡%R, %s≡≠𝕩)", w, cam));
|
||||
Arr* r = TI(x,slice)(inc(x), wi*csz);
|
||||
usz* sh = arr_shAllocI(r, csz, xr-1);
|
||||
Arr* r = TI(x,slice)(inc(x), wi*csz, csz);
|
||||
usz* sh = arr_shAlloc(r, xr-1);
|
||||
if (sh) memcpy(sh, a(x)->sh+1, (xr-1)*sizeof(usz));
|
||||
dec(x);
|
||||
return taga(r);
|
||||
@ -325,7 +319,7 @@ B select_c2(B t, B w, B x) {
|
||||
mut_copyG(r, i*csz, x, csz*(usz)c, csz);
|
||||
}
|
||||
Arr* ra = mut_fp(r);
|
||||
usz* rsh = arr_shAllocR(ra, rr);
|
||||
usz* rsh = arr_shAlloc(ra, rr);
|
||||
if (rsh) {
|
||||
memcpy(rsh , a(w)->sh , wr *sizeof(usz));
|
||||
memcpy(rsh+wr, a(x)->sh+1, (xr-1)*sizeof(usz));
|
||||
@ -464,8 +458,7 @@ B slash_c2(B t, B w, B x) {
|
||||
i32 wv = o2i(w);
|
||||
if (wv<=0) {
|
||||
if (wv<0) thrM("/: 𝕨 cannot be negative");
|
||||
Arr* r = TI(x,slice)(x, 0);
|
||||
arr_shVec(r,0);
|
||||
Arr* r = TI(x,slice)(x, 0, 0); arr_shVec(r);
|
||||
return taga(r);
|
||||
}
|
||||
if (TI(x,elType)==el_i32) {
|
||||
@ -493,8 +486,7 @@ B slash_c2(B t, B w, B x) {
|
||||
|
||||
B slicev(B x, usz s, usz ia) {
|
||||
usz xia = a(x)->ia; assert(s+ia <= xia);
|
||||
Arr* r = TI(x,slice)(x, s);
|
||||
arr_shVec(r, ia);
|
||||
Arr* r = TI(x,slice)(x, s, ia); arr_shVec(r);
|
||||
return taga(r);
|
||||
}
|
||||
extern B rt_take, rt_drop;
|
||||
@ -551,7 +543,7 @@ B join_c1(B t, B x) {
|
||||
if (ir==0) thrM("∾: Empty vector 𝕩 cannot have a unit fill element");
|
||||
B xff = getFillQ(xf);
|
||||
HArr_p r = m_harrUp(0);
|
||||
usz* sh = arr_shAllocR((Arr*)r.c, ir);
|
||||
usz* sh = arr_shAlloc((Arr*)r.c, ir);
|
||||
if (sh) {
|
||||
sh[0] = 0;
|
||||
memcpy(sh+1, a(xf)->sh+1, sizeof(usz)*(ir-1));
|
||||
@ -589,7 +581,7 @@ B join_c1(B t, B x) {
|
||||
}
|
||||
assert(ri==cam*csz);
|
||||
Arr* ra = mut_fp(r);
|
||||
usz* sh = arr_shAllocR(ra, ir);
|
||||
usz* sh = arr_shAlloc(ra, ir);
|
||||
if (sh) {
|
||||
sh[0] = cam;
|
||||
memcpy(sh+1, x0sh+1, sizeof(usz)*(ir-1));
|
||||
@ -626,7 +618,7 @@ B join_c2(B t, B w, B x) {
|
||||
mut_copyG(r, 0, w, 0, wia);
|
||||
mut_copyG(r, wia, x, 0, xia);
|
||||
Arr* ra = mut_fp(r);
|
||||
usz* sh = arr_shAllocR(ra, c);
|
||||
usz* sh = arr_shAlloc(ra, c);
|
||||
if (sh) {
|
||||
for (i32 i = 1; i < c; i++) {
|
||||
usz s = xsh[i+xr-c];
|
||||
@ -644,8 +636,8 @@ B couple_c1(B t, B x) {
|
||||
if (isArr(x)) {
|
||||
usz rr = rnk(x);
|
||||
usz ia = a(x)->ia;
|
||||
Arr* r = TI(x,slice)(inc(x),0);
|
||||
usz* sh = arr_shAllocI(r, ia, rr+1);
|
||||
Arr* r = TI(x,slice)(inc(x),0, ia);
|
||||
usz* sh = arr_shAlloc(r, rr+1);
|
||||
if (sh) { sh[0] = 1; memcpy(sh+1, a(x)->sh, rr*sizeof(usz)); }
|
||||
dec(x);
|
||||
return taga(r);
|
||||
@ -672,7 +664,7 @@ B couple_c2(B t, B w, B x) {
|
||||
mut_copyG(r, 0, w, 0, ia);
|
||||
mut_copyG(r, ia, x, 0, ia);
|
||||
Arr* ra = mut_fp(r);
|
||||
usz* sh = arr_shAllocR(ra, wr+1);
|
||||
usz* sh = arr_shAlloc(ra, wr+1);
|
||||
if (sh) { sh[0]=2; memcpy(sh+1, a(w)->sh, wr*sizeof(usz)); }
|
||||
if (!SFNS_FILLS) { dec(w); dec(x); return taga(ra); }
|
||||
B rf = fill_both(w, x);
|
||||
@ -772,14 +764,12 @@ B group_c2(B t, B w, B x) {
|
||||
len[n]++; // overallocation makes this safe after n<-1 check
|
||||
}
|
||||
|
||||
Arr* r = m_fillarrp(ria); fillarr_setFill(r, m_f64(0));
|
||||
arr_shVec(r, ria);
|
||||
Arr* r = m_fillarrp(ria); fillarr_setFill(r, m_f64(0)); arr_shVec(r);
|
||||
B* rp = fillarr_ptr(r);
|
||||
for (usz i = 0; i < ria; i++) rp[i] = m_f64(0); // don't break if allocation errors
|
||||
B xf = getFillQ(x);
|
||||
|
||||
Arr* rf = m_fillarrp(0); fillarr_setFill(rf, m_f64(0));
|
||||
arr_shVec(rf, 0);
|
||||
Arr* rf = m_fillarrp(0); fillarr_setFill(rf, m_f64(0)); arr_shVec(rf);
|
||||
fillarr_setFill(r, taga(rf));
|
||||
if (TI(x,elType)==el_i32) {
|
||||
for (usz i = 0; i < ria; i++) { i32* t; rp[i] = m_i32arrv(&t, len[i]); }
|
||||
@ -807,7 +797,7 @@ B group_c2(B t, B w, B x) {
|
||||
i32 n = wp[i];
|
||||
if (n>=0) fillarr_ptr(a(rp[n]))[pos[n]++] = xget(x, i);
|
||||
}
|
||||
for (usz i = 0; i < ria; i++) { arr_shVec(a(rp[i]), len[i]); }
|
||||
for (usz i = 0; i < ria; i++) { a(rp[i])->ia = len[i]; arr_shVec(a(rp[i])); }
|
||||
}
|
||||
fillarr_setFill(rf, xf);
|
||||
dec(w); dec(x); TFREE(lenO); TFREE(pos);
|
||||
@ -831,8 +821,7 @@ B group_c2(B t, B w, B x) {
|
||||
for (usz i = 0; i < ria; i++) len[i] = pos[i] = 0;
|
||||
for (usz i = 0; i < xia; i++) len[o2i64u(wgetU(w, i))]++;
|
||||
|
||||
Arr* r = m_fillarrp(ria); fillarr_setFill(r, m_f64(0));
|
||||
arr_shVec(r, ria);
|
||||
Arr* r = m_fillarrp(ria); fillarr_setFill(r, m_f64(0)); arr_shVec(r);
|
||||
B* rp = fillarr_ptr(r);
|
||||
for (usz i = 0; i < ria; i++) rp[i] = m_f64(0); // don't break if allocation errors
|
||||
B xf = getFillQ(x);
|
||||
@ -843,8 +832,7 @@ B group_c2(B t, B w, B x) {
|
||||
c->ia = 0;
|
||||
rp[i] = taga(c);
|
||||
}
|
||||
Arr* rf = m_fillarrp(0);
|
||||
arr_shVec(rf, 0);
|
||||
Arr* rf = m_fillarrp(0); arr_shVec(rf);
|
||||
fillarr_setFill(rf, xf);
|
||||
fillarr_setFill(r, taga(rf));
|
||||
BS2B xget = TI(x,get);
|
||||
@ -852,7 +840,7 @@ B group_c2(B t, B w, B x) {
|
||||
i64 n = o2i64u(wgetU(w, i));
|
||||
if (n>=0) fillarr_ptr(a(rp[n]))[pos[n]++] = xget(x, i);
|
||||
}
|
||||
for (usz i = 0; i < ria; i++) { arr_shVec(a(rp[i]), len[i]); }
|
||||
for (usz i = 0; i < ria; i++) { a(rp[i])->ia = len[i]; arr_shVec(a(rp[i])); }
|
||||
dec(w); dec(x); TFREE(lenO); TFREE(pos);
|
||||
return taga(r);
|
||||
}
|
||||
|
||||
@ -19,14 +19,14 @@ B m_str32(u32* s) {
|
||||
return r;
|
||||
}
|
||||
|
||||
static Arr* m_c32slice(Arr* p, u32* ptr) {
|
||||
C32Slice* r = mm_alloc(sizeof(C32Slice), t_c32slice);
|
||||
static Arr* m_c32slice(Arr* p, u32* ptr, usz ia) {
|
||||
C32Slice* r = m_arr(sizeof(C32Slice), t_c32slice, ia);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return (Arr*)r;
|
||||
}
|
||||
static Arr* c32arr_slice (B x, usz s) { return m_c32slice(a(x), c(C32Arr,x)->a+s); }
|
||||
static Arr* c32slice_slice(B x, usz s) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_c32slice(p, c(C32Slice,x)->a+s); dec(x); return r; }
|
||||
static Arr* c32arr_slice (B x, usz s, usz ia) { return m_c32slice(a(x), c(C32Arr,x)->a+s, ia); }
|
||||
static Arr* c32slice_slice(B x, usz s, usz ia) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_c32slice(p, c(C32Slice,x)->a+s, ia); dec(x); return r; }
|
||||
|
||||
static B c32arr_get (B x, usz n) { VTY(x,t_c32arr ); return m_c32(c(C32Arr ,x)->a[n]); }
|
||||
static B c32slice_get(B x, usz n) { VTY(x,t_c32slice); return m_c32(c(C32Slice,x)->a[n]); }
|
||||
@ -49,8 +49,7 @@ void c32arr_init() {
|
||||
|
||||
u32* tmp; bi_emptyCVec = m_c32arrv(&tmp, 0); gc_add(bi_emptyCVec);
|
||||
|
||||
Arr* emptySVec = m_fillarrp(0);
|
||||
arr_shVec(emptySVec, 0);
|
||||
Arr* emptySVec = m_fillarrp(0); arr_shVec(emptySVec);
|
||||
fillarr_setFill(emptySVec, emptyCVec());
|
||||
bi_emptySVec = taga(emptySVec); gc_add(bi_emptySVec);
|
||||
}
|
||||
|
||||
@ -10,19 +10,19 @@ typedef struct C32Slice {
|
||||
|
||||
#define C32A_SZ(IA) fsizeof(F64Arr,a,f64,IA)
|
||||
static B m_c32arrv(u32** p, usz ia) {
|
||||
C32Arr* r = mm_alloc(C32A_SZ(ia), t_c32arr);
|
||||
C32Arr* r = m_arr(C32A_SZ(ia), t_c32arr, ia);
|
||||
arr_shVec((Arr*)r);
|
||||
*p = r->a;
|
||||
arr_shVec((Arr*)r, ia);
|
||||
return taga(r);
|
||||
}
|
||||
static B m_c32arrc(u32** p, B x) { assert(isArr(x));
|
||||
C32Arr* r = mm_alloc(C32A_SZ(a(x)->ia), t_c32arr);
|
||||
C32Arr* r = m_arr(C32A_SZ(a(x)->ia), t_c32arr, a(x)->ia);
|
||||
*p = r->a;
|
||||
arr_shCopy((Arr*)r, x);
|
||||
return taga(r);
|
||||
}
|
||||
static Arr* m_c32arrp(u32** p, usz ia) { // doesn't write shape/rank
|
||||
C32Arr* r = mm_alloc(C32A_SZ(ia), t_c32arr);
|
||||
C32Arr* r = m_arr(C32A_SZ(ia), t_c32arr, ia);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return (Arr*)r;
|
||||
|
||||
@ -6,14 +6,14 @@ NOINLINE B m_caf64(usz sz, f64* a) {
|
||||
return r;
|
||||
}
|
||||
|
||||
static Arr* m_f64slice(Arr* p, f64* ptr) {
|
||||
F64Slice* r = mm_alloc(sizeof(F64Slice), t_f64slice);
|
||||
static Arr* m_f64slice(Arr* p, f64* ptr, usz ia) {
|
||||
F64Slice* r = m_arr(sizeof(F64Slice), t_f64slice, ia);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return (Arr*)r;
|
||||
}
|
||||
static Arr* f64arr_slice (B x, usz s) { return m_f64slice(a(x), c(F64Arr ,x)->a+s); }
|
||||
static Arr* f64slice_slice(B x, usz s) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_f64slice(p, c(F64Slice,x)->a+s); dec(x); return r; }
|
||||
static Arr* f64arr_slice (B x, usz s, usz ia) { return m_f64slice(a(x), c(F64Arr ,x)->a+s, ia); }
|
||||
static Arr* f64slice_slice(B x, usz s, usz ia) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_f64slice(p, c(F64Slice,x)->a+s, ia); dec(x); return r; }
|
||||
|
||||
static B f64arr_get (B x, usz n) { VTY(x,t_f64arr ); return m_f64(c(F64Arr ,x)->a[n]); }
|
||||
static B f64slice_get(B x, usz n) { VTY(x,t_f64slice); return m_f64(c(F64Slice,x)->a[n]); }
|
||||
|
||||
@ -9,19 +9,19 @@ typedef struct F64Slice {
|
||||
|
||||
#define F64A_SZ(IA) fsizeof(F64Arr,a,f64,IA)
|
||||
static B m_f64arrv(f64** p, usz ia) {
|
||||
F64Arr* r = mm_alloc(F64A_SZ(ia), t_f64arr);
|
||||
F64Arr* r = m_arr(F64A_SZ(ia), t_f64arr, ia);
|
||||
arr_shVec((Arr*)r);
|
||||
*p = r->a;
|
||||
arr_shVec((Arr*)r, ia);
|
||||
return taga(r);
|
||||
}
|
||||
static B m_f64arrc(f64** p, B x) { assert(isArr(x));
|
||||
F64Arr* r = mm_alloc(F64A_SZ(a(x)->ia), t_f64arr);
|
||||
F64Arr* r = m_arr(F64A_SZ(a(x)->ia), t_f64arr, a(x)->ia);
|
||||
*p = r->a;
|
||||
arr_shCopy((Arr*)r, x);
|
||||
return taga(r);
|
||||
}
|
||||
static Arr* m_f64arrp(f64** p, usz ia) { // doesn't write shape/rank
|
||||
F64Arr* r = mm_alloc(F64A_SZ(ia), t_f64arr);
|
||||
F64Arr* r = m_arr(F64A_SZ(ia), t_f64arr, ia);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return (Arr*)r;
|
||||
|
||||
@ -31,14 +31,14 @@ B asFill(B x) { // consumes
|
||||
return bi_noFill;
|
||||
}
|
||||
|
||||
static Arr* m_fillslice(Arr* p, B* ptr) {
|
||||
FillSlice* r = mm_alloc(sizeof(FillSlice), t_fillslice);
|
||||
static Arr* m_fillslice(Arr* p, B* ptr, usz ia) {
|
||||
FillSlice* r = m_arr(sizeof(FillSlice), t_fillslice, ia);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return (Arr*)r;
|
||||
}
|
||||
static Arr* fillarr_slice (B x, usz s) { return m_fillslice(a(x), c(FillArr,x)->a+s); }
|
||||
static Arr* fillslice_slice(B x, usz s) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_fillslice(p, c(FillSlice,x)->a+s); dec(x); return r; }
|
||||
static Arr* fillarr_slice (B x, usz s, usz ia) { return m_fillslice(a(x), c(FillArr,x)->a+s, ia); }
|
||||
static Arr* fillslice_slice(B x, usz s, usz ia) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_fillslice(p, c(FillSlice,x)->a+s, ia); dec(x); return r; }
|
||||
|
||||
static B fillarr_get (B x, usz n) { VTY(x,t_fillarr ); return inc(c(FillArr ,x)->a[n]); }
|
||||
static B fillslice_get (B x, usz n) { VTY(x,t_fillslice); return inc(c(FillSlice,x)->a[n]); }
|
||||
@ -201,7 +201,7 @@ B withFill(B x, B fill) { // consumes both
|
||||
return r;
|
||||
}
|
||||
base:;
|
||||
FillArr* r = mm_alloc(fsizeof(FillArr,a,B,ia), t_fillarr);
|
||||
FillArr* r = m_arr(fsizeof(FillArr,a,B,ia), t_fillarr, ia);
|
||||
arr_shCopy((Arr*)r, x);
|
||||
r->fill = fill;
|
||||
if (xt==t_harr | xt==t_hslice) {
|
||||
|
||||
@ -59,8 +59,8 @@ static B getFillE(B x) { // errors if there's no fill
|
||||
}
|
||||
|
||||
|
||||
static Arr* m_fillarrp(usz ia) { // doesn't set ia
|
||||
return mm_alloc(fsizeof(FillArr,a,B,ia), t_fillarr);
|
||||
static Arr* m_fillarrp(usz ia) {
|
||||
return m_arr(fsizeof(FillArr,a,B,ia), t_fillarr, ia);
|
||||
}
|
||||
static void fillarr_setFill(Arr* x, B fill) { assert(x->type==t_fillarr); ((FillArr*)x)->fill = fill; } // consumes fill
|
||||
static B* fillarr_ptr(Arr* x) { assert(x->type==t_fillarr); return ((FillArr*)x)->a; }
|
||||
@ -70,12 +70,12 @@ static B m_unit(B x) {
|
||||
B xf = asFill(inc(x));
|
||||
if (noFill(xf)) {
|
||||
HArr_p r = m_harrUp(1);
|
||||
arr_shAllocR((Arr*)r.c, 0);
|
||||
arr_shAlloc((Arr*)r.c, 0);
|
||||
r.a[0] = x;
|
||||
return r.b;
|
||||
}
|
||||
FillArr* r = mm_alloc(fsizeof(FillArr,a,B,1), t_fillarr);
|
||||
arr_shAllocI((Arr*)r, 1, 0);
|
||||
FillArr* r = m_arr(fsizeof(FillArr,a,B,1), t_fillarr, 1);
|
||||
arr_shAlloc((Arr*)r, 0);
|
||||
r->fill = xf;
|
||||
r->a[0] = x;
|
||||
return taga(r);
|
||||
@ -86,13 +86,13 @@ static B m_atomUnit(B x) {
|
||||
Arr* r;
|
||||
if (q_i32(x)) { i32* rp; r = m_i32arrp(&rp, 1); rp[0] = o2iu(x); }
|
||||
else { f64* rp; r = m_f64arrp(&rp, 1); rp[0] = o2fu(x); }
|
||||
arr_shAllocR(r, 0);
|
||||
arr_shAlloc(r, 0);
|
||||
return taga(r);
|
||||
}
|
||||
if (isC32(x)) {
|
||||
u32* rp; Arr* r = m_c32arrp(&rp, 1);
|
||||
rp[0] = o2cu(x);
|
||||
arr_shAllocR(r,0);
|
||||
arr_shAlloc(r,0);
|
||||
return taga(r);
|
||||
}
|
||||
return m_unit(x);
|
||||
|
||||
@ -8,13 +8,12 @@ B toCells(B x) {
|
||||
usz cam = a(x)->sh[0];
|
||||
usz csz = arr_csz(x);
|
||||
usz i = 0;
|
||||
BS2A slice = TI(x,slice);
|
||||
BSS2A slice = TI(x,slice);
|
||||
usz p = 0;
|
||||
HArr_p r = m_harrs(cam, &i);
|
||||
if (rnk(x)==2) {
|
||||
for (; i < cam; i++) {
|
||||
Arr* s = slice(inc(x), p);
|
||||
arr_shVec(s, csz);
|
||||
Arr* s = slice(inc(x), p, csz); arr_shVec(s);
|
||||
r.a[i] = taga(s);
|
||||
p+= csz;
|
||||
}
|
||||
@ -24,8 +23,7 @@ B toCells(B x) {
|
||||
usz* xsh = a(x)->sh;
|
||||
for (u64 i = 0; i < cr; i++) csh->a[i] = xsh[i+1];
|
||||
for (; i < cam; i++) {
|
||||
Arr* s = slice(inc(x), p);
|
||||
arr_shSetI(s, csz, cr, csh);
|
||||
Arr* s = slice(inc(x), p, csz); arr_shSetI(s, cr, csh);
|
||||
r.a[i] = taga(s);
|
||||
p+= csz;
|
||||
}
|
||||
@ -50,10 +48,9 @@ B toKCells(B x, ur k) {
|
||||
usz i = 0;
|
||||
usz p = 0;
|
||||
HArr_p r = m_harrs(cam, &i);
|
||||
BS2A slice = TI(x,slice);
|
||||
BSS2A slice = TI(x,slice);
|
||||
for (; i < cam; i++) {
|
||||
Arr* s = slice(inc(x), p);
|
||||
arr_shSetI(s, csz, cr, csh);
|
||||
Arr* s = slice(inc(x), p, csz); arr_shSetI(s, cr, csh);
|
||||
r.a[i] = taga(s);
|
||||
p+= csz;
|
||||
}
|
||||
@ -91,14 +88,14 @@ NOINLINE void harr_pfree(B x, usz am) { // am - item after last written
|
||||
|
||||
|
||||
|
||||
static Arr* m_hslice(Arr* p, B* ptr) {
|
||||
HSlice* r = mm_alloc(sizeof(HSlice), t_hslice);
|
||||
static Arr* m_hslice(Arr* p, B* ptr, usz ia) {
|
||||
HSlice* r = m_arr(sizeof(HSlice), t_hslice, ia);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return (Arr*)r;
|
||||
}
|
||||
static Arr* harr_slice (B x, usz s) { return m_hslice(a(x), c(HArr,x)->a+s); }
|
||||
static Arr* hslice_slice(B x, usz s) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_hslice(p, c(HSlice,x)->a+s); dec(x); return r; }
|
||||
static Arr* harr_slice (B x, usz s, usz ia) { return m_hslice(a(x), c(HArr,x)->a+s, ia); }
|
||||
static Arr* hslice_slice(B x, usz s, usz ia) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_hslice(p, c(HSlice,x)->a+s, ia); dec(x); return r; }
|
||||
|
||||
static B harr_get (B x, usz n) { VTY(x,t_harr ); return inc(c(HArr ,x)->a[n]); }
|
||||
static B hslice_get (B x, usz n) { VTY(x,t_hslice); return inc(c(HSlice,x)->a[n]); }
|
||||
|
||||
@ -24,7 +24,7 @@ NOINLINE void harr_pfree(B x, usz am); // am - item after last written
|
||||
|
||||
|
||||
static HArr_p m_harrs(usz ia, usz* ctr) { // writes just ia
|
||||
HArr* r = mm_alloc(fsizeof(HArr,a,B,ia), t_harrPartial);
|
||||
HArr* r = m_arr(fsizeof(HArr,a,B,ia), t_harrPartial, ia);
|
||||
r->ia = ia;
|
||||
r->sh = ctr;
|
||||
HArr_p rp = harrP_parts(r);
|
||||
@ -57,7 +57,7 @@ static B harr_fcd(HArr_p p, B x) { VTY(p.b, t_harrPartial);
|
||||
static usz* harr_fa(HArr_p p, ur r) { VTY(p.b, t_harrPartial);
|
||||
p.c->type = t_harr;
|
||||
gsPop();
|
||||
return arr_shAllocR((Arr*)p.c, r);
|
||||
return arr_shAlloc((Arr*)p.c, r);
|
||||
}
|
||||
static void harr_abandon(HArr_p p) { VTY(p.b, t_harrPartial);
|
||||
gsPop();
|
||||
@ -65,24 +65,24 @@ static void harr_abandon(HArr_p p) { VTY(p.b, t_harrPartial);
|
||||
}
|
||||
|
||||
static HArr_p m_harrUv(usz ia) {
|
||||
HArr* r = mm_alloc(fsizeof(HArr,a,B,ia), t_harr);
|
||||
arr_shVec((Arr*)r, ia);
|
||||
HArr* r = m_arr(fsizeof(HArr,a,B,ia), t_harr, ia);
|
||||
arr_shVec((Arr*)r);
|
||||
return harrP_parts(r);
|
||||
}
|
||||
static HArr_p m_harrUc(B x) { assert(isArr(x));
|
||||
HArr* r = mm_alloc(fsizeof(HArr,a,B,a(x)->ia), t_harr);
|
||||
HArr* r = m_arr(fsizeof(HArr,a,B,a(x)->ia), t_harr, a(x)->ia);
|
||||
arr_shCopy((Arr*)r, x);
|
||||
return harrP_parts(r);
|
||||
}
|
||||
static HArr_p m_harrUp(usz ia) { // doesn't write shape/rank
|
||||
HArr* r = mm_alloc(fsizeof(HArr,a,B,ia), t_harr);
|
||||
HArr* r = m_arr(fsizeof(HArr,a,B,ia), t_harr, ia);
|
||||
r->ia = ia;
|
||||
return harrP_parts(r);
|
||||
}
|
||||
|
||||
static B m_hunit(B x) {
|
||||
HArr_p r = m_harrUp(1);
|
||||
arr_shAllocR((Arr*)r.c, 0);
|
||||
arr_shAlloc((Arr*)r.c, 0);
|
||||
r.a[0] = x;
|
||||
return r.b;
|
||||
}
|
||||
|
||||
@ -6,14 +6,14 @@ NOINLINE B m_cai32(usz ia, i32* a) {
|
||||
return r;
|
||||
}
|
||||
|
||||
static Arr* m_i32slice(Arr* p, i32* ptr) {
|
||||
I32Slice* r = mm_alloc(sizeof(I32Slice), t_i32slice);
|
||||
static Arr* m_i32slice(Arr* p, i32* ptr, usz ia) {
|
||||
I32Slice* r = m_arr(sizeof(I32Slice), t_i32slice, ia);
|
||||
r->p = p;
|
||||
r->a = ptr;
|
||||
return (Arr*)r;
|
||||
}
|
||||
static Arr* i32arr_slice (B x, usz s) { return m_i32slice(a(x), c(I32Arr,x)->a+s); }
|
||||
static Arr* i32slice_slice(B x, usz s) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_i32slice(p, c(I32Slice,x)->a+s); dec(x); return r; }
|
||||
static Arr* i32arr_slice (B x, usz s, usz ia) { return m_i32slice(a(x), c(I32Arr,x)->a+s, ia); }
|
||||
static Arr* i32slice_slice(B x, usz s, usz ia) { Arr* p=c(Slice,x)->p; ptr_inc(p); Arr* r = m_i32slice(p, c(I32Slice,x)->a+s, ia); dec(x); return r; }
|
||||
|
||||
static B i32arr_get (B x, usz n) { VTY(x,t_i32arr ); return m_i32(c(I32Arr ,x)->a[n]); }
|
||||
static B i32slice_get(B x, usz n) { VTY(x,t_i32slice); return m_i32(c(I32Slice,x)->a[n]); }
|
||||
|
||||
@ -10,21 +10,20 @@ typedef struct I32Slice {
|
||||
|
||||
#define I32A_SZ(IA) fsizeof(F64Arr,a,f64,IA)
|
||||
static B m_i32arrv(i32** p, usz ia) {
|
||||
I32Arr* r = mm_alloc(I32A_SZ(ia), t_i32arr);
|
||||
I32Arr* r = m_arr(I32A_SZ(ia), t_i32arr, ia);
|
||||
arr_shVec((Arr*)r);
|
||||
*p = r->a;
|
||||
arr_shVec((Arr*)r, ia);
|
||||
return taga(r);
|
||||
}
|
||||
static B m_i32arrc(i32** p, B x) { assert(isArr(x));
|
||||
I32Arr* r = mm_alloc(I32A_SZ(a(x)->ia), t_i32arr);
|
||||
I32Arr* r = m_arr(I32A_SZ(a(x)->ia), t_i32arr, a(x)->ia);
|
||||
*p = r->a;
|
||||
arr_shCopy((Arr*)r, x);
|
||||
return taga(r);
|
||||
}
|
||||
static Arr* m_i32arrp(i32** p, usz ia) { // doesn't write shape/rank
|
||||
I32Arr* r = mm_alloc(I32A_SZ(ia), t_i32arr);
|
||||
I32Arr* r = m_arr(I32A_SZ(ia), t_i32arr, ia);
|
||||
*p = r->a;
|
||||
r->ia = ia;
|
||||
return (Arr*)r;
|
||||
}
|
||||
|
||||
|
||||
@ -485,7 +485,7 @@ B bqn_merge(B x) { // consumes
|
||||
Arr* r = m_fillarrp(0);
|
||||
fillarr_setFill(r, xff);
|
||||
if (xr+xfr > UR_MAX) thrM(">: Result rank too large");
|
||||
usz* rsh = arr_shAllocI(r, 0, xr+xfr);
|
||||
usz* rsh = arr_shAlloc(r, xr+xfr);
|
||||
if (rsh) {
|
||||
memcpy (rsh , a(x)->sh, xr *sizeof(usz));
|
||||
if(xfr)memcpy(rsh+xr, a(xf)->sh, xfr*sizeof(usz));
|
||||
@ -513,7 +513,7 @@ B bqn_merge(B x) { // consumes
|
||||
rp+= elIA;
|
||||
}
|
||||
Arr* ra = mut_fp(r);
|
||||
usz* rsh = arr_shAllocR(ra, xr+elR);
|
||||
usz* rsh = arr_shAlloc(ra, xr+elR);
|
||||
if (rsh) {
|
||||
memcpy (rsh , a(x)->sh, xr *sizeof(usz));
|
||||
if (elSh)memcpy(rsh+xr, elSh, elR*sizeof(usz));
|
||||
|
||||
@ -29,40 +29,39 @@ static void decSh(Value* x) { if (RARE(prnk(x)>1)) ptr_dec(shObjP(x));}
|
||||
|
||||
#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; })
|
||||
|
||||
static inline void* m_arr(u64 sz, u8 type, usz ia) {
|
||||
Arr* r = mm_alloc(sz, type);
|
||||
r->ia = ia;
|
||||
return r;
|
||||
}
|
||||
static ShArr* m_shArr(ur r) {
|
||||
assert(r>1);
|
||||
return ((ShArr*)mm_alloc(fsizeof(ShArr, a, usz, r), t_shape));
|
||||
}
|
||||
|
||||
static void arr_shVec(Arr* x, usz ia) {
|
||||
x->ia = ia;
|
||||
static void arr_shVec(Arr* x) {
|
||||
sprnk(x, 1);
|
||||
x->sh = &x->ia;
|
||||
}
|
||||
static usz* arr_shAllocR(Arr* x, ur r) { // allocates shape, sets rank
|
||||
static usz* arr_shAlloc(Arr* x, ur r) { // sets rank, allocates & returns shape (or null if r<2)
|
||||
sprnk(x,r);
|
||||
if (r>1) return x->sh = m_shArr(r)->a;
|
||||
x->sh = &x->ia;
|
||||
return 0;
|
||||
return NULL;
|
||||
}
|
||||
static usz* arr_shAllocI(Arr* x, usz ia, ur r) { // allocates shape, sets ia,rank
|
||||
x->ia = ia;
|
||||
return arr_shAllocR(x, r);
|
||||
}
|
||||
static void arr_shSetI(Arr* x, usz ia, ur r, ShArr* sh) {
|
||||
static void arr_shSetI(Arr* x, ur r, ShArr* sh) { // set rank and assign and increment shape if needed
|
||||
sprnk(x,r);
|
||||
x->ia = ia;
|
||||
if (r>1) { x->sh = sh->a; ptr_inc(sh); }
|
||||
else { x->sh = &x->ia; }
|
||||
}
|
||||
static void arr_shSetU(Arr* x, ur r, ShArr* sh) {
|
||||
static void arr_shSetU(Arr* x, ur r, ShArr* sh) { // set rank and assign shape
|
||||
sprnk(x,r);
|
||||
if (r>1) { x->sh = sh->a; }
|
||||
else { x->sh = &x->ia; }
|
||||
}
|
||||
static void arr_shCopy(Arr* n, B o) { // copy shape,rank,ia from o to n
|
||||
static void arr_shCopy(Arr* n, B o) { // copy shape & rank from o to n
|
||||
assert(isArr(o));
|
||||
n->ia = a(o)->ia;
|
||||
assert(a(o)->ia==n->ia);
|
||||
ur r = sprnk(n,rnk(o));
|
||||
if (r<=1) {
|
||||
n->sh = &n->ia;
|
||||
|
||||
4
src/h.h
4
src/h.h
@ -354,7 +354,7 @@ void slice_print(B x);
|
||||
|
||||
typedef bool (* B2b)(B);
|
||||
typedef void (* B2v)(B);
|
||||
typedef Arr* (* BS2A)(B, usz);
|
||||
typedef Arr* (*BSS2A)(B, usz, usz);
|
||||
typedef B (* BS2B)(B, usz);
|
||||
typedef B (* BSS2B)(B, usz, usz);
|
||||
typedef B (* B2B)(B);
|
||||
@ -370,7 +370,7 @@ typedef B (*BBBBBB2B)(B, B, B, B, B, B);
|
||||
F(BS2B, getU) /* like get, but doesn't increment result (mostly equivalent to `B t=get(…); dec(t); t`) */ \
|
||||
F(BB2B, m1_d) /* consume all args; (m, f) */ \
|
||||
F(BBB2B, m2_d) /* consume all args; (m, f, g) */ \
|
||||
F(BS2A, slice) /* consumes; create slice from given starting position; add ia, rank, shape yourself; may not actually be a Slice object; preserves fill */ \
|
||||
F(BSS2A, slice) /* consumes; create slice from given starting position and length; add shape & rank yourself; may not actually be a Slice object; preserves fill */ \
|
||||
F(B2B, identity) /* return identity element of this function; doesn't consume */ \
|
||||
\
|
||||
F( BBB2B, fn_uc1) /* t,o, x→r; r≡O⌾( T ) x; consumes x */ \
|
||||
|
||||
@ -180,7 +180,8 @@ static void* nvm_alloc(u64 sz) {
|
||||
// if (r==MAP_FAILED) thrM("JIT: Failed to allocate executable memory");
|
||||
// return r;
|
||||
TmpFile* src = mmX_allocN(fsizeof(TmpFile,a,u8,sz), t_i8arr);
|
||||
arr_shVec((Arr*)src, sz);
|
||||
src->ia = sz;
|
||||
arr_shVec((Arr*)src);
|
||||
return src->a;
|
||||
}
|
||||
void nvm_free(u8* ptr) {
|
||||
|
||||
@ -374,7 +374,7 @@ static B def_identity(B f) { return bi_N; }
|
||||
static B def_get(B x, usz n) { return inc(x); }
|
||||
static B def_m1_d(B m, B f ) { thrM("cannot derive this"); }
|
||||
static B def_m2_d(B m, B f, B g) { thrM("cannot derive this"); }
|
||||
static Arr* def_slice(B x, usz s) { thrM("cannot slice non-array!"); }
|
||||
static Arr* def_slice(B x, usz s, usz ia) { thrM("cannot slice non-array!"); }
|
||||
|
||||
#ifdef DONT_FREE
|
||||
static B empty_get(B x, usz n) {
|
||||
|
||||
@ -30,8 +30,7 @@ TmpFile* file_bytes(B path) { // consumes
|
||||
fseek(f, 0, SEEK_END);
|
||||
u64 len = ftell(f);
|
||||
fseek(f, 0, SEEK_SET);
|
||||
TmpFile* src = mm_alloc(fsizeof(TmpFile,a,u8,len), t_i8arr);
|
||||
arr_shVec((Arr*)src, len);
|
||||
TmpFile* src = m_arr(fsizeof(TmpFile,a,u8,len), t_i8arr, len); arr_shVec((Arr*)src);
|
||||
if (fread((char*)src->a, 1, len, f)!=len) thrF("Error reading file \"%R\"", path);
|
||||
dec(path);
|
||||
fclose(f);
|
||||
@ -101,8 +100,7 @@ B path_dir(B path) { // consumes; returns directory part of file path with trail
|
||||
for (usz i = 0; i < pia; i++) if (!isC32(pgetU(path, i))) thrM("Paths must be character vectors");
|
||||
for (i64 i = (i64)pia-1; i >= 0; i--) {
|
||||
if (o2cu(pgetU(path, i))=='/') {
|
||||
Arr* r = TI(path,slice)(path, 0);
|
||||
arr_shVec(r, i+1);
|
||||
Arr* r = TI(path,slice)(path, 0, i+1); arr_shVec(r);
|
||||
return taga(r);
|
||||
}
|
||||
}
|
||||
|
||||
2
src/vm.c
2
src/vm.c
@ -955,7 +955,7 @@ NOINLINE B vm_fmtPoint(B src, B prepend, B path, usz cs, usz ce) { // consumes p
|
||||
i64 padStart = padEnd;
|
||||
while (padStart>0 && o2cu(srcGetU(s,padStart-1))!='\n') padStart--;
|
||||
|
||||
Arr* slice = TI(src,slice)(inc(src),srcS); arr_shVec(slice, srcE-srcS);
|
||||
Arr* slice = TI(src,slice)(inc(src),srcS, srcE-srcS); arr_shVec(slice);
|
||||
AJOIN(taga(slice));
|
||||
cs-= srcS;
|
||||
ce-= srcS;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user