shithub: sl

Download patch

ref: c2ad1dcfbbb721224c5c90a17baa5e88d87af867
parent: 21446b0c5aa586e198df778762f61b322f308f96
author: Sigrid Solveig Haflínudóttir <sigrid@ftrv.se>
date: Tue Apr 29 21:05:11 EDT 2025 

another round of renaming


--- a/src/builtins.c
+++ b/src/builtins.c
@@ -193,7 +193,7 @@
 	sl_gc_handle(&lst);
 	const char *k = nil;
 	sl_sym *v;
-	while(Tnext(slg.symbols, &k, (void**)&v)){
+	while(Tnext(slvm.symbols, &k, (void**)&v)){
 		if(v->binding != sl_unbound && (v->flags & FLAG_KEYWORD) == 0)
 			lst = mk_cons(tagptr(v, TAG_SYM), lst);
 	}
--- a/src/cvalues.c
+++ b/src/cvalues.c
@@ -24,12 +24,12 @@
 void
 add_finalizer(sl_cv *cv)
 {
-	if(slg.nfinalizers == slg.maxfinalizers){
-		slg.maxfinalizers *= 2;
-		slg.finalizers = MEM_REALLOC(slg.finalizers, slg.maxfinalizers*sizeof(slg.finalizers));
-		assert(slg.finalizers != nil);
+	if(slvm.nfinalizers == slvm.maxfinalizers){
+		slvm.maxfinalizers *= 2;
+		slvm.finalizers = MEM_REALLOC(slvm.finalizers, slvm.maxfinalizers*sizeof(slvm.finalizers));
+		assert(slvm.finalizers != nil);
 	}
-	slg.finalizers[slg.nfinalizers++] = cv;
+	slvm.finalizers[slvm.nfinalizers++] = cv;
 }
 
 void
@@ -48,8 +48,8 @@
 void
 sweep_finalizers(void)
 {
-	sl_cv **lst = slg.finalizers;
-	usize n = 0, ndel = 0, l = slg.nfinalizers;
+	sl_cv **lst = slvm.finalizers;
+	usize n = 0, ndel = 0, l = slvm.nfinalizers;
 	sl_cv *tmp;
 #define SWAP_sf(a, b) (tmp = a, a = b, b = tmp, 1)
 	if(l == 0)
@@ -66,8 +66,8 @@
 		}
 	}while((n < l-ndel) && SWAP_sf(lst[n], lst[n+ndel]));
 
-	slg.nfinalizers -= ndel;
-	slg.malloc_pressure = 0;
+	slvm.nfinalizers -= ndel;
+	slvm.malloc_pressure = 0;
 }
 
 // compute the size of the metadata object for a cvalue
@@ -110,13 +110,13 @@
 		if(!nofinalize && type->vtable != nil && type->vtable->finalize != nil)
 			add_finalizer(pcv);
 	}else{
-		if(slg.malloc_pressure > ALLOC_LIMIT_TRIGGER)
+		if(slvm.malloc_pressure > ALLOC_LIMIT_TRIGGER)
 			sl_gc(false);
 		pcv = alloc_words(CVALUE_NWORDS);
 		pcv->type = type;
 		pcv->data = MEM_ALLOC(sz);
 		cv_autorelease(pcv);
-		slg.malloc_pressure += sz;
+		slvm.malloc_pressure += sz;
 	}
 	if(str)
 		((char*)pcv->data)[--sz] = '\0';
@@ -910,7 +910,7 @@
 	sl_v sym = mk_sym(name, false);
 	sl_sym *s = ptr(sym);
 	s->binding = tagptr(cv, TAG_CVALUE);
-	ptrhash_put(&slg.reverse_dlsym_lookup, cv, (void*)sym);
+	ptrhash_put(&slvm.reverse_dlsym_lookup, cv, (void*)sym);
 
 	return s->binding;
 }
