shithub: femtolisp

Info  •  Files  •  Log  •  Branches

refactor (mostly arithmetic)

Make fixnum<->bignum arithmetic correct and more seamless when it
comes to possible overflows of underlying types.
Fixnums will transition to bignums (vice versa) when needed.
C-specific types are no longer considered as preferred numerical
types.

--- a/3rd/mp/mpaux.c

+++ b/3rd/mp/mpaux.c

@@ -75,13 +75,13 @@

 			return;

 	} else {

 		if(b->p == (mpdigit*)&b[1]){

-			b->p = (mpdigit*)LLT_ALLOC(n*Dbytes);

+			b->p = (mpdigit*)MEM_ALLOC(n*Dbytes);

 			if(b->p == nil)

 				sysfatal("mpbits: %r");

 			memmove(b->p, &b[1], Dbytes*b->top);

 			memset(&b[1], 0, Dbytes*b->size);

 		} else {

-			b->p = (mpdigit*)LLT_REALLOC(b->p, n*Dbytes);

+			b->p = (mpdigit*)MEM_REALLOC(b->p, n*Dbytes);

 			if(b->p == nil)

 				sysfatal("mpbits: %r");

 		}

@@ -101,8 +101,8 @@

 		sysfatal("freeing mp constant");

 	memset(b->p, 0, b->size*Dbytes);

 	if(b->p != (mpdigit*)&b[1])

-		LLT_FREE(b->p);

-	LLT_FREE(b);

+		MEM_FREE(b->p);

+	MEM_FREE(b);

 }

 mpint*

--- a/3rd/mp/mpfmt.c

+++ b/3rd/mp/mpfmt.c

@@ -143,7 +143,7 @@

 		for(rv=1; (base >> rv) > 1; rv++)

 			;

 		len = 10 + (b->top*Dbits / rv);

-		buf = LLT_ALLOC(len);

+		buf = MEM_ALLOC(len);

 		if(buf == nil)

 			return nil;

 		alloced = 1;

@@ -179,7 +179,7 @@

 	}

 	if(rv < 0){

 		if(alloced)

-			LLT_FREE(buf);

+			MEM_FREE(buf);

 		return nil;

 	}

 	return buf;

--- a/3rd/mp/mpmul.c

+++ b/3rd/mp/mpmul.c

@@ -90,7 +90,7 @@

 		mpvecadd(res+n, reslen-n, diffprod, u0len+v0len, res+n);

 	memmove(p, res, (alen+blen)*Dbytes);

-	LLT_FREE(t);

+	MEM_FREE(t);

 }

 #define KARATSUBAMIN 32

--- a/3rd/mp/mptobe.c

+++ b/3rd/mp/mptobe.c

@@ -13,7 +13,7 @@

 		m++;

 	if(p == nil){

 		n = m;

-		p = LLT_ALLOC(n);

+		p = MEM_ALLOC(n);

 		if(p == nil)

 			sysfatal("mptobe: %r");

 	} else {

--- a/3rd/spooky.c

+++ b/3rd/spooky.c

@@ -26,7 +26,7 @@

 #include "platform.h"

 #include "spooky.h"

-#define ALLOW_UNALIGNED_READS 1

+#define ALLOW_UNALIGNED_READS 0

 //

 // SC_CONST: a constant which:

@@ -369,9 +369,18 @@

 	} u;

 	size_t left;

-	h[0] = h[3] = h[6] = h[9] = *hash1;

-	h[1] = h[4] = h[7] = h[10] = *hash2;

-	h[2] = h[5] = h[8] = h[11] = SC_CONST;

+	h[0] = *hash1;

+	h[1] = *hash2;

+	h[2] = SC_CONST;

+	h[3] = *hash1;

+	h[4] = *hash2;

+	h[5] = SC_CONST;

+	h[6] = *hash1;

+	h[7] = *hash2;

+	h[8] = SC_CONST;

+	h[9] = *hash1;

+	h[10] = *hash2;

+	h[11] = SC_CONST;

 	u.p8 = (const uint8_t *) message;

 	end = u.p64 + (length / SC_BLOCKSIZE) * SC_NUMVARS;

--- a/3rd/wcwidth.c

+++ b/3rd/wcwidth.c

@@ -15,7 +15,7 @@

  * https://github.com/termux/termux-packages/tree/master/packages/libandroid-support

  */

-#include "../llt.h"

