--- a/runtime/object.c	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/object.c	Fri Oct 07 00:10:02 2011 -0700
@@ -1,9 +1,15 @@
 #include "object.h"
 #include "builtin.h"
+#ifdef USE_GC
+#include <gc/gc.h>
+#else
 #include <stdlib.h>
+#ifndef USE_MALLOC
+#include "fixed_alloc.h"
+#endif
+#endif
 #include <string.h>
 #include <stdio.h>
-#include "fixed_alloc.h"
 
 blueprint ** registered_types = NULL;
 uint32_t max_registered_type = 0;
@@ -129,14 +135,27 @@
 
 object * alloc_object(blueprint * bp)
 {
+#ifdef USE_GC
+	return GC_malloc(bp->boxed_size);
+#else
+#ifdef USE_MALLOC
+	return malloc(bp->boxed_size);
+#else
 	return falloc(bp->boxed_size, manager);
-	//return malloc(bp->boxed_size);
+#endif
+#endif
 }
 
+#ifndef USE_GC
 void dealloc_object(blueprint * bp, object * obj)
 {
+#ifdef USE_MALLOC
+	free(obj);
+#else
 	ffree(obj, bp->boxed_size, manager);
+#endif
 }
+#endif
 
 object * new_object(uint32_t type)
 {
@@ -155,7 +174,9 @@
 	if(ret)
 	{
 		ret->bprint = bp;
+#ifndef USE_GC
 		rh_atomic_set(ret, refcount, 1);
+#endif
 		memset(((char *)ret) + sizeof(object), '\0', bp->size);
 		bp->init(ret);
 	} else {
@@ -170,13 +191,23 @@
 	multisize * ret;
 	if(type >= max_registered_type || !registered_types[type])
 		return NULL;
+#ifdef USE_GC
+	ret = GC_malloc(sizeof(multisize) + size);
+#else
+#ifdef USE_MALLOC	
+	ret = malloc(sizeof(multisize) + size);
+#else
 	ret = falloc(sizeof(multisize) + size, manager);
+#endif
+#endif
 	if(ret)
 	{
 		bp = registered_types[type];
 		ret->base.bprint = bp;
 		ret->size = size;
+#ifndef USE_GC
 		rh_atomic_set(&(ret->base), refcount, 1);
+#endif
 		memset(((char *)ret) + sizeof(multisize), '\0', size);
 		bp->init((object *)ret);
 	}
@@ -188,12 +219,22 @@
 	object * copy;
 	multisize * mcopy, *mtocopy;
 	blueprint * bp;
+#ifndef USE_GC
 	if(rh_atomic_get(tocopy, refcount) == 1)
 		return tocopy;
+#endif
 	bp = get_blueprint(tocopy);
 	if(bp->size < 0) {
 		mtocopy = (multisize *)tocopy;
+#ifdef USE_GC
+		mcopy = GC_malloc(sizeof(multisize) + mtocopy->size);
+#else
+#ifdef USE_MALLOC
+		mcopy = malloc(sizeof(multisize) + mtocopy->size);
+#else
 		mcopy = falloc(sizeof(multisize) + mtocopy->size, manager);
+#endif
+#endif
 		mcopy->size = mtocopy->size;
 		memcpy(((char *)mcopy)+sizeof(multisize), ((char *)mtocopy)+sizeof(multisize), mtocopy->size);
 		copy = (object *)mcopy;
@@ -202,7 +243,9 @@
 		memcpy(((char *)copy) + sizeof(object), ((char *)tocopy)+sizeof(object), bp->size);
 	}
 	copy->bprint = bp;
+#ifndef USE_GC
 	rh_atomic_set(copy, refcount, 1);
+#endif
 	bp->copy(copy);
 	release_ref(tocopy);
 	return copy;
@@ -217,7 +260,9 @@
 	dest = alloc_object(bp);
 	memcpy(((char *)dest) + sizeof(object), rawdata, bp->size);
 	dest->bprint = bp;
+#ifndef USE_GC
 	rh_atomic_set(dest, refcount, 1);
+#endif
 	bp->copy(dest);
 	return dest;
 }
@@ -231,11 +276,13 @@
 	bp->copy(src);
 }
 
+#ifndef USE_GC
 void release_ref(object * obj)
 {
 	if(rh_atomic_sub_testzero(obj, refcount, 1))
 		get_blueprint(obj)->free(obj);
 }
+#endif
 
 void check_type_storage(type)
 {
@@ -245,7 +292,11 @@
 		if(type_storage)
 		{
 			type_storage_temp = (type + (type_storage >> 1));
+#ifdef USE_GC
+			temp = GC_realloc(registered_types, type_storage_temp * sizeof(blueprint *));
+#else
 			temp = realloc(registered_types, type_storage_temp * sizeof(blueprint *));
+#endif
 			if(temp)
 			{
 				registered_types = temp;
@@ -254,7 +305,9 @@
 			}
 			else
 			{
+#ifndef USE_GC
 				free(registered_types);
+#endif
 				fprintf(stderr, "Couldn't allocate %d bytes for type storage array\n", type_storage_temp * sizeof(blueprint *));
 				exit(-1);
 			}
@@ -264,7 +317,12 @@
 				type_storage =INITIAL_TYPE_STORAGE;
 			else
 				type_storage = type + 8;
+#ifdef USE_GC
+			registered_types = GC_malloc(type_storage * sizeof(blueprint *));
+#else
 			registered_types = malloc(type_storage * sizeof(blueprint *));
+#endif
+
 			if(registered_types)
 				memset(registered_types, '\0', type_storage * sizeof(blueprint *));
 			else
@@ -285,7 +343,9 @@
 	blueprint * bp = get_blueprint(obj);
 	if(bp->cleanup)
 		bp->cleanup(obj);
+#ifndef USE_GC
 	ffree(obj, bp->boxed_size, manager);
+#endif
 }
 
 void multi_free(object * obj)
@@ -294,17 +354,24 @@
 	blueprint * bp = get_blueprint(obj);
 	if(bp->cleanup)
 		bp->cleanup(obj);
+#ifndef USE_GC
 	ffree(multi, sizeof(multisize) + multi->size, manager);
+#endif
 }
 
 blueprint * new_blueprint(uint32_t type, int32_t size, special_func init, special_func copy, special_func cleanup)
 {
+#ifdef USE_GC
+	blueprint * bp = GC_malloc(sizeof(blueprint));
+#else
 	blueprint * bp = malloc(sizeof(blueprint));
+
 	//dirty hack!, move elsewhere
 	if (!manager) {
 		fixed_alloc_init();
 		manager = new_mem_manager();
 	}
+#endif
 	if(bp)
 	{
 		bp->size = size;
@@ -343,6 +410,7 @@
 	return register_type_byid(max_registered_type, size, init, copy, cleanup);
 }
 
+/*
 void add_method(blueprint * bp, uint32_t methodid, rhope_func impl)
 {
 	rhope_func * temp;
@@ -489,6 +557,7 @@
 	}
 	bp->setter_lookup[setfieldid-bp->first_setfieldid] = impl;
 }
+*/
 
 blueprint * get_blueprint_byid(uint32_t type)
 {