@@ -1444,8 +1444,8 @@
 void
 cvalues_init(void)
 {
-	htable_new(&slg.types, 256);
-	htable_new(&slg.reverse_dlsym_lookup, 256);
+	htable_new(&slvm.types, 256);
+	htable_new(&slvm.reverse_dlsym_lookup, 256);
 
 	ctor_cv_intern(rune, NONNUMERIC, u32int);
 	sl_sym *sym = ptr(sl_runesym);
--- a/src/opcodes.c
+++ b/src/opcodes.c
@@ -1,6 +1,6 @@
 #include "sl.h"
 
-const Builtin builtins[N_OPCODES] = {
+const sl_builtin builtins[N_OPCODES] = {
 	[OP_BUILTINP] = {"builtin?", 1},
 	[OP_FIXNUMP] = {"fixnum?", 1},
 	[OP_COMPARE] = {"compare", 2},
--- a/src/opcodes.h
+++ b/src/opcodes.h
@@ -90,4 +90,4 @@
 	N_OPCODES
 }sl_op;
 
-extern const Builtin builtins[N_OPCODES];
+extern const sl_builtin builtins[N_OPCODES];
--- a/src/print.c
+++ b/src/print.c
@@ -885,7 +885,7 @@
 	sl_v label;
 
 	if(cv_class(cv) == sl_builtintype){
-		label = (sl_v)ptrhash_get(&slg.reverse_dlsym_lookup, cv);
+		label = (sl_v)ptrhash_get(&slvm.reverse_dlsym_lookup, cv);
 		assert(label != (sl_v)HT_NOTFOUND);
 		if(sl.print_princ){
 			outs(f, sym_name(label));
@@ -934,7 +934,7 @@
 	sl_print_child(f, v);
 
 	if(sl.print_level >= 0 || sl.print_length >= 0)
-		memset(sl.consflags, 0, 4*bitvector_nwords(slg.heapsize/sizeof(sl_cons)));
+		memset(sl.consflags, 0, 4*bitvector_nwords(slvm.heapsize/sizeof(sl_cons)));
 
 	if((iscons(v) || isvec(v) || isfn(v) || iscvalue(v)) && !isstr(v))
 		htable_reset(&sl.printconses, 32);
--- a/src/sl.c
+++ b/src/sl.c
@@ -38,8 +38,8 @@
 sl_type *sl_utf8type, *sl_runetype;
 sl_type *sl_strtype;
 
-sl_thread(Sl *slp);
-Slg slg = {0};
+sl_thread(sl_proc *slp);
+sl_vm slvm_ = {0};
 
 typedef struct {
 	const char *name;
@@ -67,8 +67,8 @@
 _Noreturn void
 sl_exit(const char *status)
 {
-	if(!slg.exiting){
-		slg.exiting = true;
+	if(!slvm.exiting){
+		slvm.exiting = true;
 		sl_applyn(
 			1,
 			sym_value(mk_sym("__finish", false)),
@@ -83,7 +83,7 @@
 	sl_exctx _ctx; int l__tr, l__ca; \
 	_ctx.osp = sl.sp - sl.stack; _ctx.frame = sl.curr_frame; \
 	_ctx.rdst = sl.readstate; _ctx.prev = sl.exctx; \
-	_ctx.ngchnd = slg.ngchandles; sl.exctx = &_ctx; \
+	_ctx.ngchnd = slvm.ngchandles; sl.exctx = &_ctx; \
 	if(!sl_setjmp(_ctx.buf)) \
 		for(l__tr = 1; l__tr; l__tr = 0, (void)(sl.exctx = sl.exctx->prev))
 
@@ -106,7 +106,7 @@
 	_ctx->frame = sl.curr_frame;
 	_ctx->rdst = sl.readstate;
 	_ctx->prev = sl.exctx;
-	_ctx->ngchnd = slg.ngchandles;
+	_ctx->ngchnd = slvm.ngchandles;
 }
 
 void
@@ -144,7 +144,7 @@
 	}
 	if(sl.throwing_frame == 0)
 		sl.throwing_frame = sl.curr_frame;
-	slg.ngchandles = sl.exctx->ngchnd;
+	slvm.ngchandles = sl.exctx->ngchnd;
 	sl_exctx *thisctx = sl.exctx;
 	if(sl.exctx->prev)   // don't throw past toplevel
 		sl.exctx = sl.exctx->prev;
@@ -247,9 +247,9 @@
 	int len = strlen(str);
 	sl_sym *v;
 	const char *k;
-	if(!Tgetkv(slg.symbols, str, len, &k, (void**)&v)){
+	if(!Tgetkv(slvm.symbols, str, len, &k, (void**)&v)){
 		v = alloc_sym(str, len, copy);
-		slg.symbols = Tsetl(slg.symbols, v->name, len, v);
+		slvm.symbols = Tsetl(slvm.symbols, v->name, len, v);
 	}
 	if(v->binding == sl_lambda)
 		return sl_lambda;
@@ -260,7 +260,7 @@
 mk_csym_(const char *str, int len)
 {
 	sl_sym *v = alloc_sym(str, len, false);
-	slg.symbols = Tsetl(slg.symbols, str, len, v);
+	slvm.symbols = Tsetl(slvm.symbols, str, len, v);
 	return tagptr(v, TAG_SYM);
 }
 
@@ -269,7 +269,7 @@
 	argcount(nargs, 0);
 	USED(args);
 	sl_gensym *gs = alloc_words(sizeof(sl_gensym)/sizeof(sl_v));
-	gs->id = slg.gensym_ctr++;
+	gs->id = slvm.gensym_ctr++;
 	gs->binding = sl_unbound;
 	gs->type = nil;
 	return tagptr(gs, TAG_SYM);
@@ -314,8 +314,8 @@
 {
 	if(ismanaged(v)){
 		sl_gensym *gs = ptr(v);
-		slg.gsnameno = 1-slg.gsnameno;
-		char *n = uint2str(slg.gsname[slg.gsnameno]+1, sizeof(slg.gsname[0])-1, gs->id, 10);
+		slvm.gsnameno = 1-slvm.gsnameno;
+		char *n = uint2str(slvm.gsname[slvm.gsnameno]+1, sizeof(slvm.gsname[0])-1, gs->id, 10);
 		*(--n) = 'g';
 		return n;
 	}
@@ -329,10 +329,10 @@
 {
 	sl_cons *c;
 
-	if(sl_unlikely(slg.curheap > slg.lim))
+	if(sl_unlikely(slvm.curheap > slvm.lim))
 		sl_gc(false);
-	c = (sl_cons*)slg.curheap;
-	slg.curheap += sizeof(sl_cons);
+	c = (sl_cons*)slvm.curheap;
+	slvm.curheap += sizeof(sl_cons);
 	return tagptr(c, TAG_CONS);
 }
 
@@ -345,13 +345,13 @@
 	assert(n > 0);
 	if(n & 1)
 		n++;
-	if(sl_unlikely((sl_v*)slg.curheap > (sl_v*)slg.lim+2-n)){
+	if(sl_unlikely((sl_v*)slvm.curheap > (sl_v*)slvm.lim+2-n)){
 		sl_gc(false);
-		while(sl_unlikely((sl_v*)slg.curheap > (sl_v*)slg.lim+2-n))
+		while(sl_unlikely((sl_v*)slvm.curheap > (sl_v*)slvm.lim+2-n))
 			sl_gc(true);
 	}
-	first = (sl_v*)slg.curheap;
-	slg.curheap += n*sizeof(sl_v);
+	first = (sl_v*)slvm.curheap;
+	slvm.curheap += n*sizeof(sl_v);
 	return first;
 }
 
@@ -387,21 +387,21 @@
 void
 sl_gc_handle(sl_v *pv)
 {
-	if(sl_unlikely(slg.ngchandles == slg.maxgchandles)){
-		sl_v **gh = MEM_REALLOC(slg.gchandles, slg.maxgchandles*2*sizeof(sl_v*));
+	if(sl_unlikely(slvm.ngchandles == slvm.maxgchandles)){
+		sl_v **gh = MEM_REALLOC(slvm.gchandles, slvm.maxgchandles*2*sizeof(sl_v*));
 		if(gh == nil)
 			cthrow(lerrorf(sl_errmem, "out of gc handles"), pv);
-		slg.maxgchandles *= 2;
-		slg.gchandles = gh;
+		slvm.maxgchandles *= 2;
+		slvm.gchandles = gh;
 	}
-	slg.gchandles[slg.ngchandles++] = pv;
+	slvm.gchandles[slvm.ngchandles++] = pv;
 }
 
 void
 sl_free_gc_handles(int n)
 {
-	assert(slg.ngchandles >= n);
-	slg.ngchandles -= n;
+	assert(slvm.ngchandles >= n);
+	slvm.ngchandles -= n;
 }
 
 sl_v
@@ -423,8 +423,8 @@
 				return first;
 			}
 			d = cdr_(v);
-			*pcdr = nc = tagptr((sl_cons*)slg.curheap, TAG_CONS);
-			slg.curheap += sizeof(sl_cons);
+			*pcdr = nc = tagptr((sl_cons*)slvm.curheap, TAG_CONS);
+			slvm.curheap += sizeof(sl_cons);
 			forward(v, nc);
 			car_(nc) = ismanaged(a) ? sl_relocate(a) : a;
 			pcdr = &cdr_(nc);
@@ -440,7 +440,7 @@
 		return forwardloc(v);
 
 	if(t == TAG_CVALUE){
-		if(sl_unlikely(slg.exiting)){
+		if(sl_unlikely(slvm.exiting)){
 			sweep_cv(ptr(v));
 			return sl_nil;
 		}
@@ -503,7 +503,7 @@
 {
 	const char *k = nil;
 	sl_sym *v;
-	while(Tnext(slg.symbols, &k, (void**)&v)){
+	while(Tnext(slvm.symbols, &k, (void**)&v)){
 		if(v->binding != sl_unbound)
 			v->binding = sl_relocate(v->binding);
 	}
@@ -512,9 +512,9 @@
 void
 sl_gc(bool mustgrow)
 {
-	slg.gccalls++;
-	slg.lim = slg.curheap = slg.tospace;
-	slg.lim += slg.heapsize * (slg.grew ? 2 : 1) - sizeof(sl_cons);
+	slvm.gccalls++;
+	slvm.lim = slvm.curheap = slvm.tospace;
+	slvm.lim += slvm.heapsize * (slvm.grew ? 2 : 1) - sizeof(sl_cons);
 
 	usize top, f;
 	if(sl.throwing_frame > sl.curr_frame){
@@ -534,8 +534,8 @@
 		top = f - 3;
 		f = sl.stack[top];
 	}
-	for(int i = 0; i < slg.ngchandles; i++)
-		*slg.gchandles[i] = sl_relocate(*slg.gchandles[i]);
+	for(int i = 0; i < slvm.ngchandles; i++)
+		*slvm.gchandles[i] = sl_relocate(*slvm.gchandles[i]);
 	trace_globals();
 	relocate_typetable();
 	sl_readstate *rs = sl.readstate;
@@ -561,22 +561,22 @@
 
 	sweep_finalizers();
 
-	void *temp = slg.tospace;
-	slg.tospace = slg.fromspace;
-	slg.fromspace = temp;
+	void *temp = slvm.tospace;
+	slvm.tospace = slvm.fromspace;
+	slvm.fromspace = temp;
 
 	// FIXME(sigrid): add some extra to the "used"?
-	sl_segused(slg.fromspace, slg.heapsize, slg.curheap-slg.fromspace);
+	sl_segused(slvm.fromspace, slvm.heapsize, slvm.curheap-slvm.fromspace);
 
 	// if we're using > 80% of the space, resize tospace so we have
 	// more space to fill next time. if we grew tospace last time,
 	// grow the other half of the heap this time to catch up.
-	if(slg.grew || mustgrow || ((intptr)(slg.lim-slg.curheap) < (intptr)slg.heapsize/5)){
-		sl_segfree(slg.tospace, slg.heapsize);
-		slg.tospace = sl_segalloc(slg.heapsize*2);
-		if(sl_unlikely(slg.tospace == nil)){
-			slg.tospace = sl_segalloc(slg.heapsize);
-			if(slg.tospace == nil){
+	if(slvm.grew || mustgrow || ((intptr)(slvm.lim-slvm.curheap) < (intptr)slvm.heapsize/5)){
+		sl_segfree(slvm.tospace, slvm.heapsize);
+		slvm.tospace = sl_segalloc(slvm.heapsize*2);
+		if(sl_unlikely(slvm.tospace == nil)){
+			slvm.tospace = sl_segalloc(slvm.heapsize);
+			if(slvm.tospace == nil){
 				// FIXME(sigrid): lost it entirely. give up?
 				// alternatively, wait and try indefinitely?
 				sysfatal("lost tospace");
@@ -583,16 +583,16 @@
 			}
 			sl_raise(sl_erroom);
 		}
-		if(slg.grew){
-			slg.heapsize *= 2;
-			temp = bitvector_resize(sl.consflags, 0, slg.heapsize/sizeof(sl_cons), 1);
+		if(slvm.grew){
+			slvm.heapsize *= 2;
+			temp = bitvector_resize(sl.consflags, 0, slvm.heapsize/sizeof(sl_cons), 1);
 			if(sl_unlikely(temp == nil))
 				sl_raise(sl_erroom);
 			sl.consflags = (u32int*)temp;
 		}
-		slg.grew = !slg.grew;
+		slvm.grew = !slvm.grew;
 	}
-	if(sl_unlikely((sl_v*)slg.curheap > (sl_v*)slg.lim-2)){
+	if(sl_unlikely((sl_v*)slvm.curheap > (sl_v*)slvm.lim-2)){
 		// all data was live; gc again and grow heap.
 		// but also always leave at least 4 words available, so a closure
 		// can be allocated without an extra check.
@@ -1065,7 +1065,7 @@
 	if(isbuiltin(v))
 		return mk_sym(builtins[uintval(v)].name, false);
 	if(iscbuiltin(v)){
-		v = (sl_v)ptrhash_get(&slg.reverse_dlsym_lookup, ptr(v));
+		v = (sl_v)ptrhash_get(&slvm.reverse_dlsym_lookup, ptr(v));
 		if(v == (sl_v)HT_NOTFOUND)
 			return sl_nil;
 		return v;
@@ -1321,15 +1321,15 @@
 	USED(args);
 	argcount(nargs, 0);
 	ios *io = toio(sym_value(sl_iooutsym));
-	ios_printf(io, "heap total     %10"PRIuPTR" bytes\n", slg.heapsize);
-	ios_printf(io, "heap free      %10"PRIuPTR" bytes\n", (uintptr)(slg.lim-slg.curheap));
-	ios_printf(io, "heap used      %10"PRIuPTR" bytes\n", (uintptr)(slg.curheap-slg.fromspace));
+	ios_printf(io, "heap total     %10"PRIuPTR" bytes\n", slvm.heapsize);
+	ios_printf(io, "heap free      %10"PRIuPTR" bytes\n", (uintptr)(slvm.lim-slvm.curheap));
+	ios_printf(io, "heap used      %10"PRIuPTR" bytes\n", (uintptr)(slvm.curheap-slvm.fromspace));
 	ios_printf(io, "stack          %10"PRIu64" bytes\n", (u64int)sl.nstack*sizeof(sl_v));
-	ios_printf(io, "finalizers     %10"PRIu32"\n", (u32int)slg.nfinalizers);
-	ios_printf(io, "max finalizers %10"PRIu32"\n", (u32int)slg.maxfinalizers);
-	ios_printf(io, "gc handles     %10"PRIu32"\n", (u32int)slg.ngchandles);
-	ios_printf(io, "max gc handles %10"PRIu32"\n", (u32int)slg.maxgchandles);
-	ios_printf(io, "gc calls       %10"PRIu64"\n", (u64int)slg.gccalls);
+	ios_printf(io, "finalizers     %10"PRIu32"\n", (u32int)slvm.nfinalizers);
+	ios_printf(io, "max finalizers %10"PRIu32"\n", (u32int)slvm.maxfinalizers);
+	ios_printf(io, "gc handles     %10"PRIu32"\n", (u32int)slvm.ngchandles);
+	ios_printf(io, "max gc handles %10"PRIu32"\n", (u32int)slvm.maxgchandles);
+	ios_printf(io, "gc calls       %10"PRIu64"\n", (u64int)slvm.gccalls);
 	ios_printf(io, "opcodes        %10d\n", N_OPCODES);
 	return sl_void;
 }
@@ -1351,25 +1351,25 @@
 		return -1;
 	sl.scr_width = 100;
 
-	slg.heapsize = heapsize*sizeof(sl_v);
+	slvm.heapsize = heapsize*sizeof(sl_v);
 
-	if((slg.fromspace = sl_segalloc(slg.heapsize)) == nil){
+	if((slvm.fromspace = sl_segalloc(slvm.heapsize)) == nil){
 failed:
 		MEM_FREE(sl.consflags);
-		MEM_FREE(slg.finalizers);
-		MEM_FREE(slg.gchandles);
+		MEM_FREE(slvm.finalizers);
+		MEM_FREE(slvm.gchandles);
 		MEM_FREE(sl.stack);
-		sl_segfree(slg.fromspace, slg.heapsize);
-		sl_segfree(slg.tospace, slg.heapsize);
+		sl_segfree(slvm.fromspace, slvm.heapsize);
+		sl_segfree(slvm.tospace, slvm.heapsize);
 		htable_free(&sl.printconses);
 		MEM_FREE(slp);
 		return -1;
 	}
 
-	if((slg.tospace = sl_segalloc(slg.heapsize)) == nil)
+	if((slvm.tospace = sl_segalloc(slvm.heapsize)) == nil)
 		goto failed;
-	slg.curheap = slg.fromspace;
-	slg.lim = slg.curheap+slg.heapsize-sizeof(sl_cons);
+	slvm.curheap = slvm.fromspace;
+	slvm.lim = slvm.curheap+slvm.heapsize-sizeof(sl_cons);
 
 	sl.nstack = STACK_SIZE0;
 	if((sl.stack = MEM_ALLOC(sl.nstack*sizeof(sl_v))) == nil)
@@ -1377,14 +1377,14 @@
 	sl.sp = sl.stack;
 	sl.stackend = sl.stack + sl.nstack - 4;
 
-	slg.maxfinalizers = 512;
-	if((slg.finalizers = MEM_ALLOC(slg.maxfinalizers * sizeof(*slg.finalizers))) == nil)
+	slvm.maxfinalizers = 512;
+	if((slvm.finalizers = MEM_ALLOC(slvm.maxfinalizers * sizeof(*slvm.finalizers))) == nil)
 		goto failed;
-	slg.maxgchandles = 16;
-	if((slg.gchandles = MEM_ALLOC(slg.maxgchandles * sizeof(sl_v*))) == nil)
+	slvm.maxgchandles = 16;
+	if((slvm.gchandles = MEM_ALLOC(slvm.maxgchandles * sizeof(sl_v*))) == nil)
 		goto failed;
 
-	if((sl.consflags = bitvector_new(slg.heapsize/sizeof(sl_cons), 1)) == nil)
+	if((sl.consflags = bitvector_new(slvm.heapsize/sizeof(sl_cons), 1)) == nil)
 		goto failed;
 	if((htable_new(&sl.printconses, 32)) == nil)
 		goto failed;
--- a/src/sl.h
+++ b/src/sl.h
@@ -8,8 +8,25 @@
 #include "htable_h.h"
 HTPROT(ptrhash)
 
+typedef struct sl_exctx sl_exctx;
+typedef struct sl_builtin sl_builtin;
+typedef struct sl_cons sl_cons;
+typedef struct sl_cv sl_cv;
+typedef struct sl_cvtable sl_cvtable;
+typedef struct sl_fn sl_fn;
+typedef struct sl_gensym sl_gensym;
+typedef struct sl_readstate sl_readstate;
+typedef struct sl_sym sl_sym;
 typedef struct sl_type sl_type;
 
+typedef struct sl_proc sl_proc;
+typedef struct sl_vm sl_vm;
+
+typedef uintptr sl_v;
+
+typedef void (*cvinitfunc_t)(sl_type *, sl_v, void *);
+typedef sl_v (*builtin_t)(sl_v *, int);
+
 enum {
 	TAG_FIXNUM,
 	TAG_SPECIAL,
@@ -45,8 +62,6 @@
 	T_F32, T_F64,
 }sl_numtype;
 
-typedef uintptr sl_v;
-
 #if defined(BITS64)
 typedef s64int sl_fx;
 #define FIXNUM_BITS (64-TAG_BITS)
@@ -63,14 +78,14 @@
 #define PRIdFIXNUM PRId32
 #endif
 
-typedef struct {
+struct sl_cons {
 	sl_v car;
 	sl_v cdr;
-}sl_aligned(8) sl_cons;
+}sl_aligned(8);
 
 // NOTE: sl_sym MUST have the same fields as sl_gensym first
 // there are places where gensyms are treated as normal symbols
-typedef struct {
+struct sl_sym {
 	u64int hash;
 	sl_type *type;
 	sl_v binding;   // global value binding
@@ -79,23 +94,19 @@
 	u8int flags;
 	u8int _dummy;
 	const char *name;
-}sl_aligned(8) sl_sym;
+}sl_aligned(8);
 
-typedef struct {
+struct sl_gensym {
 	u64int id;
 	sl_type *type;
 	sl_v binding;
-}sl_aligned(8) sl_gensym;
+}sl_aligned(8);
 
-typedef struct Builtin Builtin;
-
-struct Builtin {
+struct sl_builtin {
 	const char *name;
 	int nargs;
 };
 
-typedef sl_v (*builtin_t)(sl_v*, int);
-
 #define fits_bits(x, b) (((x)>>(b-1)) == 0 || (~((x)>>(b-1))) == 0)
 #define fits_fixnum(x) fits_bits(x, FIXNUM_BITS)
 
@@ -139,7 +150,7 @@
 
 // allocate n consecutive conses
 #define cons_reserve(n) tagptr(alloc_words((n)*2), TAG_CONS)
-#define cons_index(c) (((sl_cons*)ptr(c))-((sl_cons*)slg.fromspace))
+#define cons_index(c) (((sl_cons*)ptr(c))-((sl_cons*)slvm.fromspace))
 #define ismarked(c) bitvector_get(sl.consflags, cons_index(c))
 #define mark_cons(c) bitvector_set(sl.consflags, cons_index(c))
 #define unmark_cons(c) bitvector_reset(sl.consflags, cons_index(c))
@@ -187,7 +198,7 @@
 #define sym_value(s) (((sl_sym*)ptr(s))->binding)
 #define sym_name_(s) (((sl_sym*)ptr(s))->name)
 #define sym_to_numtype(s) (((sl_sym*)ptr(s))->numtype)
-#define ismanaged(v) ((((u8int*)ptr(v)) >= slg.fromspace) && (((u8int*)ptr(v)) < slg.fromspace+slg.heapsize))
+#define ismanaged(v) ((((u8int*)ptr(v)) >= slvm.fromspace) && (((u8int*)ptr(v)) < slvm.fromspace+slvm.heapsize))
 #define isgensym(v)  (issym(v) && ismanaged(v))
 #define iscbuiltin(v) (iscvalue(v) && cv_class(ptr(v)) == sl_builtintype)
 #define isfnbuiltin(v) ((v) < (N_BUILTINS<<TAG_BITS))
@@ -269,22 +280,22 @@
 char *uint2str(char *dest, usize len, u64int num, int base);
 
 /* error handling */
-typedef struct _sl_readstate {
+struct sl_readstate {
 	sl_htable backrefs;
 	sl_htable gensyms;
 	sl_v source;
 	ios_loc errloc;
-	struct _sl_readstate *prev;
-}sl_readstate;
+	struct sl_readstate *prev;
+};
 
-typedef struct _ectx_t {
+struct sl_exctx {
 	sl_readstate *rdst;
-	struct _ectx_t *prev;
+	struct sl_exctx *prev;
 	sl_jmp_buf buf;
 	usize osp;
 	usize frame;
 	int ngchnd;
-}sl_exctx;
+};
 
 void free_readstate(sl_readstate *rs);
 
@@ -323,15 +334,13 @@
 			bthrow(arity_error(nargs, c)); \
 	}while(0)
 
-typedef struct {
+struct sl_cvtable {
 	void (*print)(sl_v self, ios *f);
 	void (*relocate)(sl_v oldv, sl_v newv);
 	void (*finalize)(sl_v self);
 	void (*print_traverse)(sl_v self);
-}sl_cvtable;
+};
 
-typedef void (*cvinitfunc_t)(sl_type*, sl_v, void*);
-
 struct sl_type {
 	sl_v type;
 	sl_cvtable *vtable;
@@ -343,7 +352,7 @@
 	sl_numtype numtype;
 };
 
-typedef struct {
+struct sl_cv {
 	sl_type *type;
 	union {
 		void *data;
@@ -351,15 +360,15 @@
 	};
 	usize len; // length of *data in bytes
 	u8int _space[]; // variable size
-}sl_aligned(8) sl_cv;
+}sl_aligned(8);
 
-typedef struct {
+struct sl_fn {
 	sl_v vals;
 	sl_v bcode;
 	sl_v env;
 	sl_v name;
 	usize maxstack;
-}sl_aligned(8) sl_fn;
+}sl_aligned(8);
 
 #define cv_class(cv) ((sl_type*)(((uintptr)((sl_cv*)cv)->type)&~(uintptr)3))
 #define cv_len(cv) (((sl_cv*)(cv))->len)
@@ -392,10 +401,7 @@
 	sl_eof = special(4),
 };
 
-typedef struct Sl Sl;
-typedef struct Slg Slg;
-
-struct Sl {
+struct sl_proc {
 	sl_v *sp;
 	usize curr_frame;
 
@@ -422,7 +428,7 @@
 	uintptr cpc;
 };
 
-struct Slg {
+struct sl_vm {
 	u8int *curheap;
 	u8int *lim;
 	usize malloc_pressure;
@@ -448,10 +454,11 @@
 	uintptr heapsize; // bytes
 };
 
-extern sl_thread(Sl *slp);
+extern sl_thread(sl_proc *slp);
 #define sl (*slp)
 
-extern Slg slg;
+extern sl_vm slvm_;
+#define slvm (slvm_)
 
 extern sl_v sl_builtinssym, sl_quote, sl_lambda, sl_comma, sl_commaat;
 extern sl_v sl_commadot, sl_trycatch, sl_backquote;
--- a/src/types.c
+++ b/src/types.c
@@ -12,7 +12,7 @@
 		if(ft != nil)
 			return ft;
 	}
-	void **bp = equalhash_bp(&slg.types, (void*)t);
+	void **bp = equalhash_bp(&slvm.types, (void*)t);
 	if(*bp != HT_NOTFOUND){
 		assert(*bp != nil);
 		return *bp;
@@ -73,7 +73,7 @@
 void
 relocate_typetable(void)
 {
-	sl_htable *h = &slg.types;
+	sl_htable *h = &slvm.types;
 	for(int i = 0; i < h->size; i += 2){
 		if(h->table[i] != HT_NOTFOUND){
 			void *nv = (void*)sl_relocate((sl_v)h->table[i]);
--- a/src/vm.h
+++ b/src/vm.h
@@ -297,10 +297,10 @@
 }
 
 OP(OP_CONS) {
-	if(sl_unlikely((sl_v*)slg.curheap > (sl_v*)slg.lim))
+	if(sl_unlikely((sl_v*)slvm.curheap > (sl_v*)slvm.lim))
 		sl_gc(false);
-	sl_cons *c = (sl_cons*)slg.curheap;
-	slg.curheap += sizeof(sl_cons);
+	sl_cons *c = (sl_cons*)slvm.curheap;
+	slvm.curheap += sizeof(sl_cons);
 	c->car = sl.sp[-2];
 	c->cdr = sl.sp[-1];
 	sl.sp[-2] = tagptr(c, TAG_CONS);
--- a/tools/gen.sl
+++ b/tools/gen.sl
@@ -449,10 +449,10 @@
     ops)
   (io-close docs-ops)
   (io-write c-header "\tN_OPCODES\n}sl_op;\n\n")
-  (io-write c-header "extern const Builtin builtins[N_OPCODES];\n")
+  (io-write c-header "extern const sl_builtin builtins[N_OPCODES];\n")
 
   (io-write c-code "#include \"sl.h\"\n\n")
-  (io-write c-code "const Builtin builtins[N_OPCODES] = {\n")
+  (io-write c-code "const sl_builtin builtins[N_OPCODES] = {\n")
   (for-each
     (λ (c la) (begin (io-write c-code (str "\t[" c))
                      (io-write c-code «] = {"»)