+#include "flisp.h"

 struct width_interval {

 	int start;

--- a/bitvector.c

+++ b/bitvector.c

@@ -1,4 +1,4 @@

-#include "llt.h"

+#include "flisp.h"

 uint32_t *

 bitvector_resize(uint32_t *b, uint64_t oldsz, uint64_t newsz, int initzero)

@@ -5,7 +5,7 @@

 {

 	uint32_t *p;

 	size_t sz = ((newsz+31)>>5) * sizeof(uint32_t);

-	p = LLT_REALLOC(b, sz);

+	p = MEM_REALLOC(b, sz);

 	if(p == nil)

 		return nil;

 	if(initzero && newsz>oldsz){

--- a/builtins.c

+++ b/builtins.c

@@ -2,7 +2,6 @@

   Extra femtoLisp builtin functions

 */

-#include "llt.h"

 #include "flisp.h"

 #include "operators.h"

 #include "cvalues.h"

@@ -9,6 +8,9 @@

 #include "timefuncs.h"

 #include "random.h"

+#define DBL_MAXINT (1LL<<53)

+#define FLT_MAXINT (1<<24)

+

 size_t

 llength(value_t v)

 {

@@ -131,7 +133,7 @@

 BUILTIN("symbol", symbol)

 {

 	argcount(nargs, 1);

-	if(!fl_isstring(args[0]))

+	if(__unlikely(!fl_isstring(args[0])))

 		type_error("string", args[0]);

 	return symbol(cvalue_data(args[0]));

 }

@@ -245,13 +247,15 @@

 BUILTIN("fixnum", fixnum)

 {

 	argcount(nargs, 1);

-	if(isfixnum(args[0]))

-		return args[0];

-	if(iscprim(args[0])){

-		cprim_t *cp = (cprim_t*)ptr(args[0]);

-		return fixnum(conv_to_long(cp_data(cp), cp_numtype(cp)));

-	}

-	type_error("number", args[0]);

+	value_t v = args[0];

+	if(isfixnum(v))

+		return v;

+	void *p = ptr(v);

+	if(iscprim(v))

+		return fixnum(conv_to_int64(cp_data(p), cp_numtype(p)));

+	if(iscvalue(v) && cp_numtype(p) == T_MPINT)

+		return fixnum(mptov(*(mpint**)cv_data(p)));

+	type_error("number", v);

 }

 BUILTIN("truncate", truncate)

@@ -285,11 +289,11 @@

 BUILTIN("vector-alloc", vector_alloc)

 {

-	uint32_t i, k, a;

+	size_t i, k, a;

 	value_t f, v;

 	if(nargs < 1)

 		argcount(nargs, 1);

-	i = toulong(args[0]);

+	i = tosize(args[0]);

 	v = alloc_vector(i, 0);

 	a = 1;

 	for(k = 0; k < i; k++){

@@ -394,14 +398,12 @@

 BUILTIN("rand", rand)

 {

 	USED(args); USED(nargs);

-	uint64_t x = genrand_int63();

-	fixnum_t r;

 #ifdef BITS64

-	r = x >> 3;

+	uint64_t x = genrand_uint64();

 #else

-	r = x >> (32+3);

+	uint32_t x = genrand_uint32();

 #endif

-	return fixnum(r);

+	return fixnum(x >> 3);

 }

 BUILTIN("rand-uint32", rand_uint32)

--- a/cvalues.c

+++ b/cvalues.c

@@ -1,9 +1,7 @@

-#include "llt.h"

 #include "flisp.h"

 #include "operators.h"

 #include "cvalues.h"

 #include "types.h"

-#include "overflows.h"

 #include "iostream.h"

 // trigger unconditional GC after this many bytes are allocated

@@ -16,7 +14,7 @@

 {

 	if(FL(nfinalizers) == FL(maxfinalizers)){

 		size_t nn = FL(maxfinalizers) == 0 ? 256 : FL(maxfinalizers)*2;

-		cvalue_t **temp = LLT_REALLOC(FL(finalizers), nn*sizeof(cvalue_t*));

+		cvalue_t **temp = MEM_REALLOC(FL(finalizers), nn*sizeof(cvalue_t*));

 		if(temp == nil)

 			lerrorf(FL(MemoryError), "out of memory");

 		FL(finalizers) = temp;

@@ -47,7 +45,7 @@

 				t->vtable->finalize(tagptr(tmp, TAG_CVALUE));

 			if(!isinlined(tmp) && owned(tmp) && !FL(exiting)){

 				memset(cv_data(tmp), 0xbb, cv_len(tmp));

-				LLT_FREE(cv_data(tmp));

+				MEM_FREE(cv_data(tmp));

 			}

 			ndel++;

 		}

@@ -54,7 +52,7 @@

 	}while((n < l-ndel) && SWAP_sf(lst[n], lst[n+ndel]));

 	FL(nfinalizers) -= ndel;

-#ifdef VERBOSEGC

+#if defined(VERBOSEGC)

 	if(ndel > 0)

 		printf("GC: finalized %d objects\n", ndel);

 #endif

@@ -125,7 +123,7 @@

 			gc(0);

 		pcv = alloc_words(CVALUE_NWORDS);

 		pcv->type = type;

-		pcv->data = LLT_ALLOC(sz);

+		pcv->data = MEM_ALLOC(sz);

 		autorelease(pcv);

 		FL(malloc_pressure) += sz;

 	}

@@ -211,7 +209,7 @@

 	size_t sz = cv_len(cv);

 	if(cv_isstr(cv))

 		sz++;

-	void *data = LLT_ALLOC(sz);

+	void *data = MEM_ALLOC(sz);

 	memcpy(data, cv_data(cv), sz);

 	cv->data = data;

 	autorelease(cv);

@@ -226,9 +224,13 @@

 		if(isfixnum(arg)) \

 			n = (ctype)numval(arg); \

 		else if(iscprim(arg)){ \

-			cprim_t *cp = (cprim_t*)ptr(arg); \

+			cprim_t *cp = ptr(arg); \

 			void *p = cp_data(cp); \

 			n = (ctype)conv_to_##cnvt(p, cp_numtype(cp)); \

+		}else if(iscvalue(arg) && cp_numtype(ptr(arg)) == T_MPINT){ \

+			cvalue_t *cv = ptr(arg); \

+			void *p = cv_data(cv); \

+			n = (ctype)conv_to_##cnvt(p, T_MPINT); \

 		}else \

 			return 1; \

 		*((ctype*)dest) = n; \

@@ -281,20 +283,9 @@

 num_ctor(int64, int64_t, T_INT64)

 num_ctor(uint64, uint64_t, T_UINT64)

 num_ctor_init(byte,  uint8_t, T_UINT8)

-#if defined(ULONG64)

-num_ctor_init(long, int64_t, T_INT64)

-num_ctor(ulong, uint64_t, T_UINT64)

-#else

-num_ctor_init(long, int32_t, T_INT32)

-num_ctor(ulong, uint32_t, T_UINT32)

-#endif

 num_ctor(float, float, T_FLOAT)

 num_ctor(double, double, T_DOUBLE)

-#if defined(__plan9__)

 num_ctor(rune, uint32_t, T_UINT32)

-#else

-num_ctor(rune, int32_t, T_INT32)

-#endif

 static int

 cvalue_mpint_init(fltype_t *type, value_t arg, void *dest)

@@ -303,6 +294,10 @@

 	USED(type);

 	if(isfixnum(arg)){

 		n = vtomp(numval(arg), nil);

+	}else if(iscvalue(arg)){

+		cvalue_t *cv = ptr(arg);

+		void *p = cv_data(cv);

+		n = conv_to_mpint(p, cp_numtype(cv));

 	}else if(iscprim(arg)){

 		cprim_t *cp = (cprim_t*)ptr(arg);

 		void *p = cp_data(cp);

@@ -348,20 +343,22 @@

 value_t

 size_wrap(size_t sz)

 {

-	if(fits_fixnum(sz))

-		return fixnum(sz);

-	assert(sizeof(void*) == sizeof(size_t));

-	return mk_ulong(sz);

+	if(sizeof(size_t) == 8)

+		return fits_fixnum(sz) ? fixnum(sz): mk_uint64(sz);

+	else

+		return fits_fixnum(sz) ? fixnum(sz): mk_uint32(sz);

 }

 size_t

-toulong(value_t n)

+tosize(value_t n)

 {

 	if(isfixnum(n))

 		return (size_t)numval(n);

 	if(iscprim(n)){

 		cprim_t *cp = (cprim_t*)ptr(n);

-		return conv_to_ulong(cp_data(cp), cp_numtype(cp));

+		if(sizeof(size_t) == 8)

+			return conv_to_uint64(cp_data(cp), cp_numtype(cp));

+		return conv_to_uint32(cp_data(cp), cp_numtype(cp));

 	}

 	type_error("number", n);

 }

@@ -451,7 +448,7 @@

 	cnt = predict_arraylen(arg);

 	if(iscons(cdr_(cdr_(type)))){

-		size_t tc = toulong(car_(cdr_(cdr_(type))));

+		size_t tc = tosize(car_(cdr_(cdr_(type))));

 		if(tc != cnt)

 			lerrorf(FL(ArgError), "size mismatch");

 	}

@@ -533,7 +530,7 @@

 	if(nargs < 3)

 		argcount(nargs, 3);

-	cnt = toulong(args[1]);

+	cnt = tosize(args[1]);

 	if(cnt < 0)

 		lerrorf(FL(ArgError), "invalid size: %d", cnt);

@@ -572,7 +569,7 @@

 	while(iscons(fld)){

 		fsz = ctype_sizeof(car(cdr(car_(fld))), &al);

-		ssz = LLT_ALIGN(ssz, al);

+		ssz = ALIGNED(ssz, al);

 		if(al > *palign)

 			*palign = al;

@@ -582,7 +579,7 @@

 		ssz += fsz;

 		fld = cdr_(fld);

 	}

-	return LLT_ALIGN(ssz, *palign);

+	return ALIGNED(ssz, *palign);

 }

 static size_t

@@ -601,7 +598,7 @@

 			usz = fsz;

 		fld = cdr_(fld);

 	}

-	return LLT_ALIGN(usz, *palign);

+	return ALIGNED(usz, *palign);

 }

 // *palign is an output argument giving the alignment required by type

@@ -630,7 +627,7 @@

 			if(!iscons(cdr_(cdr_(type))))

 				lerrorf(FL(ArgError), "incomplete type");

 			value_t n = car_(cdr_(cdr_(type)));

-			size_t sz = toulong(n);

+			size_t sz = tosize(n);

 			return sz * ctype_sizeof(t, palign);

 		}

 		if(hed == FL(enumsym)){

@@ -741,7 +738,7 @@

 		size_t len = cv_len(cv);

 		if(cv_isstr(cv))

 			len++;

-		ncv->data = LLT_ALLOC(len);

+		ncv->data = MEM_ALLOC(len);

 		memcpy(ncv->data, cv_data(cv), len);

 		autorelease(ncv);

 		if(hasparent(cv)){

@@ -801,7 +798,7 @@

 		size_t cnt;

 		if(iscons(cdr_(cdr_(type))))

-			cnt = toulong(car_(cdr_(cdr_(type))));

+			cnt = tosize(car_(cdr_(cdr_(type))));

 		else if(nargs == 2)

 			cnt = predict_arraylen(args[1]);

 		else

@@ -845,7 +842,7 @@

 	cvalue_t *cv = ptr(arr);

 	*data = cv_data(cv);

 	numel = cv_len(cv)/cv_class(cv)->elsz;

-	*index = toulong(ind);

+	*index = tosize(ind);

 	if(*index < 0 || *index >= numel)

 		bounds_error(arr, ind);

 }

@@ -967,149 +964,33 @@

 {

 	if(fits_fixnum(Saccum))

 		return fixnum((fixnum_t)Saccum);

-	if(Saccum > (int64_t)UINT32_MAX || Saccum < (int64_t)INT32_MIN)

-		RETURN_NUM_AS(Saccum, int64);

-	if(Saccum > (int64_t)INT32_MAX)

-		RETURN_NUM_AS(Saccum, uint32);

-	RETURN_NUM_AS(Saccum, int32);

+	RETURN_NUM_AS(vtomp(Saccum, nil), mpint);

 }

+#define ACCUM_DEFAULT 0

+#define ARITH_OP(a, b) (a)+(b)

+#define MP_OP mpadd

+#define ARITH_OVERFLOW sadd_overflow_64

 value_t

-fl_add_any(value_t *args, uint32_t nargs, fixnum_t carryIn)

+fl_add_any(value_t *args, uint32_t nargs)

 {

-	uint64_t Uaccum = 0;

-	uint64_t Uresult = 0;

-	int64_t Saccum = carryIn;

-	int64_t Sresult;

-	double Faccum = 0;

-	bool inexact = false;

-	uint32_t i;

-	int64_t i64;

-	value_t arg;

-	mpint *Maccum = nil, *x;

-	numerictype_t pt;

-	fixnum_t pi;

-	void *a;

+#include "fl_arith_any.inc"

+}

-	FOR_ARGS(i, 0, arg, args){

-		if(isfixnum(arg)){

-			Saccum += numval(arg);

-			continue;

-		}

-		if(num_to_ptr(arg, &pi, &pt, &a)){

-			switch(pt){

-			case T_INT8:   Saccum += *(int8_t*)a; break;

-			case T_UINT8:  Uaccum += *(uint8_t*)a; break;

-			case T_INT16:  Saccum += *(int16_t*)a; break;

-			case T_UINT16: Uaccum += *(uint16_t*)a; break;

-			case T_INT32:  Saccum += *(int32_t*)a; break;

-			case T_UINT32: Uaccum += *(uint32_t*)a; break;

-			case T_INT64:

-				i64 = *(int64_t*)a;

-				if(i64 >= 0){

-					if(addof_uint64(Uresult, Uaccum, (uint64_t)i64)){

-						if(Maccum == nil)

-							Maccum = mpnew(0);

-						x = uvtomp((uint64_t)i64, nil);

-						mpadd(Maccum, x, Maccum);

-						mpfree(x);

-					}else

-						Uaccum = Uresult;

-				}else{

-					if(subof_int64(Sresult, Saccum, i64)){

-						if(Maccum == nil)

-							Maccum = mpnew(0);

-						x = uvtomp(-(uint64_t)i64, nil);

-						x->sign = -1;

-						mpadd(Maccum, x, Maccum);

-						mpfree(x);

-					}else{

-						USED(Sresult);

-						Saccum += i64;

-					}

-				}

-				break;

-			case T_UINT64:

-				if(addof_uint64(Uresult, Uaccum, *(uint64_t*)a)){

-					if(Maccum == nil)

-						Maccum = mpnew(0);

-					x = uvtomp(*(uint64_t*)a, nil);

-					mpadd(Maccum, x, Maccum);

-					mpfree(x);

-				}else

-					Uaccum = Uresult;

-				break;

-			case T_MPINT:

-				if(Maccum == nil)

-					Maccum = mpnew(0);

-				mpadd(Maccum, *(mpint**)a, Maccum);

-				break;

-			case T_FLOAT:  Faccum += *(float*)a; inexact = true; break;

-			case T_DOUBLE: Faccum += *(double*)a; inexact = true; break;

-			default:

-				goto add_type_error;

-			}

-			continue;

-		}

-

-add_type_error:

-		mpfree(Maccum);

-		type_error("number", arg);

-	}

-	if(inexact){

-		Faccum += Uaccum;

-		Faccum += Saccum;

-		if(Maccum != nil){

-			Faccum += mptod(Maccum);

-			mpfree(Maccum);

-		}

-		return mk_double(Faccum);

-	}

-	if(Maccum != nil){

-		/* FIXME - check if it fits into fixnum first, etc */

-		x = vtomp(Saccum, nil);

-		mpadd(Maccum, x, Maccum);

-		x = uvtomp(Uaccum, x);

-		mpadd(Maccum, x, Maccum);

-		mpfree(x);

-		return mk_mpint(Maccum);

-	}

-	if(Saccum < 0){

-		uint64_t negpart = -(uint64_t)Saccum;

-		if(negpart > Uaccum){

-			Saccum += (int64_t)Uaccum;

-			// return value in Saccum

-			if(Saccum >= INT32_MIN){

-				if(fits_fixnum(Saccum)){

-					return fixnum((fixnum_t)Saccum);

-				}

-				RETURN_NUM_AS(Saccum, int32);

-			}

-			RETURN_NUM_AS(Saccum, int64);

-		}

-		Uaccum -= negpart;

-	}else{

-		if(addof_uint64(Uresult, Uaccum, (uint64_t)Saccum)){

-			if(Maccum == nil)

-				Maccum = mpnew(0);

-			x = vtomp(Saccum, nil);

-			mpadd(Maccum, x, Maccum);

-			x = uvtomp(Uaccum, x);

-			mpadd(Maccum, x, Maccum);

-			mpfree(x);

-			return mk_mpint(Maccum);

-		}else

-			Uaccum = Uresult;

-	}

-	return return_from_uint64(Uaccum);

+#define ACCUM_DEFAULT 1

+#define ARITH_OP(a, b) (a)*(b)

+#define MP_OP mpmul

+#define ARITH_OVERFLOW smul_overflow_64

+value_t

+fl_mul_any(value_t *args, uint32_t nargs)

+{

+#include "fl_arith_any.inc"

 }

 value_t

 fl_neg(value_t n)

 {

-	int32_t i32;

 	int64_t i64;

-	uint32_t ui32;

 	uint64_t ui64;

 	mpint *mp;

 	numerictype_t pt;

@@ -1117,46 +998,45 @@

 	void *a;

 	if(isfixnum(n)){

-		fixnum_t s = fixnum(-numval(n));

-		if(__unlikely((value_t)s == n))

-			return mk_xlong(-numval(n));

-		return s;

+		i64 = -(int64_t)numval(n);

+i64neg:

+		return fits_fixnum(i64) ? fixnum(i64) : mk_mpint(vtomp(i64, nil));

 	}

 	if(num_to_ptr(n, &pi, &pt, &a)){

 		switch(pt){

-		case T_INT8:   return fixnum(-(int32_t)*(int8_t*)a);

-		case T_UINT8:  return fixnum(-(int32_t)*(uint8_t*)a);

-		case T_INT16:  return fixnum(-(int32_t)*(int16_t*)a);

-		case T_UINT16: return fixnum(-(int32_t)*(uint16_t*)a);

-		case T_INT32:

-			i32 = *(int32_t*)a;

-			if(i32 == (int32_t)BIT31)

-				return mk_uint32((uint32_t)BIT31);

-			return mk_int32(-i32);

+		case T_DOUBLE: return mk_double(-*(double*)a);

+		case T_FLOAT:  return mk_float(-*(float*)a);

+		case T_INT8:   return fixnum(-(fixnum_t)*(int8_t*)a);

+		case T_UINT8:  return fixnum(-(fixnum_t)*(uint8_t*)a);

+		case T_INT16:  return fixnum(-(fixnum_t)*(int16_t*)a);

+		case T_UINT16: return fixnum(-(fixnum_t)*(uint16_t*)a);

 		case T_UINT32:

-			ui32 = *(uint32_t*)a;

-			if(ui32 <= (uint32_t)INT32_MAX+1)

-				return mk_int32(-(uint32_t)ui32);

-			return mk_int64(-(int64_t)ui32);

+			i64 = -(int64_t)*(uint32_t*)a;

+			if(0){

+		case T_INT32:

+				i64 = -(int64_t)*(int32_t*)a;

+			}

+			goto i64neg;

 		case T_INT64:

 			i64 = *(int64_t*)a;

-			if(i64 == (int64_t)BIT63)

-				return mk_uint64((uint64_t)BIT63);

-			return mk_int64(-i64);

+			if(i64 == INT64_MIN)

+				return mk_mpint(uvtomp((uint64_t)INT64_MAX+1, nil));

+			i64 = -i64;

+			goto i64neg;

 		case T_UINT64:

 			ui64 = *(uint64_t*)a;

-			if(ui64 <= (uint64_t)INT64_MAX+1)

-				return mk_int64(-(uint64_t)ui64);

-			mp = uvtomp(ui64, nil);

-			mp->sign = -1;

-			return mk_mpint(mp);

+			if(ui64 >= (uint64_t)INT64_MAX+1){

+				mp = uvtomp(ui64, nil);

+				mp->sign = -1;

+				return mk_mpint(mp);

+			}

+			i64 = -(int64_t)ui64;

+			goto i64neg;

 		case T_MPINT:

 			mp = mpcopy(*(mpint**)a);

-			mpsub(mpzero, mp, mp);

+			mp->sign = -mp->sign;

 			return mk_mpint(mp);

-		case T_FLOAT:  return mk_float(-*(float*)a);

-		case T_DOUBLE: return mk_double(-*(double*)a);

 		}

 	}

@@ -1163,91 +1043,6 @@

 	type_error("number", n);

 }

-value_t

-fl_mul_any(value_t *args, uint32_t nargs)

-{

-	int64_t Saccum = 1;

-	uint64_t Uaccum = 1;

-	double Faccum = 1;

-	bool inexact = false;

-	int64_t i64;

-	uint32_t i;

-	value_t arg;

-	mpint *Maccum = nil, *x;

-	numerictype_t pt;

-	fixnum_t pi;

-	void *a;

-

-	FOR_ARGS(i, 0, arg, args){

-		if(isfixnum(arg)){

-			Saccum *= numval(arg);

-			continue;

-		}

-		if(num_to_ptr(arg, &pi, &pt, &a)){

-			switch(pt){

-			case T_INT8:   Saccum *= *(int8_t*)a; break;

-			case T_UINT8:  Uaccum *= *(uint8_t*)a; break;

-			case T_INT16:  Saccum *= *(int16_t*)a; break;

-			case T_UINT16: Uaccum *= *(uint16_t*)a; break;

-			case T_INT32:  Saccum *= *(int32_t*)a; break;

-			case T_UINT32: Uaccum *= *(uint32_t*)a; break;

-			case T_INT64:

-				i64 = *(int64_t*)a;

-				if(i64 > 0)

-					Uaccum *= (uint64_t)i64;

-				else

-					Saccum *= i64;

-				break;

-			case T_UINT64: Uaccum *= *(uint64_t*)a; break;

-			case T_MPINT:

-				if(Maccum == nil)

-					Maccum = mpcopy(mpone);

-				mpmul(Maccum, *(mpint**)a, Maccum);

-				break;

-			case T_FLOAT:  Faccum *= *(float*)a; inexact = true; break;

-			case T_DOUBLE: Faccum *= *(double*)a; inexact = true; break;

-			default:

-				goto mul_type_error;

-			}

-			continue;

-		}

-

-mul_type_error:

-		type_error("number", arg);

-	}

-	if(inexact){

-		Faccum *= Uaccum;

-		Faccum *= Saccum;

-		if(Maccum != nil){

-			Faccum *= mptod(Maccum);

-			mpfree(Maccum);

-		}

-		return mk_double(Faccum);

-	}

-	if(Maccum != nil){

-		/* FIXME might still fit into a fixnum */

-		x = vtomp(Saccum, nil);

-		mpmul(Maccum, x, Maccum);

-		x = uvtomp(Uaccum, x);

-		mpmul(Maccum, x, Maccum);

-		mpfree(x);

-		return mk_mpint(Maccum);

-	}

-	if(Saccum < 0){

-		Saccum *= (int64_t)Uaccum;

-		if(Saccum >= INT32_MIN){

-			if(fits_fixnum(Saccum)){

-				return fixnum((fixnum_t)Saccum);

-			}

-			RETURN_NUM_AS(Saccum, int32);

-		}

-		RETURN_NUM_AS(Saccum, int64);

-	}else{

-		Uaccum *= (uint64_t)Saccum;

-	}

-	return return_from_uint64(Uaccum);

-}

-

 int

 num_to_ptr(value_t a, fixnum_t *pi, numerictype_t *pt, void **pp)

 {

@@ -1283,7 +1078,7 @@

 int

 numeric_compare(value_t a, value_t b, int eq, int eqnans, int typeerr)

 {

-	lltint_t ai, bi;

+	fixnum_t ai, bi;

 	numerictype_t ta, tb;

 	void *aptr, *bptr;

@@ -1325,7 +1120,7 @@

 fl_div2(value_t a, value_t b)

 {

 	double da, db;

-	lltint_t ai, bi;

+	fixnum_t ai, bi;

 	numerictype_t ta, tb;

 	void *aptr, *bptr;

@@ -1350,7 +1145,7 @@

 value_t

 fl_idiv2(value_t a, value_t b)

 {

-	lltint_t ai, bi;

+	fixnum_t ai, bi;

 	numerictype_t ta, tb;

 	void *aptr, *bptr;

 	int64_t a64, b64;

@@ -1411,7 +1206,7 @@

 static value_t

 fl_bitwise_op(value_t a, value_t b, int opcode)

 {

-	lltint_t ai, bi;

+	fixnum_t ai, bi;

 	numerictype_t ta, tb, itmp;

 	void *aptr = nil, *bptr = nil, *ptmp;

 	mpint *bmp = nil, *resmp = nil;

@@ -1561,6 +1356,16 @@

 		case T_UINT64: return mk_uint64(~*(uint64_t*)aptr);

 		}

 	}

+	if(iscvalue(a)){

+		cvalue_t *cv = ptr(a);

+		ta = cp_numtype(cv);

+		aptr = cv_data(cv);

+		if(ta == T_MPINT){

+			mpint *m = mpnew(0);

+			mpnot(*(mpint**)aptr, m);

+			return mk_mpint(m);

+		}

+	}

 	type_error("integer", a);

 }

@@ -1637,13 +1442,6 @@

 	ctor_cv_intern(int64, T_INT64, int64_t);

 	ctor_cv_intern(uint64, T_UINT64, uint64_t);

 	ctor_cv_intern(byte, T_UINT8, uint8_t);

-#if defined(ULONG64)

-	ctor_cv_intern(long, T_INT64, int64_t);

-	ctor_cv_intern(ulong, T_UINT64, uint64_t);

-#else

-	ctor_cv_intern(long, T_INT32, int32_t);

-	ctor_cv_intern(ulong, T_UINT32, uint32_t);

-#endif

 	ctor_cv_intern(rune, T_UINT32, uint32_t);

 	ctor_cv_intern(float, T_FLOAT, float);

 	ctor_cv_intern(double, T_DOUBLE, double);

@@ -1670,13 +1468,6 @@

 	mk_primtype(uint32, uint32_t);

 	mk_primtype(int64, int64_t);

 	mk_primtype(uint64, uint64_t);

-#if defined(ULONG64)

-	mk_primtype(long, int64_t);

-	mk_primtype(ulong, uint64_t);

-#else

-	mk_primtype(long, int32_t);

-	mk_primtype(ulong, uint32_t);

-#endif

 	mk_primtype(byte, uint8_t);

 	mk_primtype(rune, uint32_t);

 	mk_primtype(float, float);

--- a/cvalues.h

+++ b/cvalues.h

@@ -1,11 +1,10 @@

 #pragma once

-#ifdef BITS64

+#if defined(BITS64)

 #define NWORDS(sz) (((sz)+7)>>3)

 #else

 #define NWORDS(sz) (((sz)+3)>>2)

 #endif

-

 #define CVALUE_NWORDS 4

 #define MAX_INL_SIZE 384

 #define CV_OWNED_BIT  0x1

@@ -30,7 +29,7 @@

 void cv_pin(cvalue_t *cv);

 value_t mk_mpint(mpint *n);

 value_t size_wrap(size_t sz);

-size_t toulong(value_t n);

+size_t tosize(value_t n);

 off_t tooffset(value_t n);

 int cvalue_enum_init(fltype_t *ft, value_t arg, void *dest);

 int isarray(value_t v);

@@ -46,7 +45,7 @@

 value_t cbuiltin(char *name, builtin_t f);

 value_t return_from_uint64(uint64_t Uaccum);

 value_t return_from_int64(int64_t Saccum);

-value_t fl_add_any(value_t *args, uint32_t nargs, fixnum_t carryIn);

+value_t fl_add_any(value_t *args, uint32_t nargs);

 value_t fl_neg(value_t n);

 value_t fl_mul_any(value_t *args, uint32_t nargs);

 int num_to_ptr(value_t a, fixnum_t *pi, numerictype_t *pt, void **pp);

@@ -63,11 +62,6 @@

 value_t mk_int64(int64_t n);

 value_t mk_uint64(uint64_t n);

 value_t mk_rune(Rune n);

-#if defined(ULONG64)

-value_t mk_ulong(uint64_t n);

-#else

-value_t mk_ulong(uint32_t n);

-#endif

 /* builtins.c */

 size_t llength(value_t v);

--- a/equal.c

+++ b/equal.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "operators.h"

 #include "opcodes.h"

@@ -9,10 +8,14 @@

 #define BOUNDED_COMPARE_BOUND 128

 #define BOUNDED_HASH_BOUND 16384

-#ifdef BITS64

+#if defined(BITS64)

 #define inthash int64hash

+#define MIX(a, b) int64hash((uint64_t)(a) ^ (uint64_t)(b));

+#define doublehash(a) int64hash(a)

 #else

 #define inthash int32hash

+#define MIX(a, b) int64to32hash((uint64_t)(a)<<32 | (uint64_t)(b));

+#define doublehash(a) int64to32hash(a)

 #endif

 // comparable tag

@@ -327,14 +330,6 @@

   * less redundant tag checking, 3-bit tags

 */

-#ifdef BITS64

-#define MIX(a, b) int64hash((uint64_t)(a) ^ (uint64_t)(b));

-#define doublehash(a) int64hash(a)

-#else

-#define MIX(a, b) int64to32hash(((uint64_t)(a))<<32 | ((uint64_t)(b)))

-#define doublehash(a) int64to32hash(a)

-#endif

-

 // *oob: output argument, means we hit the limit specified by 'bound'

 static uintptr_t

 bounded_hash(value_t a, int bound, int *oob)

@@ -377,7 +372,7 @@

 		if(cv->type == FL(mpinttype)){

 			len = mptobe(*(mpint**)data, nil, 0, (uint8_t**)&data);

 			h = memhash(data, len);

-			LLT_FREE(data);

+			MEM_FREE(data);

 		}else{

 			h = memhash(data, cv_len(cv));

 		}

--- a/equalhash.c

+++ b/equalhash.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "equalhash.h"

 #include "equal.h"

--- /dev/null

+++ b/fl_arith_any.inc

@@ -1,0 +1,164 @@

+//value_t

+//fl_*_any(value_t *args, uint32_t nargs)

+// input: ACCUM_DEFAULT ARITH_OP(a,b)   MP_OP   ARITH_OVERFLOW

+// add:   0             a+b             mpadd   sadd_overflow_64

+// mul:   1             a*b             mpmul   smul_overflow_64

+

+	mpint *Maccum = nil, *m = nil;

+	int64_t Saccum = ACCUM_DEFAULT, x;

+	uint64_t u64;

+	double Faccum = ACCUM_DEFAULT;

+	bool inexact = false;

+	value_t arg;

+	numerictype_t pt;

+	void *a;

+	cprim_t *cp;

+	cvalue_t *cv;

+

+	uint32_t i, j;

+	FOR_ARGS(i, 0, arg, args){

+		if(isfixnum(arg))

+			x = numval(arg);

+		else{

+			if(iscprim(arg)){

+				cp = ptr(arg);

+				a = cp_data(cp);

+				pt = cp_numtype(cp);

+			}else if(iscvalue(arg)){

+				cv = ptr(arg);

+				a = cv_data(cv);

+				pt = cv_class(cv)->numtype;

+			}else{

+typeerr:

+				mpfree(Maccum);

+				mpfree(m);

+				type_error("number", arg);

+			}

+			switch(pt){

+			case T_DOUBLE: Faccum = ARITH_OP(Faccum, *(double*)a); inexact = true; continue;

+			case T_FLOAT:  Faccum = ARITH_OP(Faccum, *(float*)a); inexact = true; continue;

+			case T_INT8:   x = *(int8_t*)a; break;

+			case T_UINT8:  x = *(uint8_t*)a; break;

+			case T_INT16:  x = *(int16_t*)a; break;

+			case T_UINT16: x = *(uint16_t*)a; break;

+			case T_INT32:  x = *(int32_t*)a; break;

+			case T_UINT32: x = *(uint32_t*)a; break;

+			case T_INT64:  x = *(int64_t*)a; break;

+			case T_UINT64:

+				u64 = *(uint64_t*)a;

+				if(u64 > INT64_MAX){

+					x = ACCUM_DEFAULT;

+					goto overflow;

+				}

+				x = u64;

+				break;

+			case T_MPINT:

+				x = ACCUM_DEFAULT;

+				u64 = ACCUM_DEFAULT;

+				m = mpcopy(*(mpint**)a);

+				goto overflow;

+			default:

+				goto typeerr;

+			}

+		}

+

+		int64_t accu;

+		if(ARITH_OVERFLOW(Saccum, x, &accu)){

+			u64 = ACCUM_DEFAULT;

+			goto overflow;

+		}

+		Saccum = accu;

+	}

+

+	if(inexact)

+		return mk_double(ARITH_OP(Faccum, Saccum));

+	if(fits_fixnum(Saccum))

+		return fixnum((fixnum_t)Saccum);

+	u64 = ACCUM_DEFAULT;

+	x = ACCUM_DEFAULT;

+

+overflow:

+	i++;

+	if(Maccum == nil)

+		Maccum = vtomp(Saccum, nil);

+	if(m == nil){

+		if(u64 != ACCUM_DEFAULT)

+			m = uvtomp(u64, nil);

+		else if(x != ACCUM_DEFAULT)

+			m = vtomp(x, nil);

+		else

+			m = mpnew(ACCUM_DEFAULT);

+	}

+

+	MP_OP(Maccum, m, Maccum);

+

+	FOR_ARGS(j, i, arg, args){

+		if(isfixnum(arg)){

+			vtomp(numval(arg), m);

+			MP_OP(Maccum, m, Maccum);

+			continue;

+		}

+

+		if(iscprim(arg)){

+			cp = ptr(arg);

+			a = cp_data(cp);

+			pt = cp_numtype(cp);

+		}else if(iscvalue(arg)){

+			cv = ptr(arg);

+			a = cv_data(cv);

+			pt = cv_class(cv)->numtype;

+		}else{

+			goto typeerr;

+		}

+		switch(pt){

+		case T_DOUBLE: Faccum = ARITH_OP(Faccum, *(double*)a); inexact = true; continue;

+		case T_FLOAT:  Faccum = ARITH_OP(Faccum, *(float*)a); inexact = true; continue;

+		case T_INT8:   x = *(int8_t*)a; break;

+		case T_UINT8:  x = *(uint8_t*)a; break;

+		case T_INT16:  x = *(int16_t*)a; break;

+		case T_UINT16: x = *(uint16_t*)a; break;

+		case T_INT32:  x = *(int32_t*)a; break;

+		case T_UINT32: x = *(uint32_t*)a; break;

+		case T_INT64:  x = *(int64_t*)a; break;

+		case T_UINT64:

+			uvtomp(*(uint64_t*)a, m);

+			MP_OP(Maccum, m, Maccum);

+			continue;

+		case T_MPINT:

+			MP_OP(Maccum, *(mpint**)a, Maccum);

+			continue;

+		default:

+			goto typeerr;

+		}

+		vtomp(x, m);

+		MP_OP(Maccum, m, Maccum);

+	}

+

+	int n = mpsignif(Maccum);

+	if(n >= FIXNUM_BITS){

+		if(inexact){

+			dtomp(Faccum, m);

+			MP_OP(Maccum, m, Maccum);

+			n = mpsignif(Maccum);

+			if(n < FIXNUM_BITS){

+				inexact = false;

+				goto down;

+			}

+		}

+		mpfree(m);

+		return mk_mpint(Maccum);

+	}

+

+down:

+	mpfree(m);

+	Saccum = mptov(Maccum);

+	mpfree(Maccum);

+	if(inexact)

+		return mk_double(ARITH_OP(Faccum, Saccum));

+	assert(fits_fixnum(Saccum));

+	return fixnum((fixnum_t)Saccum);

+

+#undef ACCUM_DEFAULT

+#undef ARITH_OP

+#undef MP_OP

+#undef ARITH_OVERFLOW

--- a/flisp.c

+++ b/flisp.c

@@ -5,7 +5,6 @@

   Distributed under the BSD License

 */

-#include "llt.h"

 #include "flisp.h"

 #include "operators.h"

 #include "cvalues.h"

@@ -286,7 +285,7 @@

 	value_t *first;

 	assert(n > 0);

-	n = LLT_ALIGN(n, 2);   // only allocate multiples of 2 words

+	n = ALIGNED(n, 2);   // only allocate multiples of 2 words

 	if(__unlikely((value_t*)FL(curheap) > (value_t*)FL(lim)+2-n)){

 		gc(0);

 		while((value_t*)FL(curheap) > ((value_t*)FL(lim))+2-n)

@@ -497,7 +496,7 @@

 	sweep_finalizers();

-#ifdef VERBOSEGC

+#if defined(VERBOSEGC)

 	printf("GC: found %d/%d live conses\n",

 		   (FL(curheap)-FL(tospace))/sizeof(cons_t), FL(heapsize)/sizeof(cons_t));

 #endif

@@ -509,7 +508,7 @@

 	// 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(FL(grew) || ((FL(lim)-FL(curheap)) < (int)(FL(heapsize)/5)) || mustgrow){

-		temp = LLT_REALLOC(FL(tospace), FL(heapsize)*2);

+		temp = MEM_REALLOC(FL(tospace), FL(heapsize)*2);

 		if(__unlikely(temp == nil))

 			fl_raise(FL(memory_exception_value));

 		FL(tospace) = temp;

@@ -534,7 +533,7 @@

 grow_stack(void)

 {

 	size_t newsz = FL(nstack) * 2;

-	value_t *ns = LLT_REALLOC(FL(stack), newsz*sizeof(value_t));

+	value_t *ns = MEM_REALLOC(FL(stack), newsz*sizeof(value_t));

 	if(__unlikely(ns == nil))

 		lerrorf(FL(MemoryError), "stack overflow");

 	FL(stack) = ns;

@@ -786,7 +785,7 @@

 		if(__unlikely(i >= nargs))

 			lerrorf(FL(ArgError), "keyword %s requires an argument", symbol_name(v));

 		value_t hv = fixnum(((symbol_t*)ptr(v))->hash);

-		lltint_t lx = numval(hv);

+		fixnum_t lx = numval(hv);

 		uintptr_t x = 2*((lx < 0 ? -lx : lx) % n);

 		if(__likely(vector_elt(kwtable, x) == v)){

 			uintptr_t idx = numval(vector_elt(kwtable, x+1));

@@ -866,7 +865,9 @@

 	int tail, x;

 	// temporary variables (not necessary to preserve across calls)

-	uint32_t op, i, ipd;

+	size_t isz;

+	uint8_t op;

+	uint32_t i, ipd;

 	symbol_t *sym;

 	cons_t *c;

 	value_t *pv;

@@ -895,7 +896,7 @@

 	PUSH(0); // captured?

 	FL(curr_frame) = FL(sp);

-#ifdef COMPUTED_GOTO

+#if defined(COMPUTED_GOTO)

 #pragma GCC diagnostic push

 #pragma GCC diagnostic ignored "-Wpedantic"

 #define OP(x) op_##x:

@@ -1060,9 +1061,9 @@

 					if(isbuiltin(func)){

 						s = builtins[i].nargs;

 						if(s >= 0)

-							argcount(n, s);

+							argcount(n, (unsigned)s);

 						else if(s != ANYARGS && (signed)n < -s)

-							argcount(n, -s);

+							argcount(n, (unsigned)-s);

 						// remove function arg

 						for(s = FL(sp)-n-1; s < (int)FL(sp)-1; s++)

 							FL(stack)[s] = FL(stack)[s+1];

@@ -1077,7 +1078,7 @@

 						case OP_DIV:	goto apply_div;

 						default:

 							op = i;

-#ifdef COMPUTED_GOTO

+#if defined(COMPUTED_GOTO)

 							goto *((uint8_t*)&&op_OP_LOADA0 + ops[i]);

 #else

 							continue;

@@ -1259,10 +1260,10 @@

 			v = FL(stack)[FL(sp)-2];

 			if(isvector(v)){

 				e = FL(stack)[FL(sp)-1];

-				i = isfixnum(e) ? numval(e) : (uint32_t)toulong(e);

-				if(__unlikely(i >= vector_size(v)))

+				isz = tosize(e);

+				if(__unlikely(isz >= vector_size(v)))

 					bounds_error(v, e);

-				v = vector_elt(v, i);

+				v = vector_elt(v, isz);

 			}else if(__likely(isarray(v))){

 				v = cvalue_array_aref(&FL(stack)[FL(sp)-2]);

 			}else{

@@ -1297,13 +1298,24 @@

 			NEXT_OP;

 		OP(OP_ADD2)

+		do_add2:

 			FL(stack)[ipd] = (uintptr_t)ip;

-			if(bothfixnums(FL(stack)[FL(sp)-1], FL(stack)[FL(sp)-2])){

-				s = numval(FL(stack)[FL(sp)-1]) + numval(FL(stack)[FL(sp)-2]);

-				v = fits_fixnum(s) ? fixnum(s) : mk_xlong(s);

-			}else{

-				v = fl_add_any(&FL(stack)[FL(sp)-2], 2, 0);

+			if(0){

+		OP(OP_SUB2)

+		do_sub2:

+				FL(stack)[ipd] = (uintptr_t)ip;

+				FL(stack)[FL(sp)-1] = fl_neg(FL(stack)[FL(sp)-1]);

 			}

+			{

+				fixnum_t a, b, c;

+				a = FL(stack)[FL(sp)-2];

+				b = FL(stack)[FL(sp)-1];

+				if(bothfixnums(a, b) && !sadd_overflow(numval(a), numval(b), &c) && fits_fixnum(c)){

+					v = fixnum(c);

+				}else{

+					v = fl_add_any(&FL(stack)[FL(sp)-2], 2);

+				}

+			}

 			POPN(1);

 			FL(stack)[FL(sp)-1] = v;

 			NEXT_OP;

@@ -1499,25 +1511,11 @@

 		OP(OP_ADD)

 			n = *ip++;

+			if(n == 2)

+				goto do_add2;

 		apply_add:

-			s = 0;

-			i = FL(sp)-n;

-			for(; i < FL(sp); i++){

-				if(isfixnum(FL(stack)[i])){

-					s += numval(FL(stack)[i]);

-					if(__unlikely(!fits_fixnum(s))){

-						i++;

-						goto add_ovf;

-					}

-				}else{

-				add_ovf:

-					FL(stack)[ipd] = (uintptr_t)ip;

-					v = fl_add_any(&FL(stack)[i], FL(sp)-i, s);

-					break;

-				}

-			}

-			if(i == FL(sp))

-				v = fixnum(s);

+			FL(stack)[ipd] = (uintptr_t)ip;

+			v = fl_add_any(&FL(stack)[FL(sp)-n], n);

 			POPN(n);

 			PUSH(v);

 			NEXT_OP;

@@ -1535,27 +1533,13 @@

 			// so it can handle rest args properly

 			PUSH(FL(stack)[i]);

 			FL(stack)[i] = fixnum(0);

-			FL(stack)[i+1] = fl_neg(fl_add_any(&FL(stack)[i], n, 0));

+			FL(stack)[i+1] = fl_neg(fl_add_any(&FL(stack)[i], n));

 			FL(stack)[i] = POP();

-			v = fl_add_any(&FL(stack)[i], 2, 0);

+			v = fl_add_any(&FL(stack)[i], 2);

 			POPN(n);

 			PUSH(v);

 			NEXT_OP;

-		OP(OP_SUB2)

-		do_sub2:

-			if(bothfixnums(FL(stack)[FL(sp)-2], FL(stack)[FL(sp)-1])){

-				s = numval(FL(stack)[FL(sp)-2]) - numval(FL(stack)[FL(sp)-1]);

-				v = fits_fixnum(s) ? fixnum(s) : mk_xlong(s);

-			}else{

-				FL(stack)[ipd] = (uintptr_t)ip;

-				FL(stack)[FL(sp)-1] = fl_neg(FL(stack)[FL(sp)-1]);

-				v = fl_add_any(&FL(stack)[FL(sp)-2], 2, 0);

-			}

-			POPN(1);

-			FL(stack)[FL(sp)-1] = v;

-			NEXT_OP;

-

 		OP(OP_MUL)

 			n = *ip++;

 		apply_mul:

@@ -1857,7 +1841,7 @@

 		OP(OP_NOP)

 			NEXT_OP;

-#ifdef COMPUTED_GOTO

+#if defined(COMPUTED_GOTO)

 #pragma GCC diagnostic pop

 #else

 		}

@@ -2184,8 +2168,8 @@

 	FL(heapsize) = initial_heapsize;

-	FL(fromspace) = LLT_ALLOC(FL(heapsize));

-	FL(tospace)   = LLT_ALLOC(FL(heapsize));

+	FL(fromspace) = MEM_ALLOC(FL(heapsize));

+	FL(tospace)   = MEM_ALLOC(FL(heapsize));

 	FL(curheap) = FL(fromspace);

 	FL(lim) = FL(curheap)+FL(heapsize)-sizeof(cons_t);

 	FL(consflags) = bitvector_new(FL(heapsize)/sizeof(cons_t), 1);

@@ -2192,7 +2176,7 @@

 	htable_new(&FL(printconses), 32);

 	comparehash_init();

 	FL(nstack) = 262144;

-	FL(stack) = LLT_ALLOC(FL(nstack)*sizeof(value_t));

+	FL(stack) = MEM_ALLOC(FL(nstack)*sizeof(value_t));

 	FL(Nil) = builtin(OP_THE_EMPTY_LIST);

 	FL(t) = builtin(OP_BOOL_CONST_T);

@@ -2262,21 +2246,7 @@

 	setc(symbol("procedure?"), builtin(OP_FUNCTIONP));

 	setc(symbol("top-level-bound?"), builtin(OP_BOUNDP));

-#if defined(__linux__)

-	set(symbol("*os-name*"), symbol("linux"));

-#elif defined(__OpenBSD__)

-	set(symbol("*os-name*"), symbol("openbsd"));

-#elif defined(__FreeBSD__)

-	set(symbol("*os-name*"), symbol("freebsd"));

-#elif defined(__NetBSD__)

-	set(symbol("*os-name*"), symbol("netbsd"));

-#elif defined(__DragonFly__)

-	set(symbol("*os-name*"), symbol("dragonflybsd"));

-#elif defined(__plan9__)

-	set(symbol("*os-name*"), symbol("plan9"));

-#else

-	set(symbol("*os-name*"), symbol("unknown"));

-#endif

+	set(symbol("*os-name*"), symbol(__os_name__));

 	FL(the_empty_vector) = tagptr(alloc_words(1), TAG_VECTOR);

 	vector_setsize(FL(the_empty_vector), 0);

--- a/flisp.h

+++ b/flisp.h

@@ -1,5 +1,12 @@

 #pragma once

+#include "platform.h"

+#include "utf8.h"

+#include "ios.h"

+#include "bitvector.h"

+#include "htableh.inc"

+HTPROT(ptrhash)

+

 enum {

 	TAG_NUM,

 	TAG_CPRIM,

@@ -26,9 +33,22 @@

 	T_DOUBLE,

 }numerictype_t;

-typedef uintptr_t value_t;

-typedef lltint_t fixnum_t;

+#ifdef BITS64

+typedef uint64_t value_t;

+typedef int64_t fixnum_t;

+#define FIXNUM_BITS 62

+#define TOP_BIT (1ULL<<63)

+#define T_FIXNUM T_INT64

+#else

+typedef uint32_t value_t;

+typedef int32_t fixnum_t;

+#define FIXNUM_BITS 30

+#define TOP_BIT (1U<<31)

+#define T_FIXNUM T_INT32

+#endif

+#define ALIGNED(x, sz) (((x) + (sz-1)) & (-sz))

+

 typedef struct {

 	value_t car;

 	value_t cdr;

@@ -68,15 +88,8 @@

 typedef value_t (*builtin_t)(value_t*, uint32_t);

-#ifdef BITS64

-#define T_FIXNUM T_INT64

-#define fits_fixnum(x) (((x)>>61) == 0 || (~((x)>>61)) == 0)

-#define mk_xlong mk_int64

-#else

-#define T_FIXNUM T_INT32

-#define fits_fixnum(x) (((x)>>29) == 0 || (~((x)>>29)) == 0)

-#define mk_xlong mk_int32

-#endif

+#define fits_bits(x, b) (((x)>>(b-1)) == 0 || (~((x)>>(b-1))) == 0)

+#define fits_fixnum(x) fits_bits(x, FIXNUM_BITS)

 #define ANYARGS -10000

 #define NONNUMERIC (0xff)

@@ -88,7 +101,6 @@

 #define tagptr(p, t) ((value_t)(p) | (t))

 #define fixnum(x) ((value_t)(x)<<2)

 #define numval(x)  ((fixnum_t)(x)>>2)

-#define fits_bits(x, b) (((x)>>(b-1)) == 0 || (~((x)>>(b-1))) == 0) /* mag: UNUSED? */

 #define uintval(x) (((unsigned int)(x))>>3)

 #define builtin(n) tagptr(((int)n<<3), TAG_FUNCTION)

 #define iscons(x) (tag(x) == TAG_CONS)

@@ -428,3 +440,8 @@

 extern Fl fl;

 #define FL(f) fl.f

+

+extern double D_PNAN, D_NNAN, D_PINF, D_NINF;

+extern float F_PNAN, F_NNAN, F_PINF, F_NINF;

+

+_Noreturn void flmain(const uint8_t *boot, int bootsz, int argc, char **argv);

--- a/flmain.c

+++ b/flmain.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "cvalues.h"

 #include "print.h"

--- a/hashing.c

+++ b/hashing.c

@@ -1,9 +1,9 @@

-#include "llt.h"

+#include "flisp.h"

 #include "hashing.h"

 #include "spooky.h"

-lltuint_t

-nextipow2(lltuint_t i)

+value_t

+nextipow2(value_t i)

 {

 	if(i == 0)

 		return 1;

@@ -12,7 +12,7 @@

 	i |= i >> 4;

 	i |= i >> 8;

 	i |= i >> 16;

-#ifdef BITS64

+#if defined(BITS64)

 	i |= i >> 32;

 #endif

 	i++;

--- a/hashing.h

+++ b/hashing.h

@@ -1,6 +1,6 @@

 #pragma once

-lltuint_t nextipow2(lltuint_t i);

+value_t nextipow2(value_t i);

 uint32_t int32hash(uint32_t a);

 uint64_t int64hash(uint64_t key);

 uint32_t int64to32hash(uint64_t key);

--- a/htable.c

+++ b/htable.c

@@ -2,7 +2,7 @@

   functions common to all hash table instantiations

 */

-#include "llt.h"

+#include "flisp.h"

 #include "htable.h"

 #include "hashing.h"

@@ -17,7 +17,7 @@

 		size *= 2; // 2 pointers per key/value pair

 		size *= 2; // aim for 50% occupancy

 		h->size = size;

-		h->table = LLT_ALLOC(size*sizeof(void*));

+		h->table = MEM_ALLOC(size*sizeof(void*));

 	}

 	if(h->table == nil)

 		return nil;

@@ -31,7 +31,7 @@

 htable_free(htable_t *h)

 {

 	if(h->table != &h->_space[0])

-		LLT_FREE(h->table);

+		MEM_FREE(h->table);

 }

 // empty and reduce size

@@ -41,7 +41,7 @@

 	sz = nextipow2(sz);

 	if(h->size > sz*4 && h->size > HT_N_INLINE){

 		size_t newsz = sz*4;

-		void **newtab = LLT_REALLOC(h->table, newsz*sizeof(void*));

+		void **newtab = MEM_REALLOC(h->table, newsz*sizeof(void*));

 		if(newtab == nil)

 			return;

 		h->size = newsz;

--- a/htable.inc

+++ b/htable.inc

@@ -13,7 +13,7 @@

 static void ** \

 HTNAME##_lookup_bp(htable_t *h, void *key) \

 { \

-	lltuint_t hv; \

+	value_t hv; \

 	size_t i, orig, index, iter; \

 	size_t newsz, sz = hash_size(h); \

 	size_t maxprobe = max_probe(sz); \

@@ -52,7 +52,7 @@

 		newsz = HT_N_INLINE; \

 	else \

 		newsz = sz<<2; \

-	tab = (void**)LLT_ALLOC(newsz*sizeof(void*)); \

+	tab = (void**)MEM_ALLOC(newsz*sizeof(void*)); \

 	if(tab == nil) \

 		return nil; \

 	for(i = 0; i < newsz; i++) \

@@ -64,7 +64,7 @@

 			(*HTNAME##_lookup_bp(h, ol[i])) = ol[i+1]; \

 	} \

 	if(ol != &h->_space[0]) \

-		LLT_FREE(ol); \

+		MEM_FREE(ol); \

 	sz = hash_size(h); \

 	maxprobe = max_probe(sz); \

 	tab = h->table; \

--- a/ios.c

+++ b/ios.c

@@ -1,4 +1,4 @@

-#include "llt.h"

+#include "flisp.h"

 #include "timefuncs.h"

 #define MOST_OF(x) ((x) - ((x)>>4))

@@ -26,7 +26,7 @@

 static int

 _enonfatal(int err)

 {

-	return err == EAGAIN || err == EINPROGRESS || err == EINTR || err == EWOULDBLOCK;

+	return err == 0 || err == EAGAIN || err == EINPROGRESS || err == EINTR || err == EWOULDBLOCK;

 }

 #define SLEEP_TIME 5//ms

 #endif

@@ -39,6 +39,9 @@

 	ssize_t r;

 	while(1){

+#if !defined(__plan9__)

+		errno = 0;

+#endif

 		r = read(fd, buf, n);

 		if(r > -1){

 			*nread = (size_t)r;

@@ -81,6 +84,9 @@

 	ssize_t r;

 	while(1){

+#if !defined(__plan9__)

+		errno = 0;

+#endif

 		r = write(fd, buf, n);

 		if(r > -1){

 			*nwritten = (size_t)r;

@@ -140,11 +146,11 @@

 		// if we own the buffer we're free to resize it

 		// always allocate 1 bigger in case user wants to add a NUL

 		// terminator after taking over the buffer

-		temp = LLT_REALLOC(s->buf, sz);

+		temp = MEM_REALLOC(s->buf, sz);

 		if(temp == nil)

 			return nil;

 	}else{

-		temp = LLT_ALLOC(sz);

+		temp = MEM_ALLOC(sz);

 		if(temp == nil)

 			return nil;

 		s->ownbuf = 1;

@@ -533,11 +539,11 @@

 		close(s->fd);

 	s->fd = -1;

 	if(s->buf != nil && s->ownbuf && s->buf != &s->local[0])

-		LLT_FREE(s->buf);

+		MEM_FREE(s->buf);

 	s->buf = nil;

 	s->size = s->maxsize = s->bpos = 0;

 	if(s->filename != emptystr){

-		LLT_FREE(s->filename);

+		MEM_FREE(s->filename);

 		s->filename = emptystr;

 	}

 }

@@ -564,13 +570,13 @@

 	ios_flush(s);

 	if(s->buf == &s->local[0] || s->buf == nil || (!s->ownbuf && s->size == s->maxsize)){

-		buf = LLT_ALLOC(s->size+1);

+		buf = MEM_ALLOC(s->size+1);

 		if(buf == nil)

 			return nil;

 		if(s->size)

 			memcpy(buf, s->buf, s->size);

 	}else if(s->size == s->maxsize){

-		buf = LLT_REALLOC(s->buf, s->size + 1);

+		buf = MEM_REALLOC(s->buf, s->size + 1);

 		if(buf == nil)

 			return nil;

 	}else{

@@ -601,7 +607,7 @@

 	s->size = nvalid;

 	if(s->buf != nil && s->ownbuf && s->buf != &s->local[0])

-		LLT_FREE(s->buf);

+		MEM_FREE(s->buf);

 	s->buf = buf;

 	s->maxsize = size;

 	s->ownbuf = own;

@@ -738,7 +744,7 @@

 		goto open_file_err;

 	if(!wr)

 		s->readonly = 1;

-	s->filename = LLT_STRDUP(fname);

+	s->filename = MEM_STRDUP(fname);

 	return s;

 open_file_err:

 	s->fd = -1;

@@ -793,19 +799,19 @@

 void

 ios_init_stdstreams(void)

 {

-	ios_stdin = LLT_ALLOC(sizeof(ios_t));

+	ios_stdin = MEM_ALLOC(sizeof(ios_t));

 	ios_fd(ios_stdin, STDIN_FILENO, 0, 0);

-	ios_stdin->filename = LLT_STRDUP("*stdin*");

+	ios_stdin->filename = MEM_STRDUP("*stdin*");

-	ios_stdout = LLT_ALLOC(sizeof(ios_t));

+	ios_stdout = MEM_ALLOC(sizeof(ios_t));

 	ios_fd(ios_stdout, STDOUT_FILENO, 0, 0);

 	ios_stdout->bm = bm_line;

-	ios_stdout->filename = LLT_STRDUP("*stdout*");

+	ios_stdout->filename = MEM_STRDUP("*stdout*");

-	ios_stderr = LLT_ALLOC(sizeof(ios_t));

+	ios_stderr = MEM_ALLOC(sizeof(ios_t));

 	ios_fd(ios_stderr, STDERR_FILENO, 0, 0);

 	ios_stderr->bm = bm_none;

-	ios_stderr->filename = LLT_STRDUP("*stderr*");

+	ios_stderr->filename = MEM_STRDUP("*stderr*");

 }

 /* higher level interface */

@@ -873,7 +879,7 @@

 		return 1;

 	if(s->_eof)

 		return IOS_EOF;

-#ifdef __plan9__

+#if defined(__plan9__)

 	USED(ws);

 	return 1; // FIXME(sigrid): wait for input, but not too much

 #else

@@ -939,21 +945,24 @@

 	char *str;

 	int c;

-#if defined(__plan9__)

-	str = vsmprint(format, args);

-	if((c = strlen(str)) >= 0)

-#else

+	/* skip allocations if no buffering needed */

+	if(s->bm == bm_none && (s->state == bst_none || s->state == bst_wr))

+		return vdprintf(s->fd, format, args);

+

 	if((c = vsnprintf(buf, sizeof(buf), format, args)) < nelem(buf))

 		str = buf;

-	else{

-		str = LLT_ALLOC(c+1);

-		vsnprintf(str, sizeof(c+1), format, args);

+	else if(s->state == bst_none || s->state == bst_wr){

+		/* doesn't fit? prefer no allocations */

+		ios_flush(s);

+		return vdprintf(s->fd, format, args);

+	}else{

+		str = MEM_ALLOC(c+1);

+		c = vsnprintf(str, sizeof(c+1), format, args);

 	}

 	if(c > 0)

-#endif

-		ios_write(s, str, c);

+		c = ios_write(s, str, c);

 	if(str != buf)

-		LLT_FREE(str);

+		MEM_FREE(str);

 	return c;

 }

--- a/iostream.c

+++ b/iostream.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "cvalues.h"

 #include "types.h"

@@ -69,7 +68,7 @@

 ios_t *

 toiostream(value_t v)

 {

-	if(!isiostream(v))

+	if(__unlikely(!isiostream(v)))

 		type_error("iostream", v);

 	return value2c(ios_t*, v);

 }

@@ -204,7 +203,7 @@

 {

 	argcount(nargs, 2);

 	ios_t *s = toiostream(args[0]);

-	size_t pos = toulong(args[1]);

+	size_t pos = tosize(args[1]);

 	off_t res = ios_seek(s, (off_t)pos);

 	if(res < 0)

 		return FL(f);

@@ -241,7 +240,7 @@

 	if(nargs == 3){

 		// form (io.read s type count)

 		ft = get_array_type(args[1]);

-		n = toulong(args[2]) * ft->elsz;

+		n = tosize(args[2]) * ft->elsz;

 	}else{

 		ft = get_type(args[1]);

 		if(ft->eltype != nil && !iscons(cdr_(cdr_(args[1]))))

@@ -265,8 +264,8 @@

 get_start_count_args(value_t *args, uint32_t nargs, size_t sz, size_t *offs, size_t *nb)

 {

 	if(nargs > 1){

-		*offs = toulong(args[1]);

-		*nb = nargs > 2 ? toulong(args[2]) : sz - *offs;

+		*offs = tosize(args[1]);

+		*nb = nargs > 2 ? tosize(args[2]) : sz - *offs;

 		if(*offs >= sz || *offs + *nb > sz)

 			bounds_error(args[0], args[1]);

 	}

@@ -297,7 +296,7 @@

 static uint8_t

 get_delim_arg(value_t arg)

 {

-	size_t uldelim = toulong(arg);

+	size_t uldelim = tosize(arg);

 	if(uldelim > 0x7f){

 		// runes > 0x7f, or anything else > 0xff, are out of range

 		if((iscprim(arg) && cp_class(ptr(arg)) == FL(runetype)) || uldelim > 0xff)

@@ -348,7 +347,7 @@

 	ios_t *dest = toiostream(args[0]);

 	ios_t *src = toiostream(args[1]);

 	if(nargs == 3)

-		return size_wrap(ios_copy(dest, src, toulong(args[2])));

+		return size_wrap(ios_copy(dest, src, tosize(args[2])));

 	return size_wrap(ios_copyall(dest, src));

 }

@@ -367,7 +366,7 @@

 BUILTIN("io-set-line!", io_set_line)

 {

 	argcount(nargs, 2);

-	toiostream(args[0])->lineno = toulong(args[1]);

+	toiostream(args[0])->lineno = tosize(args[1]);

 	return FL(t);

 }

@@ -380,7 +379,7 @@

 BUILTIN("io-set-column!", io_set_column)

 {

 	argcount(nargs, 2);

-	toiostream(args[0])->colno = toulong(args[1]);

+	toiostream(args[0])->colno = tosize(args[1]);

 	return FL(t);

 }

--- a/llt.h

+++ /dev/null

@@ -1,33 +1,0 @@

-#pragma once

-

-#include "platform.h"

-#include "utf8.h"

-#include "ios.h"

-#include "bitvector.h"

-

-#include "htableh.inc"

-HTPROT(ptrhash)

-

-#define DBL_MAXINT (1LL<<53)

-#define FLT_MAXINT (1<<24)

-#define BIT63 0x8000000000000000ULL

-#define BIT31 0x80000000UL

-

-#ifdef BITS64

-#define TOP_BIT BIT63

-typedef uint64_t lltuint_t;

-typedef int64_t lltint_t;

-#else

-#define TOP_BIT BIT31

-typedef uint32_t lltuint_t;

-typedef int32_t lltint_t;

-#endif

-

-#define LOG2_10 3.3219280948873626

-#define rel_zero(a, b) (fabs((a)/(b)) < DBL_EPSILON)

-#define LLT_ALIGN(x, sz) (((x) + (sz-1)) & (-sz))

-

-extern double D_PNAN, D_NNAN, D_PINF, D_NINF;

-extern float F_PNAN, F_NNAN, F_PINF, F_NINF;

-

-_Noreturn void flmain(const uint8_t *boot, int bootsz, int argc, char **argv);

--- a/main_plan9.c

+++ b/main_plan9.c

@@ -1,4 +1,4 @@

-#include "llt.h"

+#include "flisp.h"

 extern uchar bootcode[];

 extern ulong bootlen;

--- a/main_posix.c

+++ b/main_posix.c

@@ -1,4 +1,4 @@

-#include "llt.h"

+#include "flisp.h"

 #include "ieee754.h"

 static const uint8_t boot[] =

--- a/meson.build

+++ b/meson.build

@@ -98,9 +98,8 @@

 endif

 sixel = get_option('sixel')

-

+libsixel_dep = []

 if sixel.disabled()

-	libsixel_dep = []

 	src += ['sixel_disabled.c']

 else

 	libsixel = dependency('libsixel', required: sixel)

@@ -107,7 +106,7 @@

 	if libsixel.found()

 		src += ['sixel.c']

 		libsixel_dep = [libsixel]

-	elif

+	else

 		src += ['sixel_disabled.c']

 	endif

 endif

@@ -164,8 +163,8 @@

 test('argv', flisp, args: ['argv.lsp'], workdir: tests_dir)

 test('hash', flisp, args: ['hashtest.lsp'], workdir: tests_dir)

-test('perf', flisp, args: ['perf.lsp'], workdir: tests_dir)

+test('perf', flisp, args: ['perf.lsp'], workdir: tests_dir, timeout: 60)

 test('tme', flisp, args: ['tme.lsp'], workdir: tests_dir)

-test('torture', flisp, args: ['torture.scm'], workdir: tests_dir)

+test('torture', flisp, args: ['torture.scm'], workdir: tests_dir, timeout: 60)

 test('torus', flisp, args: ['torus.lsp'], workdir: tests_dir)

 test('unit', flisp, args: ['unittest.lsp'], workdir: tests_dir)

--- a/mkfile

+++ b/mkfile

@@ -2,12 +2,13 @@

 BIN=/$objtype/bin

 TARG=flisp

-CFLAGS=$CFLAGS -p -D__plan9__ -D__${objtype}__ -I3rd -Iplan9

+CFLAGS=$CFLAGS -p -I. -I3rd -Iplan9 -D__plan9__ -D__${objtype}__ -DNDEBUG

 CLEANFILES=plan9/flisp.boot.s plan9/builtin_fns.h

 HFILES=\

 	equalhash.h\

 	flisp.h\

+	plan9/platform.h\

 OFILES=\

 	3rd/mt19937-64.$O\

@@ -46,9 +47,10 @@

 	sed -n 's/^BUILTIN[_]?(\(".*)/BUILTIN_FN\1/gp' \

 		`{ls `{echo $OFILES | sed 's/\.'$O'/.c/g'} >[2]/dev/null} | sort >$target

-main_plan9.$O: plan9/builtin_fns.h

-flisp.$O: maxstack.inc opcodes.h plan9/builtin_fns.h

 builtins.$O: plan9/builtin_fns.h

+cvalues.$O: fl_arith_any.inc

+flisp.$O: maxstack.inc opcodes.h plan9/builtin_fns.h

+main_plan9.$O: plan9/builtin_fns.h

 plan9/flisp.boot.s:D: flisp.boot

 	aux/data2s boot <flisp.boot >$target

--- a/operators.c

+++ b/operators.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "operators.h"

--- a/operators.h

+++ b/operators.h

@@ -14,11 +14,3 @@

 int32_t conv_to_int32(void *data, numerictype_t tag);

 uint32_t conv_to_uint32(void *data, numerictype_t tag);

 Rune conv_to_Rune(void *data, numerictype_t tag);

-

-#if defined(ULONG64)

-#define conv_to_long conv_to_int64

-#define conv_to_ulong conv_to_uint64

-#else

-#define conv_to_long conv_to_int32

-#define conv_to_ulong conv_to_uint32

-#endif

--- a/overflows.h

+++ /dev/null

@@ -1,29 +1,0 @@

-

-#define addof_int64(c,a,b) ( \

-  (b < 1)? \

-  ((INT64_MIN-(b) <= (a))?((c=(a)+(b))?0:1):1): \

-  ((INT64_MAX-(b) >= (a))?((c=(a)+(b))?0:1):1) \

-)

-

-#define subof_int64(c,a,b) ( \

-  (b < 1)? \

-  ((INT64_MAX+(b) >= (a))?((c=(a)-(b))?0:1):1): \

-  ((INT64_MIN+(b) <= (a))?((c=(a)-(b))?0:1):1) \

-)

-

-#define addof_uint64(c,a,b) ( \

-  b? \

-  ((UINT64_MAX-(b) >= (a))?((c=(a)+(b)),0):1): \

-  0 \

-)

-

-#define subof_uint64(c,a,b) ( \

-  (b < 1)? \

-  ((UINT64_MAX+(b) >= (a))?((c=(a)-(b))?0:1):1): \

-  (((b) <= (a))?((c=(a)-(b))?0:1):1) \

-)

-

-#define mulof(c,a,b) ( \

-  (((a) != 0) && ((c=(a)*(b))/(a) != (b)))?1:0 \

-)

-

--- a/plan9/platform.h

+++ b/plan9/platform.h

@@ -3,13 +3,35 @@

 #include <ctype.h>

 #include <mp.h>

+#ifdef NDEBUG

+#undef assert

+#define assert(x)

+#endif

+

+#define __os_name__ "plan9"

+

 #define __thread

-#define LLT_ALLOC(n) malloc(n)

-#define LLT_REALLOC(p, n) realloc((p), (n))

-#define LLT_FREE(x) free(x)

-#define LLT_STRDUP(s) strdup(s)

+#define MEM_ALLOC(n) malloc(n)

+#define MEM_REALLOC(p, n) realloc((p), (n))

+#define MEM_FREE(x) free(x)

+#define MEM_STRDUP(s) strdup(s)

+/* FIXME(sigrid): s*_overflow_* can be more optimal */

+

+#define sadd_overflow_64(a, b, c) ( \

+  (b < 1) ? \

+  ((INT64_MAX-(b) <= (a)) ? ((*(c)=(a)+(b)), 0) : 1) : \

+  ((INT64_MAX-(b) >= (a)) ? ((*(c)=(a)+(b)), 0) : 1) \

+)

+

+#define smul_overflow_64(a, b, c) ( \

+	((a)>0 ? ((b)>0 ? (a)>INT64_MAX/(b) : (b)<INT64_MIN/(a)) \

+	       : ((b)>0 ? (a)<INT64_MIN/(b) : ((a)!=0 && (b)<INT64_MAX/(a)))) \

+	? 1 \

+	: ((*(c)=(a)*(b)), 0) \

+)

+

 #if defined(__amd64__) || \

     defined(__arm64__) || \

     defined(__mips64__) || \

@@ -16,6 +38,15 @@

     defined(__power64__) || \

     defined(__sparc64__)

 #define BITS64

+#define PRIdPTR PRId64

+#define sadd_overflow(a, b, c) sadd_overflow_64(a, b, c)

+#else

+#define PRIdPTR "ld"

+#define sadd_overflow(a, b, c) ( \

+  (b < 1) ? \

+  ((INT32_MAX-(b) <= (a)) ? ((*(c)=(a)+(b)), 0) : 1) : \

+  ((INT32_MAX-(b) >= (a)) ? ((*(c)=(a)+(b)), 0) : 1) \

+)

 #endif

 #define unsetenv(name) putenv(name, "")

@@ -25,6 +56,7 @@

 #define getcwd getwd

 #define vsnprintf vsnprint

+#define vdprintf fprint

 #define snprintf snprint

 #define strcasecmp cistrcmp

 #define lseek seek

@@ -31,17 +63,12 @@

 #define towupper toupperrune

 #define towlower tolowerrune

 #define iswalpha isalpharune

-#define signbit(r) ((*(uint64_t*)&(r)) & BIT63)

+#define signbit(r) ((*(uint64_t*)&(r)) & (1ULL<<63))

 #define isfinite(d) (((*(uint64_t*)&(d))&0x7ff0000000000000ULL) != 0x7ff0000000000000ULL)

 #define PRIu32 "ud"

 #define PRId64 "lld"

 #define PRIu64 "llud"

-#ifdef BITS64

-#define PRIdPTR PRId64

-#else

-#define PRIdPTR "ld"

-#endif

 #define INT32_MAX 0x7fffffff

 #define UINT32_MAX 0xffffffffU

--- a/posix/platform.h

+++ b/posix/platform.h

@@ -25,17 +25,34 @@

 #include <wctype.h>

 #include <wchar.h>

-#define LLT_ALLOC(n) malloc((size_t)(n))

-#define LLT_REALLOC(p, n) realloc((p), (size_t)(n))

-#define LLT_FREE(x) free(x)

-#define LLT_STRDUP(s) strdup(s)

+#if defined(__linux__)

+#define __os_name__ "linux"

+#elif defined(__OpenBSD__)

+#define __os_name__ "openbsd"

+#elif defined(__FreeBSD__)

+#define __os_name__ "freebsd"

+#elif defined(__NetBSD__)

+#define __os_name__ "netbsd"

+#elif defined(__DragonFly__)

+#define __os_name__ "dragonflybsd"

+#else

+#define __os_name__ "unknown"

+#endif

+#define MEM_ALLOC(n) malloc((size_t)(n))

+#define MEM_REALLOC(p, n) realloc((p), (size_t)(n))

+#define MEM_FREE(x) free(x)

+#define MEM_STRDUP(s) strdup(s)

+

 #ifndef __SIZEOF_POINTER__

 #error pointer size unknown

 #elif __SIZEOF_POINTER__ == 8

-#define BITS64 1

-#define ULONG64 1

+#define BITS64

 #endif

+

+#define sadd_overflow __builtin_add_overflow

+#define sadd_overflow_64 __builtin_add_overflow

+#define smul_overflow_64 __builtin_mul_overflow

 #define nil NULL

 #define USED(x) ((void)(x))

--- a/posix/utf.h

+++ b/posix/utf.h

@@ -7,7 +7,7 @@

 	UTFmax = 4,

 };

-typedef int32_t Rune;

+typedef uint32_t Rune;

 int chartorune(Rune *rune, const char *str);

 int runetochar(char *str, const Rune *rune);

--- a/print.c

+++ b/print.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "operators.h"

 #include "opcodes.h"

@@ -7,6 +6,8 @@

 #include "print.h"

 #include "read.h"

+#define LOG2_10 3.321928094887362347870319429489

+

 static void

 outc(char c, ios_t *f)

 {

@@ -120,7 +121,7 @@

 	if((name[0] == '\0') ||

 		(name[0] == '.' && name[1] == '\0') ||

 		(name[0] == '#') ||

-		isnumtok(name, nil))

+		fl_read_numtok(name, nil, 0))

 		escape = 1;

 	i = 0;

 	while(name[i]){

@@ -592,27 +593,31 @@

 	if(fpart == 0)

 		dec = 0;

 	if(width == 0)

-		snprintf(format, 8, "%%.%d%s", dec, num_format);

+		snprintf(format, sizeof(format), "%%.%d%s", dec, num_format);

 	else

-		snprintf(format, 8, "%%%d.%d%s", width, dec, num_format);

+		snprintf(format, sizeof(format), "%%%d.%d%s", width, dec, num_format);

 	sz = snprintf(s, cnt, format, r);

 	/* trim trailing zeros from fractions. not when using scientific

 	   notation, since we might have e.g. 1.2000e+100. also not when we

 	   need a specific output width */

 	if(width == 0 && !keepz){

-		if(sz > 2 && fpart && num_format[1] != 'e'){

+		if(sz > 2 && fpart){

+			char *e = nil;

+			if(num_format[1] == 'e'){

+				while(s[--sz] != 'e');

+				e = s + sz--;

+			}

 			while(s[sz-1] == '0'){

 				s[sz-1] = '\0';

 				sz--;

 			}

 			// don't need trailing .

-			if(s[sz-1] == '.'){

+			if(s[sz-1] == '.')

 				s[--sz] = '\0';

-			}

+			if(num_format[1] == 'e')

+				strcpy(s+sz, e);

 		}

 	}

-	// TODO. currently 1.1e20 prints as 1.1000000000000000e+20; be able to

-	// get rid of all those zeros.

 }

 // 'weak' means we don't need to accurately reproduce the type, so

@@ -696,11 +701,7 @@

 			if(type == FL(floatsym) && !FL(print_princ) && !weak)

 				outc('f', f);

 		}

-#if defined(ULONG64)

-	}else if(type == FL(uint64sym) || type == FL(ulongsym)){

-#else

 	}else if(type == FL(uint64sym)){

-#endif

 		uint64_t ui64 = *(uint64_t*)data;

 		if(weak || FL(print_princ))

 			FL(hpos) += ios_printf(f, "%"PRIu64, ui64);

@@ -709,11 +710,8 @@

 	}else if(type == FL(bignumsym)){

 		mpint *i = *(mpint**)data;

 		char *s = mptoa(i, 10, nil, 0);

-		if(weak || FL(print_princ))

-			FL(hpos) += ios_printf(f, "%s", s);

-		else

-			FL(hpos) += ios_printf(f, "#%s(%s)", symbol_name(type), s);

-		LLT_FREE(s);

+		FL(hpos) += ios_printf(f, "%s", s);

+		MEM_FREE(s);

 	}else if(issymbol(type)){

 		// handle other integer prims. we know it's smaller than uint64

 		// at this point, so int64 is big enough to capture everything.

@@ -733,7 +731,7 @@

 			value_t eltype = car(cdr_(type));

 			size_t cnt, elsize;

 			if(iscons(cdr_(cdr_(type)))){

-				cnt = toulong(car_(cdr_(cdr_(type))));

+				cnt = tosize(car_(cdr_(cdr_(type))));

 				elsize = cnt ? len/cnt : 0;

 			}else{

 				// incomplete array type

--- a/ptrhash.c

+++ b/ptrhash.c

@@ -3,11 +3,11 @@

   optimized for storing info about particular values

 */

-#include "llt.h"

+#include "flisp.h"

 #define OP_EQ(x, y) ((x) == (y))

-#ifdef BITS64

+#if defined(BITS64)

 static uint64_t

 _pinthash(uint64_t key)

 {

--- a/random.c

+++ b/random.c

@@ -1,4 +1,4 @@

-#include "llt.h"

+#include "flisp.h"

 #include "mt19937-64.h"

 #include "timefuncs.h"

 #include "random.h"

--- a/read.c

+++ b/read.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "cvalues.h"

 #include "read.h"

@@ -21,85 +20,15 @@

 static value_t do_read_sexpr(Rctx *ctx, value_t label);

-#if defined(__plan9__)

-static int errno;

-static mpint *mp_vlong_min, *mp_vlong_max, *mp_uvlong_max;

-#endif

-

-static int64_t

-strtoll_mp(const char *nptr, char **rptr, int base, mpint **mp)

-{

-	int64_t x;

-	mpint *m;

-

-	*mp = nil;

-	errno = 0;

-	x = strtoll(nptr, rptr, base);

-#if defined(__plan9__)

-	if((x != INT64_MAX && x != INT64_MIN) || *rptr == nptr)

-		return x;

-	mpint *c;

-	m = strtomp(nptr, rptr, base, nil);

-	if(x == INT64_MAX){

-		if(mp_vlong_max == nil)

-			mp_vlong_max = vtomp(INT64_MAX, nil);

-		c = mp_vlong_max;

-	}else{

-		if(mp_vlong_min == nil)

-			mp_vlong_min = vtomp(INT64_MIN, nil);

-		c = mp_vlong_min;

-	}

-	if(mpcmp(c, m) == 0){

-		mpfree(m);

-		m = nil;

-	}

-#else

-	m = nil;

-	if(errno == ERANGE && (x == LLONG_MAX || x == LLONG_MIN))

-		m = strtomp(nptr, rptr, base, nil);

-#endif

-	*mp = m;

-	return x;

-}

-

-static uint64_t

-strtoull_mp(const char *nptr, char **rptr, int base, mpint **mp)

-{

-	uint64_t x;

-	mpint *m;

-

-	*mp = nil;

-	errno = 0;

-	x = strtoull(nptr, rptr, base);

-#if defined(__plan9__)

-	if(x != INT64_MAX || *rptr == nptr)

-		return x;

-	m = strtomp(nptr, rptr, base, nil);

-	if(mp_uvlong_max == nil)

-		mp_uvlong_max = uvtomp(INT64_MAX, nil);

-	if(mpcmp(mp_uvlong_max, m) == 0){

-		mpfree(m);

-		m = nil;

-	}

-#else

-	m = nil;

-	if(errno == ERANGE && x == ULLONG_MAX)

-		m = strtomp(nptr, rptr, base, nil);

-#endif

-	*mp = m;

-	return x;

-}

-

 #define RS value2c(ios_t*, FL(readstate)->source)

 bool

-isnumtok_base(const char *tok, value_t *pval, int base)

+fl_read_numtok(const char *tok, value_t *pval, int base)

 {

 	char *end;

 	int64_t i64;

-	uint64_t ui64;

 	double d;

-	mpint *mp = nil;

+	mpint *mp;

 	if(*tok == '\0')

 		return false;

 	if(!((tok[0] == '0' && tok[1] == 'x') || (base >= 15)) && strpbrk(tok, ".eEpP")){

@@ -141,31 +70,15 @@

 				*pval = mk_double(D_NINF);

 			return true;

 		}

-		i64 = strtoll_mp(tok, &end, base, &mp);

-		bool ok = *end == '\0';

-		if(pval)

-			*pval = mp == nil ? return_from_int64(i64) : mk_mpint(mp);

-		return ok;

 	}

-	ui64 = strtoull_mp(tok, &end, base, &mp);

+	i64 = strtoll(tok, &end, base);

+	mp = fits_fixnum(i64) ? nil : strtomp(tok, &end, base, nil);

 	bool ok = *end == '\0';

 	if(pval)

-		*pval = mp == nil ? return_from_uint64(ui64) : mk_mpint(mp);

+		*pval = mp == nil ? fixnum(i64) : mk_mpint(mp);

 	return ok;

 }

-bool

-isnumtok(const char *tok, value_t *pval)

-{

-	return isnumtok_base(tok, pval, 0);

-}

-

-static bool

-read_numtok(const char *tok, value_t *pval, int base)

-{

-	return isnumtok_base(tok, pval, base);

-}

-

 static char

 nextchar(void)

 {

@@ -317,7 +230,7 @@

 			if(cval == 'u' || cval == 'U' || cval == 'x'){

 				read_token(ctx, 'u', 0);

 				if(ctx->buf[1] != '\0'){ // not a solitary 'u','U','x'

-					if(!read_numtok(&ctx->buf[1], &ctx->tokval, 16))

+					if(!fl_read_numtok(&ctx->buf[1], &ctx->tokval, 16))

 						parse_error("invalid hex character constant");

 					cval = numval(ctx->tokval);

 				}

@@ -415,7 +328,7 @@

 			    (c == 'o' && (base = 8)) ||

 			    (c == 'd' && (base = 10)) ||

 			    (c == 'x' && (base = 16))) && (isdigit_base(ctx->buf[1], base) || ctx->buf[1] == '-')){

-				if(!read_numtok(&ctx->buf[1], &ctx->tokval, base))

+				if(!fl_read_numtok(&ctx->buf[1], &ctx->tokval, base))

 					parse_error("invalid base %d constant", base);

 				return (ctx->toktype = TOK_NUM);

 			}

@@ -441,7 +354,7 @@

 		if(!read_token(ctx, c, 0)){

 			if(ctx->buf[0] == '.' && ctx->buf[1] == '\0')

 				return (ctx->toktype = TOK_DOT);

-			if(read_numtok(ctx->buf, &ctx->tokval, 0))

+			if(fl_read_numtok(ctx->buf, &ctx->tokval, 0))

 				return (ctx->toktype = TOK_NUM);

 		}

 		ctx->toktype = TOK_SYM;

@@ -512,13 +425,13 @@

 	value_t s;

 	Rune r = 0;

-	buf = LLT_ALLOC(sz);

+	buf = MEM_ALLOC(sz);

 	while(1){

 		if(i >= sz-UTFmax){ // -UTFmax: leaves room for longest utf8 sequence

 			sz *= 2;

-			temp = LLT_REALLOC(buf, sz);

+			temp = MEM_REALLOC(buf, sz);

 			if(temp == nil){

-				LLT_FREE(buf);

+				MEM_FREE(buf);

 				parse_error("out of memory reading string");

 			}

 			buf = temp;

@@ -525,7 +438,7 @@

 		}

 		c = ios_getc(RS);

 		if(c == IOS_EOF){

-			LLT_FREE(buf);

+			MEM_FREE(buf);

 			parse_error("unexpected end of input in string");

 		}

 		if(c == '"')

@@ -533,7 +446,7 @@

 		else if(c == '\\'){

 			c = ios_getc(RS);

 			if(c == IOS_EOF){

-				LLT_FREE(buf);

+				MEM_FREE(buf);

 				parse_error("end of input in escape sequence");

 			}

 			j = 0;

@@ -561,7 +474,7 @@

 				if(j)

 					r = strtol(eseq, nil, 16);

 				if(!j || r > Runemax){

-					LLT_FREE(buf);

+					MEM_FREE(buf);

 					parse_error("invalid escape sequence");

 				}

 				if(ndig == 2)

@@ -573,7 +486,7 @@

 			}else{

 				char esc = read_escape_control_char((char)c);

 				if(esc == (char)c && !strchr("\\'\"`", esc)){

-					LLT_FREE(buf);

+					MEM_FREE(buf);

 					parse_error("invalid escape sequence: \\%c", (char)c);

 				}

 				buf[i++] = esc;

@@ -584,7 +497,7 @@

 	}

 	s = cvalue_string(i);

 	memcpy(cvalue_data(s), buf, i);

-	LLT_FREE(buf);

+	MEM_FREE(buf);

 	return s;

 }

--- a/read.h

+++ b/read.h

@@ -1,8 +1,7 @@

 #pragma once

 value_t fl_read_sexpr(value_t f);

-bool isnumtok_base(const char *tok, value_t *pval, int base);

-bool isnumtok(const char *tok, value_t *pval);

+bool fl_read_numtok(const char *tok, value_t *pval, int base);

 // defines which characters are ordinary symbol characters.

 // exceptions are '.', which is an ordinary symbol character

--- a/sixel.c

+++ b/sixel.c

@@ -1,5 +1,4 @@

 #include <sixel.h>

-#include "llt.h"

 #include "flisp.h"

 #include "cvalues.h"

 #include "types.h"

@@ -48,7 +47,7 @@

 	int numcolors = 256;

 	if(nargs > 0){

 		argcount(nargs, 1);

-		numcolors = toulong(args[0]);

+		numcolors = tosize(args[0]);

 	}

 	if(numcolors < 1 || numcolors > 256)

 		lerrorf(FL(ArgError), "invalid number of colors: %d", numcolors);

@@ -79,10 +78,10 @@

 	if(!issixeloutput(args[0]))

 		type_error("sixel-output", args[0]);

 	fso_t *f = value2c(fso_t*, args[0]);

-	int scalex = toulong(args[1]);

+	int scalex = tosize(args[1]);

 	int scaley = scalex;

 	if(nargs > 2)

-		scaley = toulong(args[2]);

+		scaley = tosize(args[2]);

 	if(scalex < 1 || scalex > 32 || scaley < 1 || scaley > 32)

 		lerrorf(FL(ArgError), "invalid scale factor: %dx%d", scalex, scaley);

 	f->scalex = scalex;

@@ -175,8 +174,8 @@

 	uint8_t *pix;

 	size_t sz;

 	to_sized_ptr(args[2], &pix, &sz);

-	size_t w = toulong(args[3]);

-	size_t h = toulong(args[4]);

+	size_t w = tosize(args[3]);

+	size_t h = tosize(args[4]);

 	if(w <= 0 || w > sz)

 		bounds_error(args[2], args[3]);

 	if(h <= 0 || w*h > sz)

@@ -187,7 +186,7 @@

 		if(ow < 1 || oh < 1 || osz < ow || osz < oh)

 			lerrorf(FL(ArgError), "scaling out of range");

 		if(f->bufsz < osz){

-			f->buf = LLT_REALLOC(f->buf, osz);

+			f->buf = MEM_REALLOC(f->buf, osz);

 			f->bufsz = osz;

 		}

 		r = sixel_helper_scale_image(

@@ -205,7 +204,7 @@

 		h = oh;

 		pix = f->buf;

 	}else if(f->buf != nil){

-		LLT_FREE(f->buf);

+		MEM_FREE(f->buf);

 		f->buf = nil;

 		f->bufsz = 0;

 	}

@@ -240,7 +239,7 @@

 	fso_t *f = value2c(fso_t*, self);

 	sixel_dither_destroy(f->dither);

 	sixel_output_destroy(f->out);

-	LLT_FREE(f->buf);

+	MEM_FREE(f->buf);

 }

 static cvtable_t fso_vtable = {

--- a/string.c

+++ b/string.c

@@ -1,7 +1,6 @@

 /*

   string functions

 */

-#include "llt.h"

 #include "flisp.h"

 #include "operators.h"

 #include "cvalues.h"

@@ -26,11 +25,11 @@

 	size_t len = cv_len((cvalue_t*)ptr(args[0]));

 	size_t stop = len;

 	if(nargs > 1){

-		start = toulong(args[1]);

+		start = tosize(args[1]);

 		if(start > len)

 			bounds_error(args[0], args[1]);

 		if(nargs > 2){

-			stop = toulong(args[2]);

+			stop = tosize(args[2]);

 			if(stop > len)

 				bounds_error(args[0], args[2]);

 			if(stop <= start)

@@ -185,7 +184,7 @@

 		argcount(nargs, 3);

 	char *s = tostring(args[0]);

 	size_t lenbytes = cv_len((cvalue_t*)ptr(args[0]));

-	size_t startbytes, n, startchar = toulong(args[1]);

+	size_t startbytes, n, startchar = tosize(args[1]);

 	for(startbytes = n = 0; n < startchar && startbytes < lenbytes; n++)

 		startbytes += u8_seqlen(s+startbytes);

 	if(n != startchar)

@@ -192,7 +191,7 @@

 		bounds_error(args[0], args[1]);

 	size_t endbytes = lenbytes;

 	if(nargs == 3){

-		size_t endchar = toulong(args[2]);

+		size_t endchar = tosize(args[2]);

 		for(endbytes = startbytes; n < endchar && endbytes < lenbytes; n++)

 			endbytes += u8_seqlen(s+endbytes);

 		if(n != endchar)

@@ -211,7 +210,7 @@

 	argcount(nargs, 2);

 	char *s = tostring(args[0]);

 	size_t lenbytes = cv_len(ptr(args[0]));

-	size_t startbytes, n, startchar = toulong(args[1]);

+	size_t startbytes, n, startchar = tosize(args[1]);

 	for(startbytes = n = 0; n < startchar && startbytes < lenbytes; n++)

 		startbytes += u8_seqlen(s+startbytes);

 	if(n != startchar)

@@ -307,7 +306,7 @@

 	char cbuf[UTFmax+1];

 	size_t start = 0;

 	if(nargs == 3)

-		start = toulong(args[2]);

+		start = tosize(args[2]);

 	else

 		argcount(nargs, 2);

 	char *s = tostring(args[0]);

@@ -350,7 +349,7 @@

 static unsigned long

 get_radix_arg(value_t arg)

 {

-	unsigned long radix = toulong(arg);

+	unsigned long radix = tosize(arg);

 	if(radix < 2 || radix > 36)

 		lerrorf(FL(ArgError), "invalid radix");

 	return radix;

@@ -392,7 +391,7 @@

 	unsigned long radix = 0;

 	if(nargs == 2)

 		radix = get_radix_arg(args[1]);

-	if(!isnumtok_base(str, &n, (int)radix))

+	if(!fl_read_numtok(str, &n, (int)radix))

 		return FL(f);

 	return n;

 }

--- a/table.c

+++ b/table.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "equalhash.h"

 #include "cvalues.h"

--- a/terminal_posix.c

+++ b/terminal_posix.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include <sys/ioctl.h>

 #include <termios.h>

--- a/test/number-boundaries.lsp

+++ b/test/number-boundaries.lsp

@@ -81,17 +81,16 @@

 ; mul signed

 (assert (= 18446744073709551614 (* (high-border int64) 2)))

-;(assert (= -18446744073709551614 (* (high-border int64) -2)))

+(assert (= -18446744073709551614 (* (high-border int64) -2)))

 (assert (= 18446744073709551614 (* 2 (high-border int64))))

-;(assert (= -18446744073709551616 (* (low-border int64) 2)))

-;(assert (= -18446744073709551616 (* 2 (low-border int64))))

+(assert (= -18446744073709551616 (* (low-border int64) 2)))

+(assert (= -18446744073709551616 (* 2 (low-border int64))))

 ; mul unsigned

-;(assert (= 36893488147419103230 (* (high-border uint64) 2)))

-;(assert (= 36893488147419103230 (* 2 (high-border uint64))))

-;(assert (= -36893488147419103230 (* (high-border uint64) -2)))

-;(assert (= -36893488147419103230 (* -2 (high-border uint64))))

+(assert (= 36893488147419103230 (* (high-border uint64) 2)))

+(assert (= 36893488147419103230 (* 2 (high-border uint64))))

+(assert (= -36893488147419103230 (* (high-border uint64) -2)))

+(assert (= -36893488147419103230 (* -2 (high-border uint64))))

 (princ "all number boundaries tests pass\n\n")

 #t

-

--- a/test/unittest.lsp

+++ b/test/unittest.lsp

@@ -64,7 +64,7 @@

 (assert (< (- #uint32(0x80000000)) 0))

 (assert (> (- #int32(0x80000000)) 0))

 (assert (< (- #uint64(0x8000000000000000)) 0))

-(assert (> (- #int64(0x8000000000000000)) 0))

+(assert (< (- #int64(0x8000000000000000)) 0))

 ; fixnum versions

 (assert (= (- -536870912) 536870912))

 (assert (= (- -2305843009213693952) 2305843009213693952))

@@ -93,11 +93,12 @@

 (assert (> 0x10000000000000000 0x8fffffffffffffff))

 (assert (< 0x8fffffffffffffff 0x10000000000000000))

-(assert (not (bignum? (ash 2 60))))

-(assert (not (bignum? (- (ash 2 60) 1))))

+(assert (bignum? (ash 2 60)))

+(define (bignum-on-32? x) (if #.(fixnum? 0xffffffff) (not (bignum? x)) (bignum? x)))

+(assert (bignum-on-32? (- (ash 2 60) 1)))

 (assert (bignum? 1606938044258990275541962092341162602522202993782792835301376))

 (assert (bignum? 0xfffffffffffffffff))

-(assert (not (bignum? 0xfffffffffffffff)))

+(assert (bignum-on-32? 0xfffffffffffffff))

 (assert (= 4764984380238568507752444984131552966909

         (* 66405897020462343733 71755440315342536873)))

--- a/time_plan9.c

+++ b/time_plan9.c

@@ -1,4 +1,4 @@

-#include "llt.h"

+#include "flisp.h"

 #include "timefuncs.h"

 #include <tos.h>

--- a/time_posix.c

+++ b/time_posix.c

@@ -1,4 +1,4 @@

-#include "llt.h"

+#include "flisp.h"

 #include "timefuncs.h"

 double

--- a/types.c

+++ b/types.c

@@ -1,4 +1,3 @@

-#include "llt.h"

 #include "flisp.h"

 #include "cvalues.h"

 #include "equalhash.h"

@@ -40,7 +39,7 @@

 		if(isarray){

 			fltype_t *eltype = get_type(car_(cdr_(t)));

 			if(eltype->size == 0){

-				LLT_FREE(ft);

+				MEM_FREE(ft);

 				lerrorf(FL(ArgError), "invalid array element type");

 			}

 			ft->elsz = eltype->size;

--- a/utf8.c

+++ b/utf8.c

@@ -13,7 +13,7 @@

   A UTF-8 validation routine is included.

 */

-#include "llt.h"

+#include "flisp.h"

 static const uint32_t offsetsFromUTF8[6] = {

 	0x00000000UL, 0x00003080UL, 0x000E2080UL,