@@ -223,16 +223,15 @@ void* iallocate(VM * vm, size_t isize, int outerlock) {
223223 STATS_ALLOC(vm->stats, size)
224224 char* ptr = vm->heap.next;
225225 vm->heap.next += size;
226−
227226 assert(vm->heap.next <= vm->heap.end);
228−
229227 memset(ptr, 0, size);
228+ ((Hdr*)ptr)->sz = isize;
229+
230230#ifdef HAS_PTHREAD
231231 if (lock) { // not message passing
232232 pthread_mutex_unlock(&vm->alloc_lock);
233233 }
234234#endif
235− ((Hdr*)ptr)->sz = size;
236235 return (void*)ptr;
237236 } else {
238237 // If we're trying to allocate something bigger than the heap,
@@ -258,22 +257,42 @@ static String * allocStr(VM * vm, size_t len, int outer) {
258257 return cl;
259258}
260259
261−VAL MKFLOAT(VM* vm, double val) {
262− Float * cl = iallocate(vm, sizeof(*cl), 0);
260+static VAL mkfloat(VM* vm, double val, int outer) {
261+ Float * cl = iallocate(vm, sizeof(*cl), outer);
263262 SETTY(cl, CT_FLOAT);
264263 cl->f = val;
265264 return (VAL)cl;
266265}
267266
268−VAL MKSTRlen(VM* vm, const char * str, size_t len) {
269− String * cl = allocStr(vm, len, 0);
267+VAL MKFLOAT(VM* vm, double val) {
268+ return mkfloat(vm, val, 0);
269+}
270+
271+VAL MKFLOATc(VM* vm, double val) {
272+ return mkfloat(vm, val, 1);
273+}
274+
275+static VAL mkstrlen(VM* vm, const char * str, size_t len, int outer) {
276+ String * cl = allocStr(vm, len, outer);
270277 memcpy(cl->str, str, len);
271− cl->__null = str == NULL;
278+ cl->_null = str == NULL;
272279 return (VAL)cl;
273280}
274281
282+VAL MKSTRlen(VM* vm, const char * str, size_t len) {
283+ return mkstrlen(vm, str, len, 0);
284+}
285+
286+VAL MKSTRclen(VM* vm, char* str, size_t len) {
287+ return mkstrlen(vm, str, len, 1);
288+}
289+
275290VAL MKSTR(VM* vm, const char* str) {
276− return MKSTRlen(vm, str, str? strlen(str) : 0);
291+ return mkstrlen(vm, str, str? strlen(str) : 0, 0);
292+}
293+
294+VAL MKSTRc(VM* vm, char* str) {
295+ return mkstrlen(vm, str, strlen(str), 1);
277296}
278297
279298static char * getstroff(StrOffset * stroff) {
@@ -295,65 +314,50 @@ size_t GETSTROFFLEN(VAL stroff) {
295314 return getstrofflen((StrOffset*)stroff);
296315}
297316
298−VAL MKCDATA(VM* vm, CHeapItem * item) {
317+static VAL mkcdata(VM * vm, CHeapItem * item, int outer) {
299318 c_heap_insert_if_needed(vm, &vm->c_heap, item);
300− CDataC * cl = iallocate(vm, sizeof(*cl), 0);
319+ CDataC * cl = iallocate(vm, sizeof(*cl), outer);
301320 SETTY(cl, CT_CDATA);
302321 cl->item = item;
303322 return (VAL)cl;
304323}
305324
325+VAL MKCDATA(VM* vm, CHeapItem * item) {
326+ return mkcdata(vm, item, 0);
327+}
328+
306329VAL MKCDATAc(VM* vm, CHeapItem * item) {
307− c_heap_insert_if_needed(vm, &vm->c_heap, item);
308− CDataC * cl = iallocate(vm, sizeof(*cl), 1);
309− SETTY(cl, CT_CDATA);
310− cl->item = item;
311− return (VAL)cl;
330+ return mkcdata(vm, item, 1);
312331}
313332
314−VAL MKPTR(VM* vm, void* ptr) {
315− Ptr * cl = iallocate(vm, sizeof(*cl), 0);
333+static VAL mkptr(VM* vm, void* ptr, int outer) {
334+ Ptr * cl = iallocate(vm, sizeof(*cl), outer);
316335 SETTY(cl, CT_PTR);
317336 cl->ptr = ptr;
318337 return (VAL)cl;
319338}
320339
321−VAL MKMPTR(VM* vm, void* ptr, size_t size) {
322− ManagedPtr * cl = iallocate(vm, sizeof(*cl) + size, 0);
323− SETTY(cl, CT_MANAGEDPTR);
324− memcpy(cl->mptr, ptr, size);
325− return (VAL)cl;
340+VAL MKPTR(VM* vm, void* ptr) {
341+ return mkptr(vm, ptr, 0);
326342}
327343
328−VAL MKFLOATc(VM* vm, double val) {
329− Float * cl = iallocate(vm, sizeof(*cl), 1);
330− SETTY(cl, CT_FLOAT);
331− cl->f = val;
332− return (VAL)cl;
344+VAL MKPTRc(VM* vm, void* ptr) {
345+ return mkptr(vm, ptr, 1);
333346}
334347
335−VAL MKSTRclen(VM* vm, char* str, size_t len) {
336− String * cl = allocStr(vm, len, 1);
337− memcpy(cl->str, str, len);
348+VAL mkmptr(VM* vm, void* ptr, size_t size, int outer) {
349+ ManagedPtr * cl = iallocate(vm, sizeof(*cl) + size, outer);
350+ SETTY(cl, CT_MANAGEDPTR);
351+ memcpy(cl->mptr, ptr, size);
338352 return (VAL)cl;
339353}
340354
341−VAL MKSTRc(VM* vm, char* str) {
342− return MKSTRclen(vm, str, strlen(str));
343−}
344−
345−VAL MKPTRc(VM* vm, void* ptr) {
346− Ptr * cl = iallocate(vm, sizeof(*cl), 1);
347− SETTY(cl, CT_PTR);
348− cl->ptr = ptr;
349− return (VAL)cl;
355+VAL MKMPTR(VM* vm, void* ptr, size_t size) {
356+ return mkmptr(vm, ptr, size, 0);
350357}
351358
352359VAL MKMPTRc(VM* vm, void* ptr, size_t size) {
353− ManagedPtr * cl = iallocate(vm, sizeof(*cl) + size, 1);
354− SETTY(cl, CT_MANAGEDPTR);
355− memcpy(cl->mptr, ptr, size);
356− return (VAL)cl;
360+ return mkmptr(vm, ptr, size, 1);
357361}
358362
359363VAL MKB8(VM* vm, uint8_t bits8) {
@@ -1105,25 +1109,16 @@ char* idris_showerror(int err) {
11051109 return strerror(err);
11061110}
11071111
1108−VAL* nullary_cons;
1112+Con nullary_cons[256];
11091113
11101114void init_nullaries(void) {
11111115 int i;
1112− nullary_cons = malloc(256 * sizeof(VAL));
11131116 for(i = 0; i < 256; ++i) {
1114− Con * cl = calloc(1, sizeof(*cl));
1117+ Con * cl = nullary_cons + i;
1118+ cl->hdr.sz = sizeof(*cl);
11151119 SETTY(cl, CT_CON);
11161120 cl->tag = i;
1117− nullary_cons[i] = (VAL)cl;
1118− }
1119−}
1120−
1121−void free_nullaries(void) {
1122− int i;
1123− for(i = 0; i < 256; ++i) {
1124− free(nullary_cons[i]);
11251121 }
1126− free(nullary_cons);
11271122}
11281123
11291124int __idris_argc;