add GLOBAL, INIT_GLOBAL, or const to globals

This commit is contained in:
dzaima 2024-01-28 16:25:14 +02:00
parent 6e39b59e73
commit c078f62b1f
55 changed files with 320 additions and 320 deletions

View File

@ -730,7 +730,7 @@ cachedBin‿linkerCache ← {
vnameXvname {po.versionName""? "on " "commit "("??"GitCmd "rev-parse", "HEAD"){"""determining version"GitCmd "status", "--porcelain", "src"? ""; "-dirty"}; ˜ po.versionName}
src
"char* cbqn_versionInfo = """
"char* const cbqn_versionInfo = """
"\n"¨ ר/
"CBQN "vnameX
@ -745,7 +745,7 @@ cachedBin‿linkerCache ← {
# "build invocation: "⊸∾⍟(×≠) ¯1↓∾∾⟜' '¨ •args
""";", @+10
"char* cbqn_versionString = """vname""";", @+10
"char* const cbqn_versionString = """vname""";", @+10
{
•file.Exists AtRoot srcFile? src•FChars AtRoot srcFile? @; # don't update

View File

@ -52,8 +52,7 @@ enum PrimNumbers {
/* ´˝`∘○⊸⟜⌾⊘◶ */ n_fold , n_insert , n_scan , n_atop , n_over , n_before , n_after , n_under, n_val , n_cond,
/* ⎉⚇⍟⎊ */ n_rank , n_depth , n_repeat, n_catch
};
extern FC1 rt_invFnRegFn;
extern FC1 rt_invFnSwapFn;
extern GLOBAL FC1 rt_invFnRegFn, rt_invFnSwapFn;
#ifdef RT_WRAP
@ -102,7 +101,7 @@ static bool isPervasiveDyExt(B x) {
return false;
}
extern B
extern GLOBAL B
#define F(N,X) bi_##N,
FOR_PFN(F,F,F)
FOR_PM1(F,F,F)

View File

@ -25,7 +25,7 @@ B leading_axis_arith(FC2 fc2, B w, B x, usz* wsh, usz* xsh, ur mr);
#if SINGELI_SIMD
#include "../singeli/c/arithdDispatch.c"
static AndBytesFn andBytes_fn = simd_andBytes;
static const AndBytesFn andBytes_fn = simd_andBytes;
#else
static void base_andBytes(u8* r, u8* x, u64 repeatedMask, u64 numBytes) {
u64* x64 = (u64*)x; usz i;
@ -35,7 +35,7 @@ B leading_axis_arith(FC2 fc2, B w, B x, usz* wsh, usz* xsh, ur mr);
for (usz j = 0; j < (numBytes&7); j++) r[i*8 + j] = v>>(j*8);
}
}
static AndBytesFn andBytes_fn = base_andBytes;
static const AndBytesFn andBytes_fn = base_andBytes;
#endif
B floor_c1(B t, B x);
@ -180,7 +180,7 @@ static B modint_AS(B w, B xv) { return modint_AA(w, C2(shape, C1(fne, incG(w))
GC2f("", root , pow(x.f+0, 1.0/(w.f+0)), NOUNROLL,,,,,)
GC2f("", pow , pow(w.f+0, x.f), NOUNROLL,,,,,)
GC2f("⋆⁼",log , log(x.f)/log(w.f), NOUNROLL,,,,,)
static u64 repeatNum[] = {
static u64 const repeatNum[] = {
[el_i8 ] = 0x0101010101010101ULL,
[el_i16] = 0x0001000100010001ULL,
[el_i32] = 0x0000000100000001ULL,

View File

@ -163,7 +163,7 @@ B eq_c1(B t, B x) { if (isAtm(x)) { decA(x); return m_i32(0); } B r = m_i32(RNK(
B ne_c1(B t, B x) { if (isAtm(x)) { decA(x); return m_i32(1); } B r = m_f64(*SH(x)); decG(x); return r; }
static B mathNS;
static GLOBAL B mathNS;
B getMathNS(void) {
if (mathNS.u == 0) {
#define F(X) incG(bi_##X),

View File

@ -48,7 +48,7 @@ CMP_REC(ne, ne, swapped=0;)
#undef CMP_REC
#define CMPFN(A,F,S,T) A##_##F##S##_##T
#define FN_LUT_T(B,F,S,...) Cmp##S##Fn B##_##F##S
#define FN_LUT_T(B,F,S,...) INIT_GLOBAL Cmp##S##Fn B##_##F##S
#define FN_LUT_C(B,A,F,S) FN_LUT_T(B,F,S)[] = {CMPFN(A,F,S,u1), CMPFN(A,F,S,i8), CMPFN(A,F,S,i16), CMPFN(A,F,S,i32), CMPFN(A,F,S,f64), CMPFN(A,F,S,u8), CMPFN(A,F,S,u16), CMPFN(A,F,S,u32)}
#define FN_LUT_A(B,F,S) FN_LUT_T(B,F,S)[8]

View File

@ -89,7 +89,7 @@ bool atomEEqual(B w, B x) { // doesn't consume
// Functions in eqFns compare segments for matching
// data argument comes from eqFnData
static const u8 n = 99;
u8 eqFnData[] = { // for the main diagonal, amount to shift length by; otherwise, whether to swap arguments
u8 const eqFnData[] = { // for the main diagonal, amount to shift length by; otherwise, whether to swap arguments
0,0,0,0,0,n,n,n,
1,0,0,0,0,n,n,n,
1,1,1,0,0,n,n,n,
@ -144,7 +144,7 @@ u8 eqFnData[] = { // for the main diagonal, amount to shift length by; otherwise
#undef DEF_EQ
#endif
bool notEq(void* a, void* b, u64 l, u64 data) { return false; }
EqFn eqFns[] = {
INIT_GLOBAL EqFn eqFns[] = {
F(1_1), F(1_8), F(1_16), F(1_32), F(1_f64), notEq, notEq, notEq,
F(1_8), F(8_8), F(s8_16), F(s8_32), F(s8_f64), notEq, notEq, notEq,
F(1_16), F(s8_16), F(8_8), F(s16_32), F(s16_f64), notEq, notEq, notEq,

View File

@ -91,8 +91,8 @@ NOINLINE B list_range(B x) {
return taga(r);
}
Arr* bitUD[3];
B bit2x[2]; // ⟨0‿1 ⋄ 1‿0⟩
GLOBAL Arr* bitUD[3];
GLOBAL B bit2x[2]; // ⟨0‿1 ⋄ 1‿0⟩
B ud_c1(B t, B x) {
if (!isAtm(x)) return list_range(x);
usz xu = o2s(x);
@ -229,7 +229,7 @@ NOINLINE B for_cells_SA(B f, B w, B x, ur xcr, ur xr, u32 chr); // from cells.c
B eq_c2(B, B, B);
B feq_c2(B, B, B);
B slash_c1(B, B);
extern B rt_find;
extern GLOBAL B rt_find;
B find_c2(B t, B w, B x) {
ur wr = isAtm(w) ? 0 : RNK(w);
ur xr = isAtm(x) ? 0 : RNK(x);
@ -303,8 +303,8 @@ B find_c2(B t, B w, B x) {
decG(x); decG(w); return r;
}
static H_b2i* globalNames;
B globalNameList;
static GLOBAL H_b2i* globalNames;
GLOBAL B globalNameList;
i32 str2gid(B s) {
if (globalNames==NULL) {
globalNames = m_b2i(32);

View File

@ -345,7 +345,7 @@ static B m1c1(B t, B f, B x) { // consumes x
decG(fn);
return r;
}
extern B rt_insert;
extern GLOBAL B rt_insert;
extern B insert_base(B f, B x, bool has_w, B w); // from cells.c
B insert_c1(Md1D* d, B x) { B f = d->f;

View File

@ -254,8 +254,8 @@ B SORT_C1(B t, B x) {
#endif
extern Arr* bitUD[3]; // from fns.c
extern B bit2x[2];
extern GLOBAL Arr* bitUD[3]; // from fns.c
extern GLOBAL B bit2x[2];
extern B grade_bool(B x, usz ia, bool up); // slash.c
#define GRADE_CHR GRADE_UD("⍋","⍒")

View File

@ -259,7 +259,7 @@ static B group_simple(B w, B x, ur xr, usz wia, usz xn, usz* xsh, u8 we) {
return taga(r);
}
extern B rt_group;
extern GLOBAL B rt_group;
B group_c2(B t, B w, B x) {
if (isAtm(x)) thrM("⊔: 𝕩 must be an array");
ur xr = RNK(x);

View File

@ -79,10 +79,10 @@ B info_c1(B t, B x) {
F(Af) F(Sf) F(AfInc) F(SfInc) \
F(Ab) F(AbInc)
#define F(X) static B v_##X;
#define F(X) static GLOBAL B v_##X;
FOR_VARIATION(F)
#undef F
static B listVariations_def;
static GLOBAL B listVariations_def;
B listVariations_c2(B t, B w, B x) {
if (!isArr(x)) thrM("•internal.ListVariations: 𝕩 must be an array");
@ -162,7 +162,7 @@ static bool u8_get(u8** cv, u8* cE, const char* x) {
}
static B variation_refs;
static GLOBAL B variation_refs;
B variation_c2(B t, B w, B x) {
if (!isArr(w)) thrM("•internal.Variation: Non-array 𝕨");
if (!isArr(x)) thrM("•internal.Variation: Non-array 𝕩");
@ -380,7 +380,7 @@ B unshare_c1(B t, B x) {
dec(x);
return r;
}
static B internalNS;
static GLOBAL B internalNS;
B getInternalNS(void) {
if (internalNS.u == 0) {
#define F(X) v_##X = m_c8vec_0(#X);

View File

@ -3,14 +3,14 @@
#include "../nfns.h"
static NFnDesc* fn_invRegDesc;
static NFnDesc* fn_invSwapDesc;
static GLOBAL NFnDesc* fn_invRegDesc;
static GLOBAL NFnDesc* fn_invSwapDesc;
B fn_invReg_c1 (B t, B x) { B f = nfn_objU(t); return TI(f, fn_im)(f, x); }
B fn_invReg_c2 (B t, B w, B x) { B f = nfn_objU(t); return TI(f, fn_ix)(f, w, x); }
B fn_invSwap_c1(B t, B x) { B f = nfn_objU(t); return TI(f, fn_is)(f, x); }
B fn_invSwap_c2(B t, B w, B x) { B f = nfn_objU(t); return TI(f, fn_iw)(f, w, x); }
extern B rt_undo;
extern GLOBAL B rt_undo;
B undo_c1(Md1D* d, B x) { B f = d->f;
if (isFun(f)) return TI(f, fn_im)(f, x);
SLOW1("!runtime undo", x);

View File

@ -8,7 +8,7 @@ B val_c1(Md2D* d, B x) { return c1(d->f, x); }
B val_c2(Md2D* d, B w, B x) { return c2(d->g, w,x); }
#if CATCH_ERRORS && !BI_CATCH_DISABLED
extern B lastErrMsg; // sysfn.c
extern GLOBAL B lastErrMsg; // sysfn.c
B fillBy_c1(Md2D* d, B x) {
B xf=getFillQ(x);
@ -53,7 +53,7 @@ B catch_c1(Md2D* d, B x) { return c1(d->f, x); }
B catch_c2(Md2D* d, B w, B x) { return c2(d->f, w,x); }
#endif
extern B rt_undo;
extern GLOBAL B rt_undo;
void repeat_bounds(i64* bound, B g) { // doesn't consume
#define UPD_BOUNDS(I) ({ i64 i_ = (I); if (i_<bound[0]) bound[0] = i_; if (i_>bound[1]) bound[1] = i_; })
if (isArr(g)) {
@ -218,7 +218,7 @@ B depthf_c2(B t, B w, B x) {
if (isArr(w) || isArr(x)) return eachd_fn(t, w, x, depthf_c2);
else return c2(t, w, x);
}
extern B rt_depth;
extern GLOBAL B rt_depth;
B depth_c1(Md2D* d, B x) {
if (isF64(d->g) && o2fG(d->g)==0) {
if (isArr(x)) return eachm_fn(d->f, x, depthf_c1);

View File

@ -44,7 +44,7 @@ extern NOINLINE void memset64(u64* p, u64 v, usz l) { for (usz i=0; i<l; i++) p[
#define memset_i16(P,V,L) memset16((u16*)(P), V, L)
#define memset_i32(P,V,L) memset32((u32*)(P), V, L)
RangeFn getRange_fns[el_f64+1];
INIT_GLOBAL RangeFn getRange_fns[el_f64+1];
#if SINGELI
extern RangeFn* const simd_getRangeRaw;
#define SINGELI_FILE search
@ -356,7 +356,7 @@ B indexOf_c2(B t, B w, B x) {
}
}
B enclosed_0, enclosed_1;
GLOBAL B enclosed_0, enclosed_1;
B memberOf_c2(B t, B w, B x) {
bool split = 0; (void) split;
if (isAtm(x) || RNK(x)!=1) {

View File

@ -58,7 +58,7 @@ static void cf_1(void* r, ux rs, void* x, ux xs, ux d) { r=rs+(u8*)r; x=xs+(u8*)
static void cf_2(void* r, ux rs, void* x, ux xs, ux d) { r=rs+(u8*)r; x=xs+(u8*)x; memcpy(r, x, 2); }
static void cf_3(void* r, ux rs, void* x, ux xs, ux d) { r=rs+(u8*)r; x=xs+(u8*)x; memcpy(r, x, 3); }
static void cf_4(void* r, ux rs, void* x, ux xs, ux d) { r=rs+(u8*)r; x=xs+(u8*)x; memcpy(r, x, 4); }
static CFn cfs_0_4[] = {cf_0, cf_1, cf_2, cf_3, cf_4};
static CFn const cfs_0_4[] = {cf_0, cf_1, cf_2, cf_3, cf_4};
static void cf_8(void* r, ux rs, void* x, ux xs, ux d) { r=rs+(u8*)r; x=xs+(u8*)x; memcpy(r, x, 8); }
static void cf_16(void* r, ux rs, void* x, ux xs, ux d) { r=rs+(u8*)r; x=xs+(u8*)x; memcpy(r, x, 16); }
static void cf_5_7 (void* r, ux rs, void* x, ux xs, ux d) { r=rs+(u8*)r; x=xs+(u8*)x; memcpy(r, x, 4); memcpy(r+d, x+d, 4); }
@ -92,7 +92,7 @@ FORCE_INLINE void cf_call(CFRes f, void* r, ux rs, void* x, ux xs) {
f.fn(r, rs, x, xs, f.data);
}
extern B rt_select;
extern GLOBAL B rt_select;
B select_c1(B t, B x) {
if (isAtm(x)) thrM("⊏: Argument cannot be an atom");
ur xr = RNK(x);
@ -369,7 +369,7 @@ B select_c2(B t, B w, B x) {
extern u8 reuseElType[t_COUNT];
extern INIT_GLOBAL u8 reuseElType[t_COUNT];
B select_replace(u32 chr, B w, B x, B rep, usz wia, usz xia) { // rep⌾(w⊏⥊) x, assumes w is a typed (elNum) list of valid indices, only el_f64 if strictly necessary
#if CHECK_VALID
TALLOC(bool, set, xia);

View File

@ -555,7 +555,7 @@ static B compress(B w, B x, usz wia, u8 xl, u8 xt) {
} \
if (ri%64) rp[j] = rc;
extern B rt_slash;
extern GLOBAL B rt_slash;
B slash_c1(B t, B x) {
if (RARE(isAtm(x)) || RARE(RNK(x)!=1)) thrF("/: Argument must have rank 1 (%H ≡ ≢𝕩)", x);
u64 s = usum(x);

View File

@ -275,7 +275,7 @@ NOINLINE B vfyStr(B x, char* name, char* arg) {
return x;
}
B cdPath;
GLOBAL B cdPath;
static NOINLINE B prep_state(B w, char* name) { // consumes w, returns ⟨path,name,args⟩
if (!isArr(w) || RNK(w)!=1 || IA(w)>3) thrF("%U: 𝕨 must be a vector with at most 3 items, but had shape %H", name, w);
usz ia = IA(w); SGet(w)
@ -323,10 +323,10 @@ B hash_c1(B t, B x) {
static Body* rand_ns;
static B rand_rangeName; static NFnDesc* rand_rangeDesc;
static B rand_dealName; static NFnDesc* rand_dealDesc;
static B rand_subsetName; static NFnDesc* rand_subsetDesc;
static GLOBAL Body* rand_ns;
static GLOBAL B rand_rangeName; static GLOBAL NFnDesc* rand_rangeDesc;
static GLOBAL B rand_dealName; static GLOBAL NFnDesc* rand_dealDesc;
static GLOBAL B rand_subsetName; static GLOBAL NFnDesc* rand_subsetDesc;
#define RAND_START Scope* sc = c(NS,nfn_objU(t))->sc; \
u64 seed = sc->vars[0].u | sc->vars[1].u<<32;
#define RAND_END sc->vars[0].u = seed>>32; \
@ -418,8 +418,8 @@ B rand_range_c2(B t, B w, B x) {
return taga(r);
}
extern Arr* bitUD[3]; // from fns.c
extern B bit2x[2];
extern GLOBAL Arr* bitUD[3]; // from fns.c
extern GLOBAL B bit2x[2];
B intRange16(ux s, ux n);
B intRange32(ux s, ux n);
void intRange32Fill(i32* xp, ux s, ux n);
@ -649,7 +649,7 @@ B makeRand_c1(B t, B x) {
for (i32 i = 2; i < 5; i++) nfn_swapObj(sc->vars[i], incG(r));
return r;
}
static B randNS;
static GLOBAL B randNS;
B getRandNS(void) {
if (randNS.u == 0) {
#if RANDSEED==0
@ -661,9 +661,9 @@ B getRandNS(void) {
}
return incG(randNS);
}
static NFnDesc* bqnDesc;
static NFnDesc* rebqnDesc;
static NFnDesc* rebqnResDesc;
static GLOBAL NFnDesc* bqnDesc;
static GLOBAL NFnDesc* rebqnDesc;
static GLOBAL NFnDesc* rebqnResDesc;
B rebqn_c1(B t, B x) {
if (!isNsp(x)) thrM("•ReBQN: Argument must be a namespace");
B repl = ns_getC(x, "repl");
@ -696,7 +696,7 @@ B repl_c1(B t, B x) {
}
#if CATCH_ERRORS
B lastErrMsg;
GLOBAL B lastErrMsg;
B currentError_c1(B t, B x) {
if (isNsp(x)) thrM("•CurrentError: Namespace 𝕩 is reserved");
dec(x);
@ -707,14 +707,14 @@ B currentError_c1(B t, B x) {
B currentError_c1(B t, B x) { thrM("•CurrentError: No errors as error catching has been disabled"); }
#endif
static Body* hashmap_ns;
static NFnDesc* hashmap_getDesc;
static NFnDesc* hashmap_hasDesc;
static NFnDesc* hashmap_setDesc;
static NFnDesc* hashmap_deleteDesc;
static NFnDesc* hashmap_countDesc;
static NFnDesc* hashmap_keysDesc;
static NFnDesc* hashmap_valuesDesc;
static GLOBAL Body* hashmap_ns;
static GLOBAL NFnDesc* hashmap_getDesc;
static GLOBAL NFnDesc* hashmap_hasDesc;
static GLOBAL NFnDesc* hashmap_setDesc;
static GLOBAL NFnDesc* hashmap_deleteDesc;
static GLOBAL NFnDesc* hashmap_countDesc;
static GLOBAL NFnDesc* hashmap_keysDesc;
static GLOBAL NFnDesc* hashmap_valuesDesc;
// Hash object handling defined in search.c
extern B hashmap_build(B keys, usz n);
extern B hashmap_lookup(B* vars, B w, B x);
@ -761,7 +761,7 @@ B hashMap_c2(B t, B w, B x) {
return ns;
}
static NFnDesc* fileAtDesc;
static GLOBAL NFnDesc* fileAtDesc;
B fileAt_c1(B d, B x) {
return path_rel(nfn_objU(d), x, "•file.At");
}
@ -771,7 +771,7 @@ B fileAt_c2(B d, B w, B x) {
dec(w);
return r;
}
static NFnDesc* fCharsDesc;
static GLOBAL NFnDesc* fCharsDesc;
B fchars_c1(B d, B x) {
return path_chars(path_rel(nfn_objU(d), x, "•file.Chars"));
}
@ -782,7 +782,7 @@ B fchars_c2(B d, B w, B x) {
dec(x);
return p;
}
static NFnDesc* fBytesDesc;
static GLOBAL NFnDesc* fBytesDesc;
B fbytes_c1(B d, B x) {
I8Arr* tf = path_bytes(path_rel(nfn_objU(d), x, "•file.Bytes"));
usz ia = PIA(tf);
@ -798,7 +798,7 @@ B fbytes_c2(B d, B w, B x) {
dec(x);
return p;
}
static NFnDesc* fLinesDesc;
static GLOBAL NFnDesc* fLinesDesc;
B flines_c1(B d, B x) {
return path_lines(path_rel(nfn_objU(d), x, "•file.Lines"));
}
@ -820,7 +820,7 @@ B flines_c2(B d, B w, B x) {
decG(s);
return p;
}
static NFnDesc* importDesc;
static GLOBAL NFnDesc* importDesc;
@ -863,18 +863,18 @@ B import_c1(B d, B x) {
}
static NFnDesc* fTypeDesc;
static NFnDesc* fCreatedDesc;
static NFnDesc* fAccessedDesc;
static NFnDesc* fModifiedDesc;
static NFnDesc* fSizeDesc;
static NFnDesc* fExistsDesc;
static NFnDesc* fListDesc;
static NFnDesc* fMapBytesDesc;
static NFnDesc* createdirDesc;
static NFnDesc* realpathDesc;
static NFnDesc* renameDesc;
static NFnDesc* removeDesc;
static GLOBAL NFnDesc* fTypeDesc;
static GLOBAL NFnDesc* fCreatedDesc;
static GLOBAL NFnDesc* fAccessedDesc;
static GLOBAL NFnDesc* fModifiedDesc;
static GLOBAL NFnDesc* fSizeDesc;
static GLOBAL NFnDesc* fExistsDesc;
static GLOBAL NFnDesc* fListDesc;
static GLOBAL NFnDesc* fMapBytesDesc;
static GLOBAL NFnDesc* createdirDesc;
static GLOBAL NFnDesc* realpathDesc;
static GLOBAL NFnDesc* renameDesc;
static GLOBAL NFnDesc* removeDesc;
B list_c1(B d, B x) {
return path_list(path_rel(nfn_objU(d), x, "•file.List"));
@ -1248,7 +1248,7 @@ B tErrRaw_c1(B t, B x) {
return x;
}
static B termNS;
static GLOBAL B termNS;
B getTermNS(void) {
if (termNS.u == 0) {
#define F(X) incG(bi_##X),
@ -1312,7 +1312,7 @@ B nHas_c2(B t, B w, B x) {
decG(w); decG(x);
return m_i32(!q_N(r));
}
static B nsNS;
static GLOBAL B nsNS;
B getNsNS(void) {
if (nsNS.u == 0) {
#define F(X) incG(bi_##X),
@ -1612,7 +1612,7 @@ DEF_OP2(and) DEF_OP2(or) DEF_OP2(xor)
DEF_OP2(add) DEF_OP2(sub) DEF_OP2(mul)
#undef DEF_OP2
static B bitNS;
static GLOBAL B bitNS;
B getBitNS(void) {
if (bitNS.u == 0) {
#define F(X) incG(bi_bit##X),
@ -1627,7 +1627,7 @@ B getBitNS(void) {
B getInternalNS(void);
B getMathNS(void);
static Body* file_nsGen;
static GLOBAL Body* file_nsGen;
#if FFI || FOR_BUILD
#define FFIOPT 1
@ -1691,10 +1691,10 @@ static Body* file_nsGen;
F("rebqn", U"•ReBQN", tag(22,VAR_TAG)) \
/* end of FOR_DEFAULT_SYSVALS */
NFnDesc* ffiloadDesc;
GLOBAL NFnDesc* ffiloadDesc;
B ffiload_c2(B t, B w, B x);
B indexOf_c2(B t, B w, B x);
bool fileInit;
GLOBAL bool fileInit;
B invalidFn_c1 (B t, B x) { thrM("Using an invalid function"); }
@ -1729,10 +1729,10 @@ static NOINLINE void initSysDesc() {
}
#if HAS_VERSION
extern char* cbqn_versionString;
extern char* const cbqn_versionString;
#endif
static B platformNS;
static GLOBAL B platformNS;
static B getPlatformNS(void) {
if (platformNS.u == 0) {
@ -1877,14 +1877,14 @@ B sys_c1(B t, B x) {
}
static char* dsv_strs[] = {
static char* const dsv_strs[] = {
#define F(L,N,B) L,
FOR_DEFAULT_SYSVALS(F)
#undef F
};
u32* dsv_text[] = {
u32* const dsv_text[] = {
#define F(L,N,B) N,
FOR_DEFAULT_SYSVALS(F)
#undef F
@ -1904,7 +1904,7 @@ u32* dsv_text[] = {
NULL
};
B def_sysNames, def_sysVals;
GLOBAL B def_sysNames, def_sysVals;
void sysfn_init(void) {
usz dsv_num = sizeof(dsv_strs)/sizeof(char*);
usz i = 0;

View File

@ -63,7 +63,7 @@ typedef void (*TranspFn)(void*,void*,u64,u64,u64,u64);
#define SINGELI_FILE transpose
#include "../utils/includeSingeli.h"
#else
static TranspFn transposeFns[] = {
static TranspFn const transposeFns[] = {
transpose_i8, transpose_i16, transpose_i32, transpose_i64
};
#endif

View File

@ -26,7 +26,7 @@
#include "core/arrFns.h"
#ifdef RT_VERIFY
extern B r1Objs[RT_LEN];
extern GLOBAL B r1Objs[RT_LEN];
#endif

View File

@ -49,17 +49,17 @@ SHOULD_INLINE void* m_tyarrlbp(Arr** rp, usz w, usz ia, u8 type) M_TYARR(2, , ,
SHOULD_INLINE void* m_tyarrlbv(B* rp, usz w, usz ia, u8 type) M_TYARR(2, , arr_shVec((Arr*)r);, taga(r), )
SHOULD_INLINE void* m_tyarrlbc(B* rp, usz w, B x, u8 type) M_TYARR(2, , arr_shCopy((Arr*)r,x);, taga(r), usz ia = IA(x);)
extern u8 elType2type[];
extern u8 const elType2type[];
#define el2t(X) elType2type[X] // TODO maybe reorganize array types such that this can just be addition?
extern u8 elTypeWidth[];
extern u8 const elTypeWidth[];
#define elWidth(X) elTypeWidth[X]
extern u8 elwBitLogT[];
extern u8 const elwBitLogT[];
#define elwBitLog(X) elwBitLogT[X]
extern u8 elwByteLogT[];
extern u8 const elwByteLogT[];
#define elwByteLog(X) elwByteLogT[X]
extern u8 arrTypeWidthLog[];
extern u8 const arrTypeWidthLog[];
#define arrTypeWidthLog(X) arrTypeWidthLog[X]
extern u8 arrTypeBitsLog[];
extern u8 const arrTypeBitsLog[];
#define arrTypeBitsLog(X) arrTypeBitsLog[X]
#define arrNewType(X) el2t(TIi(X,elType))

View File

@ -109,8 +109,8 @@ static B toConstant(B x) { // doesn't consume x
}
return bi_N;
}
static NFnDesc* ucwWrapDesc;
static NFnDesc* uc1WrapDesc;
static GLOBAL NFnDesc* ucwWrapDesc;
static GLOBAL NFnDesc* uc1WrapDesc;
static B fork_uc1(B t, B o, B x) {
B f = toConstant(c(Fork, t)->f);

View File

@ -7,9 +7,9 @@
#define ENV_SIZE 4096 // max recursion depth; GS_SIZE and C stack size may limit this
#endif
extern B* gStack; // points to after end
extern B* gStackStart;
extern B* gStackEnd;
extern GLOBAL B* gStack; // points to after end
extern GLOBAL B* gStackStart;
extern GLOBAL B* gStackEnd;
void print_gStack(void);
static void gsReserve(u64 am) {

View File

@ -1,10 +1,10 @@
#include "../core.h"
#if HEAP_VERIFY
u32 heapVerify_mode = -1;
GLOBAL u32 heapVerify_mode = -1;
Value* heap_observed;
Value* heap_curr;
GLOBAL Value* heap_observed;
GLOBAL Value* heap_curr;
void heapVerify_checkFn(Value* v) {
if (v->refc!=0) {
#if OBJ_COUNTER
@ -32,15 +32,15 @@ void cbqn_heapVerify() {
#endif
static u64 heap_PICounts[t_COUNT];
static u64 heap_PISizes[t_COUNT];
static GLOBAL u64 heap_PICounts[t_COUNT];
static GLOBAL u64 heap_PISizes[t_COUNT];
NOINLINE void heap_PIFn(Value* v) {
heap_PICounts[PTY(v)]++;
heap_PISizes[PTY(v)]+= mm_size(v);
}
static u64 heap_PIFreed[128];
static GLOBAL u64 heap_PIFreed[128];
void heap_PIFreedFn(Value* v) {
heap_PIFreed[v->mmInfo&127]++;
}

View File

@ -12,7 +12,7 @@ static u64 prepAllocSize(u64 sz) {
}
#define MMAP(SZ) mmap(NULL, prepAllocSize(SZ), PROT_READ|PROT_WRITE, MAP_NORESERVE|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
bool mem_log_enabled;
GLOBAL bool mem_log_enabled;
#if MM==0
#include "../opt/mm_malloc.c"

View File

@ -9,7 +9,7 @@
bool please_tail_call_err = true;
void before_exit(void);
bool inErr;
GLOBAL bool inErr;
NORETURN NOINLINE void fatal(char* s) {
NOGC_E;
#if MM!=0
@ -61,8 +61,7 @@ NOINLINE B md_c2(B t, B w, B x) { thrM("Cannot call a modifier"); }
NOINLINE B arr_c1(B t, B x) { dec(x); return inc(t); }
NOINLINE B arr_c2(B t, B w, B x) { dec(w); dec(x); return inc(t); }
extern B rt_under, bi_before;
extern GLOBAL B rt_under, bi_before;
static B rtUnder_c1(B f, B g, B x) { // consumes x
SLOW3("!runtime 𝕎⌾F 𝕩", f, x, g);
B fn = m2_d(incG(rt_under), inc(f), inc(g));
@ -87,7 +86,7 @@ B def_decompose(B x) {
return m_hvec2(m_i32(isCallable(x)? (isImpureBuiltin(x)? 1 : 0) : -1),x);
}
B bi_emptyHVec, bi_emptyIVec, bi_emptyCVec, bi_emptySVec;
GLOBAL B bi_emptyHVec, bi_emptyIVec, bi_emptyCVec, bi_emptySVec;
NOINLINE TStack* ts_e(TStack* o, u32 elsz, u64 am) { u64 size = o->size;
u64 alsz = mm_round(fsizeof(TStack, data, u8, (size+am)*elsz));
@ -469,12 +468,12 @@ B bqn_merge(B x, u32 type) {
}
#if ALLOC_STAT
u64* ctr_a = 0;
u64* ctr_f = 0;
u64 actrc = 21000;
u64 talloc = 0;
GLOBAL u64* ctr_a = 0;
GLOBAL u64* ctr_f = 0;
GLOBAL u64 actrc = 21000;
GLOBAL u64 talloc = 0;
#if ALLOC_SIZES
u32** actrs;
GLOBAL u32** actrs;
#endif
#endif
@ -518,7 +517,7 @@ Arr* g_a(B x) { return a(x); }
B g_t (void* x) { return tag(x,OBJ_TAG); }
B g_ta(void* x) { return tag(x,ARR_TAG); }
B g_tf(void* x) { return tag(x,FUN_TAG); }
bool ignore_bad_tag;
GLOBAL bool ignore_bad_tag;
void g_p(B x) { fprintI(stderr,x); fputc(10,stderr); fflush(stderr); }
void g_i(B x) { B r = info_c2(x, m_f64(1), inc(x)); fprintI(stderr,r); dec(r); fputc(10,stderr); fflush(stderr); }
void g_pv(void* x) { ignore_bad_tag=true; fprintI(stderr,tag(x,OBJ_TAG)); fputc(10,stderr); fflush(stderr); ignore_bad_tag=false; }
@ -526,7 +525,7 @@ void g_iv(void* x) { ignore_bad_tag=true; B xo = tag(x, OBJ_TAG); B r = C2(inf
void g_pst(void) { vm_pstLive(); fflush(stdout); fflush(stderr); }
#if DEBUG
bool cbqn_noAlloc;
GLOBAL bool cbqn_noAlloc;
NOINLINE void cbqn_NOGC_start() { cbqn_noAlloc=true; }
#if OBJ_COUNTER
#define PRINT_ID(X) fprintf(stderr, "Object ID: "N64u"\n", (X)->uid)
@ -572,7 +571,7 @@ void g_pst(void) { vm_pstLive(); fflush(stdout); fflush(stderr); }
#else
#define ONLY_ALWAYS
#endif
extern bool cbqn_initialized;
extern GLOBAL bool cbqn_initialized;
static void warn_ln(B x) {
if (isArr(x)) fprint_fmt(stderr, "%s items, %S, shape=%H\n", IA(x), eltype_repr(TI(x,elType)), x);
else {

View File

@ -35,8 +35,8 @@ static void decSh(Value* x) { if (RARE(PRNK(x)>1)) decShObj(shObjP(x)); }
typedef void (*M_CopyF)(void*, usz, B, usz, usz);
typedef void (*M_FillF)(void*, usz, B, usz);
extern M_CopyF copyFns[el_MAX];
extern M_FillF fillFns[el_MAX];
extern INIT_GLOBAL M_CopyF copyFns[el_MAX];
extern INIT_GLOBAL M_FillF fillFns[el_MAX];
#define COPY_TO(WHERE, ELT, MS, X, XS, LEN) copyFns[ELT](WHERE, MS, X, XS, LEN)
#define FILL_TO(WHERE, ELT, MS, X, LEN) fillFns[ELT](WHERE, MS, X, LEN)
@ -327,23 +327,23 @@ static FC2 c2fn(B f) {
// alloc stuff
#if ALLOC_STAT
extern u64* ctr_a;
extern u64* ctr_f;
extern u64 actrc;
extern u64 talloc;
extern GLOBAL u64* ctr_a;
extern GLOBAL u64* ctr_f;
extern GLOBAL u64 actrc;
extern GLOBAL u64 talloc;
#if ALLOC_SIZES
extern u32** actrs;
extern GLOBAL u32** actrs;
#endif
#endif
#ifdef OOM_TEST
extern i64 oomTestLeft;
extern GLOBAL i64 oomTestLeft;
NOINLINE NORETURN void thrOOMTest(void);
#endif
#ifdef GC_EVERY_NTH_ALLOC
extern u64 gc_depth;
extern u64 nth_alloc;
extern GLOBAL u64 gc_depth;
extern GLOBAL u64 nth_alloc;
#endif
FORCE_INLINE void preAlloc(usz sz, u8 type) {
#ifdef OOM_TEST

View File

@ -1,39 +1,39 @@
#include "../core.h"
#include "../utils/mut.h"
u8 elType2type[] = {
u8 const elType2type[] = {
[el_i8 ] = t_i8arr, [el_c8 ] = t_c8arr,
[el_i16] = t_i16arr,[el_c16] = t_c16arr,
[el_i32] = t_i32arr,[el_c32] = t_c32arr,
[el_bit] = t_bitarr,[el_f64] = t_f64arr,
[el_B] = t_invalid, [el_MAX] = t_invalid
};
u8 elTypeWidth[] = {
u8 const elTypeWidth[] = {
[el_i8 ] = 1, [el_c8 ] = 1,
[el_i16] = 2, [el_c16] = 2,
[el_i32] = 4, [el_c32] = 4,
[el_f64] = 8, [el_B ] = 8, [el_bit] = 0
};
u8 elwBitLogT[] = {
u8 const elwBitLogT[] = {
[el_i8 ] = 3, [el_c8 ] = 3,
[el_i16] = 4, [el_c16] = 4,
[el_i32] = 5, [el_c32] = 5,
[el_f64] = 6, [el_B ] = 6, [el_bit] = 0
};
u8 elwByteLogT[] = {
u8 const elwByteLogT[] = {
[el_i8 ] = 0, [el_c8 ] = 0,
[el_i16] = 1, [el_c16] = 1,
[el_i32] = 2, [el_c32] = 2,
[el_f64] = 3, [el_B ] = 3, [el_bit] = 99
};
u8 arrTypeWidthLog[] = {
u8 const arrTypeWidthLog[] = {
[t_bitarr]=0, // 0 for mut.c hack to allow restoring a bitarr offset from array pointer & arrTypeWidthLog-"corrected" element pointer
[t_i8arr ]=0, [t_i8slice ]=0, [t_c8arr ]=0, [t_c8slice ]=0,
[t_i16arr]=1, [t_i16slice]=1, [t_c16arr]=1, [t_c16slice]=1,
[t_i32arr]=2, [t_i32slice]=2, [t_c32arr]=2, [t_c32slice]=2,
[t_f64arr]=3, [t_f64slice]=3
};
u8 arrTypeBitsLog[] = {
u8 const arrTypeBitsLog[] = {
[t_bitarr]=0,
[t_i8arr ]=3, [t_i8slice ]=3, [t_c8arr ]=3, [t_c8slice ]=3,
[t_i16arr]=4, [t_i16slice]=4, [t_c16arr]=4, [t_c16slice]=4,

View File

@ -167,8 +167,8 @@ typedef struct BoundFn {
i32 xLen; // 0: length 0 array; else, ↑
#endif
} BoundFn;
NFnDesc* boundFnDesc;
NFnDesc* foreignFnDesc;
GLOBAL NFnDesc* boundFnDesc;
GLOBAL NFnDesc* foreignFnDesc;
B boundFn_c1(B t, B x) { BoundFn* c = c(BoundFn,t); return getB(((bqn_boundFn1)c->w_c1)(makeX(inc(c->obj)), makeX(x))); }
B boundFn_c2(B t, B w, B x) { BoundFn* c = c(BoundFn,t); return getB(((bqn_boundFn2)c->w_c2)(makeX(inc(c->obj)), makeX(w), makeX(x))); }
@ -321,7 +321,7 @@ static const u8 sty_w[] = {
[sty_i8]=1, [sty_i16]=2, [sty_i32]=4, [sty_i64]=8,
[sty_f32]=4, [sty_f64]=8
};
static const char* sty_names[] = {
static char* const sty_names[] = {
[sty_void]="void", [sty_a]="a", [sty_ptr]="*",
[sty_u8]="u8", [sty_u16]="u16", [sty_u32]="u32", [sty_u64]="u64",
[sty_i8]="i8", [sty_i16]="i16", [sty_i32]="i32", [sty_i64]="i64",
@ -567,8 +567,8 @@ static NOINLINE B toW(u8 reT, u8 reW, B x) {
case 6: ffi_checkRange(x, 2, "f64", 0, 0); return toF64Any(x); break;
}
}
static u8 reTyMapC[] = { [3]=t_c8arr, [4]=t_c16arr, [5]=t_c32arr };
static u8 reTyMapI[] = { [3]=t_i8arr, [4]=t_i16arr, [5]=t_i32arr, [6]=t_f64arr };
static u8 const reTyMapC[] = { [3]=t_c8arr, [4]=t_c16arr, [5]=t_c32arr };
static u8 const reTyMapI[] = { [3]=t_i8arr, [4]=t_i16arr, [5]=t_i32arr, [6]=t_f64arr };
static B makeRe(u8 reT, u8 reW/*log*/, u8* src, u32 elW/*bytes*/) {
u8* dst; B r;
usz ia = (elW*8)>>reW;
@ -613,7 +613,7 @@ NOINLINE B readU16Bits(B x) { usz ia=IA(x); u16* xp=tyarr_ptr(x); i32* rp; B r=m
NOINLINE B readU32Bits(B x) { usz ia=IA(x); u32* xp=tyarr_ptr(x); f64* rp; B r=m_f64arrv(&rp, ia); for (usz i=0; i<ia; i++) rp[i]=xp[i]; return num_squeeze(r); }
NOINLINE B readF32Bits(B x) { usz ia=IA(x); f32* xp=tyarr_ptr(x); f64* rp; B r=m_f64arrv(&rp, ia); for (usz i=0; i<ia; i++) rp[i]=xp[i]; return r; }
static B ffiObjsGlobal;
static GLOBAL B ffiObjsGlobal;
void genObj(B o, B c, bool anyMut, void* ptr) {
// printFFIType(stdout,o); printf(" = "); printI(c); printf("\n");
if (isC32(o)) { // scalar

13
src/h.h
View File

@ -142,10 +142,13 @@ typedef size_t ux;
#define JOIN(A,B) JOIN0(A,B)
#define STR0(X) #X
#define STR1(X) STR0(X)
#define INIT_GLOBAL __attribute__((visibility("hidden"))) // global variable set once during initialization, to the same value always
#define GLOBAL INIT_GLOBAL // global variable mutated potentially multiple times, or set to a value referencing the heap
#if USE_REPLXX_IO
#include <replxx.h>
extern Replxx* global_replxx;
extern GLOBAL Replxx* global_replxx;
#define printf(...) replxx_print(global_replxx, __VA_ARGS__)
#define fprintf(f, ...) replxx_print(global_replxx, __VA_ARGS__)
#endif
@ -298,7 +301,7 @@ typedef struct Arr {
B VALIDATE(B x);
Value* VALIDATEP(Value* x);
#define UD assert(false)
extern bool cbqn_noAlloc;
extern GLOBAL bool cbqn_noAlloc;
NOINLINE void cbqn_NOGC_start(); // function to allow breakpointing
#define NOGC_CHECK(M) do { if (cbqn_noAlloc && !gc_depth) fatal(M); } while (0)
#define NOGC_S cbqn_NOGC_start()
@ -347,7 +350,7 @@ static const B bi_noVar = b((u64)0x7FF2000000000001ull); // tag(1,TAG_TAG);
static const B bi_okHdr = b((u64)0x7FF2000000000002ull); // tag(2,TAG_TAG);
static const B bi_optOut = b((u64)0x7FF2000000000003ull); // tag(3,TAG_TAG);
static const B bi_noFill = b((u64)0x7FF2000000000005ull); // tag(5,TAG_TAG);
extern B bi_emptyHVec, bi_emptyIVec, bi_emptyCVec, bi_emptySVec;
extern GLOBAL B bi_emptyHVec, bi_emptyIVec, bi_emptyCVec, bi_emptySVec;
#define emptyHVec() incG(bi_emptyHVec)
#define emptyIVec() incG(bi_emptyIVec)
#define emptyCVec() incG(bi_emptyCVec)
@ -394,7 +397,7 @@ jmp_buf* prepareCatch(void);
#define CATCH false
#define popCatch()
#endif
extern B thrownMsg;
extern GLOBAL B thrownMsg;
void freeThrown(void);
@ -568,7 +571,7 @@ typedef B (*D2C2)(Md2D*, B, B);
F(bool, isArr) /* whether this type would have an ARR_TAG tag, in cases where the tag is unknown */ \
F(bool, arrD1) /* is always an array with depth 1 */ \
#define F(TY,N) extern TY ti_##N[t_COUNT];
#define F(TY,N) extern GLOBAL TY ti_##N[t_COUNT];
FOR_TI(F)
#undef F
#define TIi(X,V) (ti_##V[X])

View File

@ -17,8 +17,8 @@
#define ALLOC_IMPL_MMX 1
// separate memory management system for executable code; isn't garbage-collected
EmptyValue* mmX_buckets[64];
u64 mmX_ctrs[64];
GLOBAL EmptyValue* mmX_buckets[64];
GLOBAL u64 mmX_ctrs[64];
#define BSZ(X) (1ull<<(X))
#define BSZI(X) ((u8)(64-CLZ((X)-1ull)))
#define MMI(X) X
@ -27,7 +27,7 @@ u64 mmX_ctrs[64];
#define MMI(X) X
#define ALSZ 20
static u64 nvm_mmap_seed = 0;
static GLOBAL u64 nvm_mmap_seed = 0;
#ifdef __clang__
#if __clang_major__ <= 12 // old clang versions get stuck in an infinite loop while optimizing this
__attribute__((optnone))
@ -61,7 +61,7 @@ static void* mmap_nvm(u64 sz) {
}
}
extern bool mem_log_enabled;
extern GLOBAL bool mem_log_enabled;
#define MMAP(SZ) mmap_nvm(sz);
#define MUL 1
#define ALLOC_MODE 1

View File

@ -49,9 +49,9 @@ typedef struct AsmStk {
u8* c; // position for next write
u8* e; // position past last writable position
} AsmStk;
static AsmStk asm_ins; // TODO add as root
static AsmStk asm_rel;
static i32 asm_depth = 0;
static GLOBAL AsmStk asm_ins; // TODO add as root
static GLOBAL AsmStk asm_rel;
static GLOBAL i32 asm_depth = 0;
static NOINLINE void asm_allocBuf(AsmStk* stk, u64 sz) {
TAlloc* a = mm_alloc(sizeof(TAlloc) + sz, t_temp);

View File

@ -20,8 +20,8 @@
FOR_INIT(F)
#undef F
u64 mm_heapMax = HEAP_MAX;
u64 mm_heapAlloc;
GLOBAL u64 mm_heapMax = HEAP_MAX;
GLOBAL u64 mm_heapAlloc;
// compiler result:
// [
@ -48,23 +48,23 @@ u64 mm_heapAlloc;
// [%, %, [[...nameList], %], %]? // optional; % marks things i haven't bothered to understand
// ]
#define FA(N,X) B bi_##N; B N##_c1(B t, B x); B N##_c2(B t, B w, B x);
#define FM(N,X) B bi_##N; B N##_c1(B t, B x);
#define FD(N,X) B bi_##N; B N##_c2(B t, B w, B x);
#define FA(N,X) GLOBAL B bi_##N; B N##_c1(B t, B x); B N##_c2(B t, B w, B x);
#define FM(N,X) GLOBAL B bi_##N; B N##_c1(B t, B x);
#define FD(N,X) GLOBAL B bi_##N; B N##_c2(B t, B w, B x);
FOR_PFN(FA,FM,FD)
#undef FA
#undef FM
#undef FD
#define FA(N,X) B bi_##N; B N##_c1(Md1D* d, B x); B N##_c2(Md1D* d, B w, B x);
#define FM(N,X) B bi_##N; B N##_c1(Md1D* d, B x);
#define FD(N,X) B bi_##N; B N##_c2(Md1D* d, B w, B x);
#define FA(N,X) GLOBAL B bi_##N; B N##_c1(Md1D* d, B x); B N##_c2(Md1D* d, B w, B x);
#define FM(N,X) GLOBAL B bi_##N; B N##_c1(Md1D* d, B x);
#define FD(N,X) GLOBAL B bi_##N; B N##_c2(Md1D* d, B w, B x);
FOR_PM1(FA,FM,FD)
#undef FA
#undef FM
#undef FD
#define FA(N,X) B bi_##N; B N##_c1(Md2D*, B x); B N##_c2(Md2D*, B w, B x);
#define FM(N,X) B bi_##N; B N##_c1(Md2D*, B x);
#define FD(N,X) B bi_##N; B N##_c2(Md2D*, B w, B x);
#define FA(N,X) GLOBAL B bi_##N; B N##_c1(Md2D*, B x); B N##_c2(Md2D*, B w, B x);
#define FM(N,X) GLOBAL B bi_##N; B N##_c1(Md2D*, B x);
#define FD(N,X) GLOBAL B bi_##N; B N##_c2(Md2D*, B w, B x);
FOR_PM2(FA,FM,FD)
#undef FA
#undef FM
@ -94,11 +94,11 @@ char* pm2_repr(u8 u) {
#define F(TY,N) TY ti_##N[t_COUNT];
#define F(TY,N) GLOBAL TY ti_##N[t_COUNT];
FOR_TI(F)
#undef F
B r1Objs[RT_LEN];
GLOBAL B r1Objs[RT_LEN];
B rtWrap_wrap(B x, bool nnbi); // consumes
void rtWrap_print(void);
@ -123,10 +123,10 @@ static NOINLINE B evalFunBlockConsume(Block* block) {
return r;
}
HArr* comps_curr;
GLOBAL HArr* comps_curr;
B rt_undo, rt_select, rt_slash, rt_insert, rt_depth,
rt_group, rt_under, rt_find;
GLOBAL B rt_undo, rt_select, rt_slash, rt_insert, rt_depth,
rt_group, rt_under, rt_find;
Block* load_buildBlock(B x, B src, B path, B name, Scope* sc, i32 nsResult) { // consumes x,src
B fullpath = q_N(name)? inc(path) : q_N(path)? inc(name) : IA(path)==1 && IGetU(path,0).u==m_c32('.').u? inc(name) : path_rel(path, inc(name), "(load_buildBlock)");
SGet(x)
@ -152,8 +152,8 @@ Block* load_importBlock(char* name, B bc, B objs, B blocks, B bodies) { // consu
}
#endif
B load_compgen;
B def_re;
GLOBAL B load_compgen;
GLOBAL B def_re;
static void change_def_comp(B comp) { // consumes
B* re = harr_ptr(def_re); // not pretty changing in-place, but still should be fine and it's for an unsafe feature anyway
@ -179,7 +179,7 @@ B compObj_c2(B t, B w, B x) {
}
#if FORMATTER
B load_fmt, load_repr;
GLOBAL B load_fmt, load_repr;
B bqn_fmt(B x) { return c1G(load_fmt, x); }
B bqn_repr(B x) { return c1G(load_repr, x); }
#else
@ -251,7 +251,7 @@ B bqn_exec(B str, B state) { // consumes all
return evalFunBlockConsume(bqn_comp(str, state));
}
B str_all, str_none;
GLOBAL B str_all, str_none;
void init_comp(B* new_re, B* prev_re, B prim, B sys) {
new_re[re_map] = m_importMap();
if (q_N(prim)) {
@ -630,7 +630,7 @@ void bqn_exit(i32 code) {
exit(code);
}
static B load_explain;
static GLOBAL B load_explain;
B bqn_explain(B str) {
#if NO_EXPLAIN
thrM("Explainer not included in this CBQN build");
@ -672,9 +672,9 @@ 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, usz ia) { fatal("cannot slice non-array!"); }
B rt_invFnReg, rt_invFnSwap;
FC1 rt_invFnRegFn;
FC1 rt_invFnSwapFn;
GLOBAL B rt_invFnReg, rt_invFnSwap;
GLOBAL FC1 rt_invFnRegFn;
GLOBAL FC1 rt_invFnSwapFn;
B def_fn_im(B t, B x) { B fn = rt_invFnRegFn(rt_invFnReg, inc(t)); SLOW2("!runtime 𝕎⁼𝕩", t, x); B r = c1(fn, x); dec(fn); return r; }
B def_fn_is(B t, B x) { B fn = rt_invFnSwapFn(rt_invFnSwap, inc(t)); SLOW2("!runtime 𝕎⁼𝕩", t, x); B r = c1(fn, x); dec(fn); return r; }
B def_fn_iw(B t, B w, B x) { B fn = rt_invFnSwapFn(rt_invFnSwap, inc(t)); SLOW3("!runtime 𝕨F⁼𝕩", w, x, t); B r = c2(fn, w, x); dec(fn); return r; }
@ -862,7 +862,7 @@ void typesFinished_init() {
#endif
}
bool cbqn_initialized;
GLOBAL bool cbqn_initialized;
void cbqn_init() {
if (cbqn_initialized) return;
#define F(X) X##_init();

View File

@ -1,5 +1,5 @@
#pragma once
extern HArr* comps_curr; // global-ish state, valid during compilation; comps_max elements
extern GLOBAL HArr* comps_curr; // global-ish state, valid during compilation; comps_max elements
enum {
comps_path,
comps_name,
@ -19,7 +19,7 @@ enum {
#define COMPS_CREF(N) COMPS_REF(comps_curr, N)
#define COMPS_ACTIVE() (comps_curr!=NULL)
extern B def_sysNames, def_sysVals;
extern GLOBAL B def_sysNames, def_sysVals;
B comps_getPrimitives(void);
void comps_getSysvals(B* res);

View File

@ -20,12 +20,12 @@
#error "Cannot use USE_REPLXX_IO without USE_REPLXX"
#endif
static B replPath, replName;
static Scope* gsc;
static bool init = false;
static GLOBAL B replPath, replName;
static GLOBAL Scope* gsc;
static GLOBAL bool repl_initialized = false;
static NOINLINE void repl_init() {
if (init) return;
if (repl_initialized) return;
cbqn_init();
replPath = m_c8vec_0("."); gc_add(replPath);
replName = m_c8vec_0("(REPL)"); gc_add(replName);
@ -33,7 +33,7 @@ static NOINLINE void repl_init() {
B ns = m_nns(body);
gsc = ptr_inc(c(NS, ns)->sc); gc_add(tag(gsc,OBJ_TAG));
ptr_dec(v(ns));
init = true;
repl_initialized = true;
}
typedef struct { bool r; char* e; } IsCmdTmp;
@ -67,11 +67,11 @@ static NOINLINE i64 readInt(char** p) {
#include <replxx.h>
#include <errno.h>
#include "utils/cstr.h"
Replxx* global_replxx;
static char* global_histfile;
static u32 cfg_prefixChar = U'\\';
GLOBAL Replxx* global_replxx;
static GLOBAL char* global_histfile;
static GLOBAL u32 cfg_prefixChar = U'\\';
static i8 themes[3][12][3] = {
static i8 const themes[3][12][3] = {
// {-1,-1,-1} for default/unchanged color, {-1,-1,n} for grayscale 0…23, else RGB 0…5
{ // 0: "none"
{-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1}, {-1,-1,-1},
@ -109,13 +109,13 @@ static NOINLINE i64 readInt(char** p) {
};
typedef i8 Theme[12][3];
static ReplxxColor theme_replxx[12];
static GLOBAL ReplxxColor theme_replxx[12];
static i32 cfg_theme = 1;
static bool cfg_enableKeyboard = true;
static B cfg_path;
static GLOBAL i32 cfg_theme = 1;
static GLOBAL bool cfg_enableKeyboard = true;
static GLOBAL B cfg_path;
static char* command_completion[] = {
static char* const command_completion[] = {
")ex ",
")r ",
")escaped ",
@ -148,7 +148,7 @@ static NOINLINE i64 readInt(char** p) {
NOINLINE void cfg_set_theme(i32 num, bool writeCfg) {
if (num>=3) return;
cfg_theme = num;
i8 (*data)[3] = themes[num];
i8 const (*data)[3] = themes[num];
for (int i = 0; i < 12; i++) {
i8 v0 = data[i][0];
i8 v1 = data[i][1];
@ -162,8 +162,8 @@ static NOINLINE i64 readInt(char** p) {
if (writeCfg) cfg_changed();
}
extern u32* dsv_text[];
static B sysvalNames, sysvalNamesNorm;
extern u32* const dsv_text[];
static GLOBAL B sysvalNames, sysvalNamesNorm;
NOINLINE void fill_color(ReplxxColor* cols, int s, int e, ReplxxColor col) {
PLAINLOOP for (int i = s; i < e; i++) cols[i] = col;
@ -177,12 +177,12 @@ static NOINLINE i64 readInt(char** p) {
static bool chr_num0(u32 c) { return chr_dig(c) || c==U'¯' || c==U'π' || c==U''; }
static bool chr_name0(u32 c) { return chr_low(c) || chr_upp(c) || c=='_'; }
static bool chr_nameM(u32 c) { return chr_name0(c) || chr_num0(c); }
static u32* chrs_fn = U"!+-×÷⋆*√⌊⌈∧∨¬|=≠≤<>≥≡≢⊣⊢⥊∾≍⋈↑↓↕⌽⍉/⍋⍒⊏⊑⊐⊒∊⍷⊔«»𝔽𝔾𝕎𝕏𝕊";
static u32* chrs_m1 = U"`˜˘¨⁼⌜´˝˙";
static u32* chrs_m2 = U"∘⊸⟜○⌾⎉⚇⍟⊘◶⎊";
static u32* chrs_lit = U"⟨⟩[]·@‿";
static u32* chrs_dmd = U"←↩,⋄→⇐";
static u32* chrs_blk = U"{}𝕨𝕩𝕗𝕘𝕣𝕤:?;";
static u32* const chrs_fn = U"!+-×÷⋆*√⌊⌈∧∨¬|=≠≤<>≥≡≢⊣⊢⥊∾≍⋈↑↓↕⌽⍉/⍋⍒⊏⊑⊐⊒∊⍷⊔«»𝔽𝔾𝕎𝕏𝕊";
static u32* const chrs_m1 = U"`˜˘¨⁼⌜´˝˙";
static u32* const chrs_m2 = U"∘⊸⟜○⌾⎉⚇⍟⊘◶⎊";
static u32* const chrs_lit = U"⟨⟩[]·@‿";
static u32* const chrs_dmd = U"←↩,⋄→⇐";
static u32* const chrs_blk = U"{}𝕨𝕩𝕗𝕘𝕣𝕤:?;";
NOINLINE bool chr_in(u32 val, u32* chrs) {
while(*chrs) if (val == *(chrs++)) return true;
return false;
@ -406,9 +406,9 @@ static NOINLINE i64 readInt(char** p) {
return (TmpState){.s = s, .pos = replace? pos : pos+1};
}
static B b_pv;
static int b_pp;
static bool inBackslash;
static GLOBAL B b_pv;
static GLOBAL int b_pp;
static GLOBAL bool inBackslash;
static void stopBackslash() { inBackslash = false; }
NOINLINE void setPrev(B s, u64 pos) { // consumes
decG(b_pv);
@ -440,7 +440,7 @@ static NOINLINE i64 readInt(char** p) {
B indexOf_c2(B, B, B);
B pick_c1(B, B);
static B b_key, b_val;
static GLOBAL B b_key, b_val;
void modified_replxx(char** s_res, int* p_res, void* userData) {
if (!cfg_enableKeyboard) return;
CATCH_OOM(return)
@ -535,7 +535,7 @@ static NOINLINE i64 readInt(char** p) {
gc_add(b_val = m_c32vec_0( U"˙˜˘¨⁼⌜´˝7∞¯•÷׬⎉⚇⍟◶⊘⎊⍎⍕⟨⟩√⋆⌽𝕨∊↑∧y⊔⊏⊐π←→↙𝕎𝕣⍋YU⊑⊒⊣⊢⍉𝕤𝕗𝕘⊸∘○⟜⋄↩↖𝕊D𝔽𝔾«J⌾»·|⥊𝕩⌊n≡∾≍≠⋈𝕏C⍒⌈N≢≤≥⇐‿"));
sysvalNames = emptyHVec();
sysvalNamesNorm = emptyHVec();
u32** c = dsv_text;
u32* const* c = dsv_text;
while (*c) { bool unused;
B str = m_c32vec_0(*(c++));
sysvalNames = vec_addN(sysvalNames, str);
@ -579,7 +579,7 @@ void clearImportCache(void);
void switchComp(void);
#endif
static B escape_parser;
static GLOBAL B escape_parser;
static B simple_unescape(B x) {
if (RARE(escape_parser.u==0)) {
escape_parser = bqn_exec(utf8Decode0("{m←\"Expected surrounding quotes\" ⋄ m!2≤≠𝕩 ⋄ m!\"\"\"\"\"\"≡0‿¯1⊏𝕩 ⋄ s←¬e←<`'\\'=𝕩 ⋄ i‿o←\"\\\"\"nr\"\"\\\"\"\"∾@+10‿13 ⋄ 1↓¯1↓{n←i⊐𝕩\"Unknown escape\"!∧´n≠≠i ⋄ n⊏o}⌾((s/»e)⊸/) s/𝕩}"), bi_N);
@ -605,7 +605,7 @@ bool ryu_s2d_n(u8* buffer, int len, f64* result);
#endif
void heap_printInfoStr(char* str);
extern bool gc_log_enabled, mem_log_enabled;
extern GLOBAL bool gc_log_enabled, mem_log_enabled;
void cbqn_runLine0(char* ln, i64 read) {
if (ln[0]==0 || read==0) return;
@ -911,7 +911,7 @@ int main() {
}
#elif !CBQN_LIB
#if HAS_VERSION
extern char* cbqn_versionInfo;
extern char* const cbqn_versionInfo;
#endif
int main(int argc, char* argv[]) {
#if USE_REPLXX_IO
@ -1104,6 +1104,5 @@ int main(int argc, char* argv[]) {
cbqn_heapVerify();
#endif
bqn_exit(0);
#undef INIT
}
#endif

View File

@ -2,8 +2,8 @@
#include "h.h"
#include "nfns.h"
static u32 nfn_curr;
static B nfn_list;
static GLOBAL u32 nfn_curr;
static GLOBAL B nfn_list;
NFnDesc* registerNFn(B name, FC1 c1, FC2 c2) {
u32 id = nfn_curr++;

View File

@ -100,8 +100,8 @@ void ns_set(B ns, B name, B val) { VTY(ns, t_ns);
static i32* emptyi32ptr;
static B emptyi32obj;
static GLOBAL i32* emptyi32ptr;
static GLOBAL B emptyi32obj;
Body* m_nnsDescF(i32 n, char** names) {
if (emptyi32ptr==NULL) gc_add(emptyi32obj = m_i32arrv(&emptyi32ptr, 0));
incByG(emptyi32obj, 2);

View File

@ -4,35 +4,35 @@
static void mm_freeFreedAndMerge(void);
#include "../utils/time.h"
#if GC_LOG_DETAILED
bool gc_log_enabled = true;
GLOBAL bool gc_log_enabled = true;
#else
bool gc_log_enabled;
GLOBAL bool gc_log_enabled;
#endif
#endif
u64 gc_depth = 1;
GLOBAL u64 gc_depth = 1;
#ifdef GC_EVERY_NTH_ALLOC
u64 nth_alloc = 1;
GLOBAL u64 nth_alloc = 1;
#endif
vfn gc_roots[8];
u32 gc_rootSz;
GLOBAL vfn gc_roots[8];
GLOBAL u32 gc_rootSz;
void gc_addFn(vfn f) {
if (gc_rootSz>=8) fatal("Too many GC root functions");
gc_roots[gc_rootSz++] = f;
}
Value* gc_rootObjs[512];
u32 gc_rootObjSz;
GLOBAL Value* gc_rootObjs[512];
GLOBAL u32 gc_rootObjSz;
void gc_add(B x) {
assert(isVal(x));
if (gc_rootObjSz>=512) fatal("Too many GC root objects");
gc_rootObjs[gc_rootObjSz++] = v(x);
}
B* gc_rootBRefs[64]; u32 gc_rootBRefsSz;
GLOBAL B* gc_rootBRefs[64]; GLOBAL u32 gc_rootBRefsSz;
void gc_add_ref(B* x) {
if (gc_rootBRefsSz>=64) fatal("Too many GC root B refs");
gc_rootBRefs[gc_rootBRefsSz++] = x;
@ -79,10 +79,10 @@ static void gc_tryFree(Value* v) {
}
#if GC_LOG_DETAILED
u64 gcs_visitBytes, gcs_visitCount, gcs_freedBytes, gcs_freedCount, gcs_unkRefsBytes, gcs_unkRefsCount; // GC stat counters
GLOBAL u64 gcs_visitBytes, gcs_visitCount, gcs_freedBytes, gcs_freedCount, gcs_unkRefsBytes, gcs_unkRefsCount; // GC stat counters
#endif
i32 visit_mode;
GLOBAL i32 visit_mode;
enum {
GC_DEC_REFC, // decrement refcount
GC_INC_REFC, // increment refcount
@ -167,7 +167,7 @@ static void gcv2_unmark_visit(Value* x) {
}
#endif
u64 gc_lastAlloc;
GLOBAL u64 gc_lastAlloc;
void gc_forceGC(bool toplevel) {
#if ENABLE_GC
u64 startTime=0, startSize=0;
@ -196,7 +196,7 @@ void gc_forceGC(bool toplevel) {
#endif
}
static bool gc_wantTopLevelGC;
static GLOBAL bool gc_wantTopLevelGC;
bool gc_maybeGC(bool toplevel) {
if (gc_depth) return false;
u64 used = mm_heapUsed();

View File

@ -1,6 +1,6 @@
#pragma once
extern u64 gc_depth;
extern GLOBAL u64 gc_depth;
static void gc_disable() { gc_depth++; }
static void gc_enable() { gc_depth--; }

View File

@ -5,15 +5,15 @@
#include "gc.c"
#if OBJ_COUNTER
u64 currObjCounter;
GLOBAL u64 currObjCounter;
#endif
#if VERIFY_TAIL
#error MM=2 doesn't support VERIFY_TAIL
#endif
#define ALLOC_MODE 0
u64 mm_ctrs[128];
EmptyValue* mm_buckets[128];
GLOBAL u64 mm_ctrs[128];
GLOBAL EmptyValue* mm_buckets[128];
#define b1_buckets mm_buckets
#define b1_allocL mm_allocL
#define ALSZ 20

View File

@ -6,13 +6,13 @@ struct EmptyValue { // needs set: mmInfo; type=t_empty; next; everything else ca
EmptyValue* next;
};
#if OBJ_COUNTER
extern u64 currObjCounter;
extern GLOBAL u64 currObjCounter;
#endif
extern u64 mm_heapAlloc;
extern u64 mm_heapMax;
extern GLOBAL u64 mm_heapAlloc;
extern GLOBAL u64 mm_heapMax;
extern u64 mm_ctrs[128];
extern EmptyValue* mm_buckets[128];
extern GLOBAL u64 mm_ctrs[128];
extern GLOBAL EmptyValue* mm_buckets[128];
#define BSZ(X) (((X)&64? 3ull : 1ull)<<(X))
#define BN(X) mm_##X
#include "mm_buddyTemplate.h"

View File

@ -8,8 +8,8 @@
u64 currObjCounter;
#endif
u64 mm_ctrs[64];
EmptyValue* mm_buckets[64];
GLOBAL u64 mm_ctrs[64];
GLOBAL EmptyValue* mm_buckets[64];
#define ALSZ 20
#define BSZ(X) (1ull<<(X))
#define MUL 1

View File

@ -6,13 +6,13 @@ struct EmptyValue { // needs set: mmInfo; type=t_empty; next; everything else ca
EmptyValue* next;
};
#if OBJ_COUNTER
extern u64 currObjCounter;
extern GLOBAL u64 currObjCounter;
#endif
extern u64 mm_heapAlloc;
extern u64 mm_heapMax;
extern GLOBAL u64 mm_heapAlloc;
extern GLOBAL u64 mm_heapMax;
extern u64 mm_ctrs[64];
extern EmptyValue* mm_buckets[64];
extern GLOBAL u64 mm_ctrs[64];
extern GLOBAL EmptyValue* mm_buckets[64];
#define BSZ(X) (1ull<<(X))
#define BN(X) mm_##X
#include "mm_buddyTemplate.h"

View File

@ -10,9 +10,9 @@ typedef struct AllocInfo {
Value* p;
u64 sz;
} AllocInfo;
AllocInfo* al;
u64 alCap;
u64 alSize;
GLOBAL AllocInfo* al;
GLOBAL u64 alCap;
GLOBAL u64 alSize;
FORCE_INLINE void BN(splitTo)(EmptyValue* c, i64 from, i64 to, bool notEqual) {
c->mmInfo = MMI(to);
@ -31,7 +31,7 @@ FORCE_INLINE void BN(splitTo)(EmptyValue* c, i64 from, i64 to, bool notEqual) {
}
#if ALLOC_MODE==0 && ENABLE_GC
static bool BN(allocMore_rec);
static GLOBAL bool BN(allocMore_rec);
#endif
static NOINLINE void* BN(allocateMore)(i64 bucket, u8 type, i64 from, i64 to) {

View File

@ -1,7 +1,7 @@
#include <stdlib.h>
#include <malloc.h>
extern u64 mm_heapAlloc;
extern u64 mm_heapMax;
extern GLOBAL u64 mm_heapAlloc;
extern GLOBAL u64 mm_heapMax;
static void mm_free(Value* x) {
preFree(x, false);

View File

@ -123,7 +123,7 @@ B bad_chrAtomSA(DyTableSA* table, B w, B x, usz ia, u8 xe) { return arith_recd(t
u64 failAtomArr1(void* r, u64 w, void* x, u64 len) { return 0; }
u64 failAtomArr2(void* r, u64 w, void* x, u64 len) { return 1; }
u8 nextType[] = {
u8 const nextType[] = {
[t_i8arr ] = t_i16arr, [t_c8arr ] = t_c16arr,
[t_i16arr] = t_i32arr, [t_c16arr] = t_c32arr,
[t_i32arr] = t_f64arr, [t_c32arr] = t_empty,

View File

@ -103,7 +103,7 @@ Make ← {𝕊ns:
cSrc
"B ", cbqn, "_c2(B,B,B);", nl
"DyTableAA ", cbqn,"DyTableAA = {", nl
"INIT_GLOBAL DyTableAA ", cbqn,"DyTableAA = {", nl
" .entsAA = {", nl
{ instrs, wexe:
{
@ -150,7 +150,7 @@ Make ← {𝕊ns:
P {"{",𝕨,",",𝕩,"}"}´
cSrc
"DyTableSA ", cbqn,"DyTable", swap (charAtm"NC")"A", " = {", nl
"INIT_GLOBAL DyTableSA ", cbqn,"DyTable", swap (charAtm"NC")"A", " = {", nl
" .ents = {", nl
" {.bitsel=", hasNumArr"bad", {𝕊:idswap/"R"} @, "_forBitsel", charAtm"NC", "N_SA},", nl
{ 𝕊 num:

View File

@ -8,7 +8,7 @@ static inline B m1c2_unsafe(D1C2 m, B f, B w, B x) { Md1D d; d.f=f; return m(&d,
typedef void (*CmpAAFn)(u64*, void*, void*, u64);
typedef void (*CmpASFn)(u64*, void*, u64, u64);
#define CMP_DEF(F, S) extern Cmp##S##Fn cmp_fns_##F##S[];
#define CMP_DEF(F, S) extern INIT_GLOBAL Cmp##S##Fn cmp_fns_##F##S[];
CMP_DEF(eq, AS); CMP_DEF(eq, AA);
CMP_DEF(ne, AS); CMP_DEF(ne, AA);
CMP_DEF(gt, AS); CMP_DEF(gt, AA);
@ -28,12 +28,12 @@ CMP_DEF(le, AS);
// Check if the l elements starting at a and b match
typedef bool (*EqFn)(void* a, void* b, u64 l, u64 data);
extern EqFn eqFns[];
extern u8 eqFnData[];
extern INIT_GLOBAL EqFn eqFns[];
extern u8 const eqFnData[];
#define EQFN_INDEX(W_ELT, X_ELT) ((W_ELT)*8 + (X_ELT))
typedef struct { EqFn fn; u8 data; } EqFnObj;
#define EQFN_GET(W_ELT, X_ELT) ({ u8 eqfn_i_ = EQFN_INDEX(W_ELT, X_ELT); (EqFnObj){.fn=eqFns[eqfn_i_], .data=eqFnData[eqfn_i_]}; })
#define EQFN_CALL(FN, W, X, L) (FN).fn(W, X, L, (FN).data)
typedef bool (*RangeFn)(void* xp, i64* res, u64 len); // writes min,max in res, assumes len≥1; returns 0 and leaves res undefined if either any (floor(x)≠x or abs>2⋆53), or (x≠(i64)x)
extern RangeFn getRange_fns[el_f64+1]; // limited to ≤el_f64
extern INIT_GLOBAL RangeFn getRange_fns[el_f64+1]; // limited to ≤el_f64

View File

@ -463,13 +463,13 @@ NOINLINE void writeNum(FILE* f, u64 v, i32 len) {
PLAINLOOP for (i32 i = 0; i < len; i++) buf[i] = (v>>(8*i)) & 0xff;
fwrite(buf, 1, len, f);
}
static char* types_str[] = {
static char* const types_str[] = {
#define F(X) #X,
FOR_TYPE(F)
#undef F
NULL
};
static u8 types_val[] = {
static u8 const types_val[] = {
#define F(X) t_##X,
FOR_TYPE(F)
#undef F

View File

@ -87,7 +87,7 @@ NOINLINE u64 bqn_hashObj(B x, const u64 secret[4]) { // TODO manual separation o
}
u64 wy_secret[4];
INIT_GLOBAL u64 wy_secret[4];
void hash_init(void) {
u64 bad1=0xa0761d6478bd642full; // values wyhash64 is afraid of

View File

@ -2,7 +2,7 @@
#include "wyhash.h"
#include "talloc.h"
extern u64 wy_secret[4];
extern INIT_GLOBAL u64 wy_secret[4];
static void bcl(B x, usz ia) { // clean up bitarr tail bits to zero
if (ia&63) {

View File

@ -43,7 +43,7 @@ static void* arr_ptr(Arr* t, u8 el) {
return el==el_B? (void*)((HArr*)t)->a : (void*)((TyArr*)t)->a;
}
u8 reuseElType[t_COUNT];
INIT_GLOBAL u8 reuseElType[t_COUNT];
void mut_init_copy(Mut* m, B x, u8 el) {
assert(m->fns == &mutFns[el_MAX]);
if (reusable(x) && reuseElType[TY(x)]==el) {
@ -58,7 +58,7 @@ void mut_init_copy(Mut* m, B x, u8 el) {
}
}
static Arr* (*cpyFns[])(B) = {
static Arr* (* const cpyFns[])(B) = {
[el_bit] = cpyBitArr,
[el_i8] = cpyI8Arr, [el_c8] = cpyC8Arr,
[el_i16] = cpyI16Arr, [el_c16] = cpyC16Arr,
@ -322,17 +322,17 @@ DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, x
#define COPY_FN(X,R) simd_copy_##X##_##R
#define MAKE_CPY(TY, MAKE, GET, WR, XRP, H2T, E, N, ...) \
static copy_fn copy0_##E##_fns[10]; \
static copy_fn const copy0_##E##_fns[10]; \
NOINLINE void cpy##N##Arr_BF(void* xp, void* rp, u64 ia, Arr* xa) { \
AS2B fn = TIv(xa,GET); \
for (usz i=0; i<ia; i++) WR(fn(xa,i)); \
} \
AS2B fn = TIv(xa,GET); \
for (usz i=0; i<ia; i++) WR(fn(xa,i)); \
} \
static void cpy##N##Arr_B(void* xp, void* rp, u64 ia, void* xRaw) { \
Arr* xa = (Arr*)xRaw; B* bxp = arrV_bptr(xa); \
if (bxp!=NULL && sizeof(B)==sizeof(f64)) H2T; \
else cpy##N##Arr_BF(xp, rp, ia, xa); \
} \
static copy_fn copy0_##E##_fns[] = __VA_ARGS__; \
static copy_fn const copy0_##E##_fns[] = __VA_ARGS__; \
Arr* cpy##N##Arr(B x) { \
usz ia = IA(x); \
MAKE; arr_shCopy(r, x); \
@ -354,13 +354,13 @@ DEF_G(void, copy, B, (void* a, usz ms, B x, usz xs, usz l), ms, x, x
bit, Bit, {COPY_FN(1,1),COPY_FN(i8,1),COPY_FN(i16,1),COPY_FN(i32,1),COPY_FN(f64,1),badCopy, badCopy, badCopy, cpyBitArr_B, COPY_FN(f64,1)})
copy_fn tcopy_i8_fns [] = {[t_bitarr]=simd_copy_1u_i8, [t_i8arr]=simd_copy_i8_i8 ,[t_i8slice]=simd_copy_i8_i8};
copy_fn tcopy_i16_fns[] = {[t_bitarr]=simd_copy_1u_i16, [t_i8arr]=simd_copy_i8_i16,[t_i8slice]=simd_copy_i8_i16, [t_i16arr]=simd_copy_i16_i16,[t_i16slice]=simd_copy_i16_i16};
copy_fn tcopy_i32_fns[] = {[t_bitarr]=simd_copy_1u_i32, [t_i8arr]=simd_copy_i8_i32,[t_i8slice]=simd_copy_i8_i32, [t_i16arr]=simd_copy_i16_i32,[t_i16slice]=simd_copy_i16_i32, [t_i32arr]=simd_copy_i32_i32,[t_i32slice]=simd_copy_i32_i32};
copy_fn tcopy_f64_fns[] = {[t_bitarr]=simd_copy_1u_f64, [t_i8arr]=simd_copy_i8_f64,[t_i8slice]=simd_copy_i8_f64, [t_i16arr]=simd_copy_i16_f64,[t_i16slice]=simd_copy_i16_f64, [t_i32arr]=simd_copy_i32_f64,[t_i32slice]=simd_copy_i32_f64, [t_f64arr]=simd_copy_f64_f64,[t_f64slice]=simd_copy_f64_f64};
copy_fn tcopy_c8_fns [] = {[t_c8arr]=simd_copy_c8_c8 ,[t_c8slice]=simd_copy_c8_c8};
copy_fn tcopy_c16_fns[] = {[t_c8arr]=simd_copy_c8_c16,[t_c8slice]=simd_copy_c8_c16, [t_c16arr]=simd_copy_c16_c16,[t_c16slice]=simd_copy_c16_c16};
copy_fn tcopy_c32_fns[] = {[t_c8arr]=simd_copy_c8_c32,[t_c8slice]=simd_copy_c8_c32, [t_c16arr]=simd_copy_c16_c32,[t_c16slice]=simd_copy_c16_c32, [t_c32arr]=simd_copy_c32_c32,[t_c32slice]=simd_copy_c32_c32};
INIT_GLOBAL copy_fn tcopy_i8_fns [] = {[t_bitarr]=simd_copy_1u_i8, [t_i8arr]=simd_copy_i8_i8 ,[t_i8slice]=simd_copy_i8_i8};
INIT_GLOBAL copy_fn tcopy_i16_fns[] = {[t_bitarr]=simd_copy_1u_i16, [t_i8arr]=simd_copy_i8_i16,[t_i8slice]=simd_copy_i8_i16, [t_i16arr]=simd_copy_i16_i16,[t_i16slice]=simd_copy_i16_i16};
INIT_GLOBAL copy_fn tcopy_i32_fns[] = {[t_bitarr]=simd_copy_1u_i32, [t_i8arr]=simd_copy_i8_i32,[t_i8slice]=simd_copy_i8_i32, [t_i16arr]=simd_copy_i16_i32,[t_i16slice]=simd_copy_i16_i32, [t_i32arr]=simd_copy_i32_i32,[t_i32slice]=simd_copy_i32_i32};
INIT_GLOBAL copy_fn tcopy_f64_fns[] = {[t_bitarr]=simd_copy_1u_f64, [t_i8arr]=simd_copy_i8_f64,[t_i8slice]=simd_copy_i8_f64, [t_i16arr]=simd_copy_i16_f64,[t_i16slice]=simd_copy_i16_f64, [t_i32arr]=simd_copy_i32_f64,[t_i32slice]=simd_copy_i32_f64, [t_f64arr]=simd_copy_f64_f64,[t_f64slice]=simd_copy_f64_f64};
INIT_GLOBAL copy_fn tcopy_c8_fns [] = {[t_c8arr]=simd_copy_c8_c8 ,[t_c8slice]=simd_copy_c8_c8};
INIT_GLOBAL copy_fn tcopy_c16_fns[] = {[t_c8arr]=simd_copy_c8_c16,[t_c8slice]=simd_copy_c8_c16, [t_c16arr]=simd_copy_c16_c16,[t_c16slice]=simd_copy_c16_c16};
INIT_GLOBAL copy_fn tcopy_c32_fns[] = {[t_c8arr]=simd_copy_c8_c32,[t_c8slice]=simd_copy_c8_c32, [t_c16arr]=simd_copy_c16_c32,[t_c16slice]=simd_copy_c16_c32, [t_c32arr]=simd_copy_c32_c32,[t_c32slice]=simd_copy_c32_c32};
#define COPY_FNS(E, NUM) \
static void m_copyG_##E(void* a, usz ms, B x, usz xs, usz l) { \
@ -514,8 +514,8 @@ NOINLINE void apd_sh_fail(ApdMut* m, B x, u8 mode) {
Arr* apd_dbg_end(ApdMut* m, u32 ty) { fatal("ApdMut default .end invoked"); }
#endif
void apd_widen(ApdMut* m, B x, ApdFn** fns);
ApdFn* apd_tot_fns[]; ApdFn* apd_sh0_fns[]; ApdFn* apd_sh1_fns[]; ApdFn* apd_sh2_fns[];
void apd_widen(ApdMut* m, B x, ApdFn* const* fns);
ApdFn* const apd_tot_fns[]; ApdFn* const apd_sh0_fns[]; ApdFn* const apd_sh1_fns[]; ApdFn* const apd_sh2_fns[];
#define APD_OR_FILL_0(X)
#define APD_OR_FILL_1(X) \
@ -571,11 +571,11 @@ APD_MK(f64, 0, ((f64*)a)[p0]=o2fG(x), xe<=el_f64) APD_MK(B, 1, ((B*)a)
NOINLINE void apd_shE_T(ApdMut* m, B x) { APD_SHH_CHK(2) }
NOINLINE void apd_shE_B(ApdMut* m, B x) { APD_SHH_CHK(2) }
#define APD_FNS(N) ApdFn* apd_##N##_fns[] = {apd_##N##_bit,apd_##N##_i8,apd_##N##_i16,apd_##N##_i32,apd_##N##_f64,apd_##N##_c8,apd_##N##_c16,apd_##N##_c32,apd_##N##_B}
#define APD_FNS(N) ApdFn* const apd_##N##_fns[] = {apd_##N##_bit,apd_##N##_i8,apd_##N##_i16,apd_##N##_i32,apd_##N##_f64,apd_##N##_c8,apd_##N##_c16,apd_##N##_c32,apd_##N##_B}
APD_FNS(tot);
APD_FNS(sh0); APD_FNS(sh1); APD_FNS(sh2);
#undef APD_FNS
ApdFn *apd_shE_fns[] = {apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_B};
ApdFn* const apd_shE_fns[] = {apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_T,apd_shE_B};
NOINLINE Arr* apd_ret_end(ApdMut* m, u32 ty) { NOGC_E; return m->obj; }
NOINLINE Arr* apd_fill_end(ApdMut* m, u32 ty) {
@ -666,7 +666,7 @@ NOINLINE void apd_sh_init(ApdMut* m, B x) {
if (xe==el_B) NOGC_E;
}
NOINLINE void apd_widen(ApdMut* m, B x, ApdFn** fns) {
NOINLINE void apd_widen(ApdMut* m, B x, ApdFn* const* fns) {
u8 xe = isArr(x)? TI(x,elType) : selfElType(x);
u8 pe = TIv(m->obj,elType);
u8 re = el_or(xe, pe);
@ -701,10 +701,10 @@ NOINLINE void apd_widen(ApdMut* m, B x, ApdFn** fns) {
M_CopyF copyFns[el_MAX];
M_FillF fillFns[el_MAX];
MutFns mutFns[el_MAX+1];
u8 el_orArr[el_MAX*16 + el_MAX+1];
INIT_GLOBAL M_CopyF copyFns[el_MAX];
INIT_GLOBAL M_FillF fillFns[el_MAX];
INIT_GLOBAL MutFns mutFns[el_MAX+1];
INIT_GLOBAL u8 el_orArr[el_MAX*16 + el_MAX+1];
void mutF_init(void) {
for (u8 i = 0; i <= el_MAX; i++) {
for (u8 j = 0; j <= el_MAX; j++) {

View File

@ -25,7 +25,7 @@ struct MutFns {
M_SetF m_set, m_setG;
M_GetF m_getU;
};
extern MutFns mutFns[el_MAX+1];
extern INIT_GLOBAL MutFns mutFns[el_MAX+1];
struct Mut {
MutFns* fns;
@ -70,7 +70,7 @@ static Arr* mut_fp(Mut* m) { assert(m->fns->elType!=el_MAX);
return m->val;
}
extern u8 el_orArr[];
extern INIT_GLOBAL u8 el_orArr[];
static u8 el_or(u8 a, u8 b) {
return el_orArr[a*16 + b];
}

View File

@ -381,8 +381,8 @@ static inline B to_chars(const floating_decimal_64 v, const bool sign, const boo
return r;
}
static B fmt_nan, fmt_zero;
static B fmt_inf[2];
static GLOBAL B fmt_nan, fmt_zero;
static GLOBAL B fmt_inf[2];
B ryu_d2s(double f) {
const uint64_t bits = double_to_bits(f); // decode the floating-point number, and unify normalized and subnormal cases.

View File

@ -61,16 +61,16 @@ void print_BCStream(FILE* f, u32* p) {
}
B thrownMsg;
u64 envPrevHeight;
GLOBAL B thrownMsg;
GLOBAL u64 envPrevHeight;
Env* envCurr; // pointer to current environment; included to make for simpler current position updating
Env* envStart;
Env* envEnd;
GLOBAL Env* envCurr; // pointer to current environment; included to make for simpler current position updating
GLOBAL Env* envStart;
GLOBAL Env* envEnd;
B* gStack; // points to after end
B* gStackStart;
B* gStackEnd;
GLOBAL B* gStack; // points to after end
GLOBAL B* gStackStart;
GLOBAL B* gStackEnd;
NOINLINE void gsReserveR(u64 am) { gsReserve(am); }
void print_gStack() {
B* c = gStackStart;
@ -140,7 +140,7 @@ typedef struct NextRequest {
u32 pos2; // ↑ for dyadic; U32_MAX if not wanted
} NextRequest;
static B emptyARMM;
static GLOBAL B emptyARMM;
Block* compileBlock(B block, Comp* comp, bool* bDone, u32* bc, usz bcIA, B allBlocks, B allBodies, B nameList, Scope* sc, i32 depth, i32 myPos, i32 nsResult) {
assert(sc!=NULL || nsResult==0);
@ -1154,7 +1154,7 @@ void md2Bl_print(FILE* f, B x) { fprintf(f,"{2-modifier block}"); }
B block_decompose(B x) { return m_hvec2(m_i32(1), x); }
#if !defined(_WIN32) && !defined(_WIN64)
static usz pageSizeV;
static GLOBAL usz pageSizeV;
#endif
usz getPageSize() {
@ -1193,10 +1193,10 @@ void print_vmStack() {
#endif
}
B oomMessage;
GLOBAL B oomMessage;
u32 bL_m[BC_SIZE] = { // bytecode length map
u32 const bL_m[BC_SIZE] = { // bytecode length map
[FN1C]=1, [FN2C]=1, [FN1O]=1, [FN2O]=1,
[MD1C]=1, [MD2C]=1, [MD2R]=1,
[TR2D]=1, [TR3D]=1, [TR3O]=1,
@ -1217,7 +1217,7 @@ u32 bL_m[BC_SIZE] = { // bytecode length map
[FN2Oi]=5, [SETH2]=5, [PRED2]=5,
};
i32 sD_m[BC_SIZE] = { // stack diff map
i32 const sD_m[BC_SIZE] = { // stack diff map
[PUSH ]= 1, [DYNO ]= 1, [DYNM]= 1, [DFND]= 1, [VARO]= 1, [VARM]= 1, [DFND0]= 1, [DFND1]=1, [DFND2]=1,
[VARU ]= 1, [EXTO ]= 1, [EXTM]= 1, [EXTU]= 1, [SYSV]= 1, [ADDI]= 1, [ADDU ]= 1, [NOTM ]= 1,
[FN1Ci]= 0, [FN1Oi]= 0, [CHKV]= 0, [VFYM]= 0, [FLDO]= 0, [FLDG]= 0, [FLDM]= 0, [RETD ]= 0, [ALIM ]=0,
@ -1231,7 +1231,7 @@ i32 sD_m[BC_SIZE] = { // stack diff map
[FAIL]=0
};
i32 sC_m[BC_SIZE] = { // stack consumed map
i32 const sC_m[BC_SIZE] = { // stack consumed map
[PUSH]=0, [DYNO]=0, [DYNM]=0, [DFND]=0, [VARO ]=0,[VARM ]=0,[NOTM ]=0, [VARU]=0, [EXTO]=0, [EXTM]=0,
[EXTU]=0, [SYSV]=0, [ADDI]=0, [ADDU]=0, [DFND0]=0,[DFND1]=0,[DFND2]=0,
@ -1247,7 +1247,7 @@ i32 sC_m[BC_SIZE] = { // stack consumed map
[FAIL]=0
};
i32 sA_m[BC_SIZE]; // stack added map
INIT_GLOBAL i32 sA_m[BC_SIZE]; // stack added map
B funBl_uc1(B t, B o, B x) {
return funBl_im(t, c1(o, c1(t, x)));
@ -1300,9 +1300,9 @@ typedef struct CatchFrame {
u64 envDepth;
u64 cfDepth;
} CatchFrame;
CatchFrame* cf; // points to after end
CatchFrame* cfStart;
CatchFrame* cfEnd;
GLOBAL CatchFrame* cf; // points to after end
GLOBAL CatchFrame* cfStart;
GLOBAL CatchFrame* cfEnd;
#if CATCH_ERRORS
jmp_buf* prepareCatch() {
@ -1354,7 +1354,7 @@ NOINLINE B vm_fmtPoint(B src, B prepend, B path, usz cs, usz ce) { // consumes p
return s;
}
extern bool cbqn_initialized;
extern GLOBAL bool cbqn_initialized;
NOINLINE void vm_printPos(Comp* comp, i32 bcPos, i64 pos) {
B src = comp->src;
if (!q_N(src) && !q_N(comp->indices)) {
@ -1439,10 +1439,10 @@ typedef union Profiler_ent {
};
u64 ip;
} Profiler_ent;
Profiler_ent* profiler_buf_s;
Profiler_ent* profiler_buf_c;
Profiler_ent* profiler_buf_e;
bool profile_buf_full;
GLOBAL Profiler_ent* profiler_buf_s;
GLOBAL Profiler_ent* profiler_buf_c;
GLOBAL Profiler_ent* profiler_buf_e;
GLOBAL bool profile_buf_full;
void profiler_bc_handler(int x) {
@ -1509,8 +1509,8 @@ void* profiler_makeMap(void);
i32 profiler_index(void** mapRaw, B comp);
void profiler_freeMap(void* mapRaw);
i32 profiler_mode; // 0: freed; 1: bytecode; 2: instruction pointers
bool profiler_active;
GLOBAL i32 profiler_mode; // 0: freed; 1: bytecode; 2: instruction pointers
GLOBAL bool profiler_active;
bool profiler_alloc(void) {
profiler_buf_s = profiler_buf_c = mmap(NULL, PROFILE_BUFFER*sizeof(Profiler_ent), PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);

View File

@ -190,10 +190,10 @@ FORCE_INLINE B execBodyInplaceI(Body* body, Scope* sc, Block* block) { // consum
return evalBC(body, sc, block);
}
extern u32 bL_m[BC_SIZE];
extern i32 sD_m[BC_SIZE];
extern i32 sC_m[BC_SIZE];
extern i32 sA_m[BC_SIZE];
extern u32 const bL_m[BC_SIZE];
extern i32 const sD_m[BC_SIZE];
extern i32 const sC_m[BC_SIZE];
extern INIT_GLOBAL i32 sA_m[BC_SIZE];
static u32* nextBC (u32* p) { return p + bL_m[*p]; }
static i32 stackAdded (u32* p) { return sA_m[*p]; }
static i32 stackDiff (u32* p) { if (*p==LSTO|*p==LSTM|*p==ARMO|*p==ARMM) return 1-p[1]; return sD_m[*p]; }
@ -219,10 +219,10 @@ typedef struct Env {
u64 pos; // if top bit set, ((u32)pos)>>1 is an offset into bytecode; otherwise, it's a pointer in the bytecode
Scope* sc;
} Env;
extern Env* envCurr;
extern Env* envStart;
extern Env* envEnd;
extern u64 envPrevHeight; // envStart+prevEnvHeight gives envCurr+1 from before the error
extern GLOBAL Env* envCurr;
extern GLOBAL Env* envStart;
extern GLOBAL Env* envEnd;
extern GLOBAL u64 envPrevHeight; // envStart+prevEnvHeight gives envCurr+1 from before the error
static inline void pushEnv(Scope* sc, u32* bc) {
if (envCurr+1==envEnd) thrM("Stack overflow");
Env* e = envCurr+1;