Mercurial > repos > rhope

changeset 186:ba35ab624ec2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add support for raw C function output from C backend as well as an option to use Boehm-GC instead of reference counting
author Mike Pavone <pavone@retrodev.com>
date Fri, 07 Oct 2011 00:10:02 -0700
parents 4580c08fd4e8
children 5e752cf2d6b1
files cbackend.rhope runtime/blueprint.h runtime/builtin.c runtime/builtinworkers.c runtime/context.c runtime/context.h runtime/func.h runtime/func_raw.h runtime/localpointers_fragment.c runtime/main_end.c runtime/main_mid.c runtime/main_start.c runtime/object.c runtime/object.h runtime/rhopefuncs_epilog.c runtime/rhopefuncs_prolog.c runtime/transaction.c runtime/transaction.h
diffstat 18 files changed, 611 insertions(+), 170 deletions(-) [+]
line wrap: on
line diff
--- a/cbackend.rhope	Wed Jul 27 21:32:40 2011 -0700
+++ b/cbackend.rhope	Fri Oct 07 00:10:02 2011 -0700
@@ -600,6 +600,7 @@
 
 
 
+
 Do AddRef@C Function[func,psource,pdest:out]
 {
     source <- [psource]Make Op[func] 
@@ -698,13 +699,13 @@
 {
 	
 	estore <- Escape Rhope Name[store,[func]Escape Pattern >>]
-	out <- [[[[[ [["((mutt_"]Append[estore]]Append["*)lv_"]]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->gs_"]]Append[estore]]Append["->local_data)->gs_"]]Append[Escape Rhope Name[var,[func]Escape Pattern >>]]
+	out <- [[[[[ [["((mutt_"]Append[estore]]Append["*)lv("]]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[", gs_"]]Append[estore]]Append[")->local_data)->gs_"]]Append[Escape Rhope Name[var,[func]Escape Pattern >>]]
 }
 
 Set Global@C Function[func,store,var,src:out]
 {
 	estore <- Escape Rhope Name[store,[func]Escape Pattern >>]
-	cell pointer <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->gs_"]]Append[estore]
+	cell pointer <- [[[["lv("]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[", gs_"]]Append[estore]]Append[")"]
 	out <- [[[[func]Add Statement[[["tmp = copy_object("]Append[[cell pointer]Append["->local_data"]]]Append[")"]]
 		]Add Statement[ [[[["((mutt_"]Append[estore]]Append[" *)tmp)->gs_"]]Append[Escape Rhope Name[var, [func]Escape Pattern >>]]]Append[[" = "]Append[[src]Make Op[func]]] ]
 		]Add Statement[[cell pointer]Append["->local_data = tmp"]]
@@ -951,9 +952,9 @@
 	{
 		[[func]Inputs >>]Find[=[op,?]]
 		{
-			out <- [["my_cdata->params["]Append[String[~]]]Append["	]"]
+			out <- [["my_params("]Append[String[~]]]Append[")"]
 		}{
-			out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->"]]Append[Escape Rhope Name[op,[func]Escape Pattern >>]]
+			out <- [[[["lv("]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[", "]]Append[Escape Rhope Name[op,[func]Escape Pattern >>]]]Append[")"]
 		}
 	}{
 		out <- Escape Rhope Name[op,[func]Escape Pattern >>]
@@ -964,7 +965,7 @@
 {
 	If[[[func]Convention >>] = ["rhope"]]
 	{
-		out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->"]]Append[Escape Rhope Name[name,[func]Escape Pattern >>]]
+		out <- [[[["lv("]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[", "]]Append[Escape Rhope Name[name,[func]Escape Pattern >>]]]Append[")"]
 	}{
 		out <- Escape Rhope Name[name,[func]Escape Pattern >>]
 	} 
@@ -1002,21 +1003,21 @@
 Discard Outputs@C Function[func,first to discard:out]
 {
 	out <- [[[[[func
-		]Add Raw Line[[["for(idx = "]Append[String[first to discard]]]Append["; idx < cdata->num_params; ++idx)"]]
+		]Add Raw Line[[["for(idx = "]Append[String[first to discard]]]Append["; idx < numresults; ++idx)"]]
 		]Add Raw Line["{"]
-		]Add Raw Line["	if (cdata->params[idx])"]
-		]Add Raw Line["		release_ref(cdata->params[idx]);"]
+		]Add Raw Line["	if (result(idx))"]
+		]Add Raw Line["		release_ref(result(idx));"]
 		]Add Raw Line["}"]
 }
 
 Result Reference@C Function[func,output:out]
 {
-	out <- [["cdata->params["]Append[String[output]]]Append["]"]
+	out <- [["result("]Append[String[output]]]Append[")"]
 }
 
 Checked Result Reference@C Function[func,output:out]
 {
-	out <- [[[["("]Append[String[output]]]Append[" < cdata->num_params ? cdata->params["]]Append[String[output]]]Append["] : NULL)"]
+	out <- [[[["("]Append[String[output]]]Append[" < numresults ? result("]]Append[String[output]]]Append[") : NULL)"]
 }
 
 
@@ -1036,7 +1037,7 @@
 
 _Set Outputs C[string,inputname,inputnum,func:out]
 {
-	out <- [string]Append[[[ [ ["\tRet("]Append[String[inputnum]] ]Append[ [[", lv_"]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->"]]]Append[Escape Rhope Name[inputname,[func]Escape Pattern >>]]]Append[")\n"]]
+	out <- [string]Append[[[ [ ["\tRet("]Append[String[inputnum]] ]Append[ [[", lv("]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[", "]]]Append[Escape Rhope Name[inputname,[func]Escape Pattern >>]]]Append["))\n"]]
 }
 
 Set Outputs@C Function[func:out]
@@ -1055,15 +1056,15 @@
 }
 _Output Defs C[string,varname,index,func:out]
 {
-	out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[[[func]Output Types >>]Index[index],[func]Escape Pattern >>]] ]]Append[[" "]Append[Escape Rhope Name[varname,[func]Escape Pattern >>]]]]Append[";\n"]
+	out <- [[[string]Append[ [" lvar("]Append[Rhope Type to C[[[func]Output Types >>]Index[index],[func]Escape Pattern >>]] ]]Append[[", "]Append[Escape Rhope Name[varname,[func]Escape Pattern >>]]]]Append[")"]
 }
 _Var Defs C[string,type,varname,p:out]
 {
-	out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[type,p]] ]]Append[[" "]Append[Escape Rhope Name[varname,p]]]]Append[";\n"]
+	out <- [[[string]Append[ [" lvar("]Append[Rhope Type to C[type,p]] ]]Append[[", "]Append[Escape Rhope Name[varname,p]]]]Append[")"]
 }
 _Global Cell Defs C[func,p,string,store:out]
 {
-	out <- [string]Append[ [["\ttrans_cell *gs_"]Append[Escape Rhope Name[store,p]]]Append[";\n"] ]
+	out <- [string]Append[ [[" lvar(trans_cell *, gs_"]Append[Escape Rhope Name[store,p]]]Append[")"] ]
 }
 
 
@@ -1073,7 +1074,22 @@
 	{
 	If[ [[[func]Convention >>] = ["rhope"]] And [[ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] > [0]] ]
 	{
-		localtype <- [[[Fold[_Global Cell Defs C[func,[func]Escape Pattern >>,?], Fold[_Output Defs C[?, ?, ?, func], Fold[_Var Defs C[?,?,?,[func]Escape Pattern >>],"typedef struct {\n", [func]Variables >>], [func]Outputs >>], [func]Uses >>]]Append["} lt_"]]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[";\n"]
+		ename <- Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]
+		localtype <- [
+			[
+				[
+					Fold[
+						_Global Cell Defs C[func,[func]Escape Pattern >>,?], 
+						Fold[
+							_Output Defs C[?, ?, ?, func], 
+							Fold[
+								_Var Defs C[?,?,?,[func]Escape Pattern >>],
+								["#define ldec_"]Append[ename],
+								[func]Variables >>], 
+							[func]Outputs >>], 
+						[func]Uses >>]
+				]Append["\nLocalsType(ldec_"]]Append[ename]
+		]Append[ [[", "]Append[ename]]Append[")\n"] ]
 	}{
 		localtype <- ""
 	}
@@ -1147,7 +1163,7 @@
 Find Trans Cell@C Function[func,text,store:out]
 {
 	estore <- Escape Rhope Name[store,[func]Escape Pattern >>]
-	out <- [text]Append[  [[[["lv_"]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append["->gs_"]]Append[estore]]Append[[[" = find_obj_cell(ct->transaction, gs_"]Append[estore]]Append[");\n"]] ]
+	out <- [text]Append[  [[[["lv("]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[", gs_"]]Append[estore]]Append[[[") = find_obj_cell(cur_transaction, gs_"]Append[estore]]Append[");\n"]] ]
 }
 
 Text@C Function[func:out]
@@ -1177,10 +1193,12 @@
 		}
 		If[ [ [[[[func]Variables >>]Length]+[[[func]Outputs >>]Length]]+[[[func]Uses >>]Length] ] = [0] ]
 		{
-			out <- [[[[[[[[[ [type]Append["NoLocals("]
+			out <- [[[[[[[[[[[ [type]Append["NoLocals("]
 				]Append[cname]
 				]Append[",\n\tNumParams "]
 				]Append[ String[[[func]Inputs >>]Length] ]
+				]Append[",\n\tNumOutputs "]
+				]Append[ String[[[func]Outputs >>]Length] ]
 				]Append[")\n\n"]
 				]Append[param check]
 				]Append[ [[func]Statements >>]Join[""] ]
@@ -1193,18 +1211,20 @@
 				begin trans <- [[[["\tbegin_transaction(ct, "]Append[ String[[[func]Uses >>]Length] ]]Append[", "]]Append[ [Map[Map[[func]Uses >>, Escape Rhope Name[?, [func]Escape Pattern >>]], ["gs_"]Append[?]]]Join[", "] ]]Append[");\n"]
 				init trans <- [[Fold[Find Trans Cell[func,?], begin trans, [func]Uses >>]
 					]Append[[["transretry_"]Append[fname]]Append[":\n"]]
-					]Append["\tfor(idx = 0; idx < cdata->num_params; ++idx) { add_ref(cdata->params[idx]); }\n"]
+					]Append[ [["\tfor(idx = 0; idx < "]Append[String[[[func]Inputs >>]Length]]]Append["; ++idx) { add_ref(my_params(idx)); }\n"] ]
 				//TODO: Figure out whether this is a readonly or write transaction
 				commit trans <- [[["\tif(!commit_transaction(ct, 0)) { prep_retry(ct); goto transretry_"]Append[fname]]Append["; }\n"]
-					]Append["\tfor(idx = 0; idx < cdata->num_params; ++idx) { release_ref(cdata->params[idx]); }\n"]
+					]Append[ [["\tfor(idx = 0; idx < "]Append[String[[[func]Inputs >>]Length]]]Append["; ++idx) { release_ref(my_params(idx)); }\n"] ]
 			}{
 				init trans <- ""
 				commit trans <- ""
 			}
-			out <- [[[[[[[[[[[[ [type]Append["("]
+			out <- [[[[[[[[[[[[[[ [type]Append["("]
 				]Append[cname]
 				]Append[",\n\tNumParams "]
 				]Append[ String[[[func]Inputs >>]Length] ]
+				]Append[",\n\tNumOutputs "]
+				]Append[ String[[[func]Outputs >>]Length] ]
 				]Append[")\n\n"]
 				]Append[param check]
 				]Append[init trans]
@@ -1519,11 +1539,11 @@
 _Dispatch Enum Sub[text, num, name:out]
 {
 	out <- [[[[[text
-		]Append["\tRES_"]
+		]Append["\tResEnum("]
 		]Append[String[num]]
-		]Append["_"]
+		]Append[", "]
 		]Append[name]
-		]Append[",\n"]
+		]Append[")\n"]
 }
 
 _Dispatch Enum[text,func,raw name:out]
@@ -1547,7 +1567,7 @@
 {
 	out <- [[[[["typedef enum {\n"
 		]Append[Fold[_Dispatch Enum[?], 
-			[Fold[_Dispatch Enum Methods[[program]Escape Pattern >>,?], "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n\tFUNC_ID,\n\tFUNC_BlueprintSP_FromSP_ID,\n\tFUNC_Pause,\n\tRES_1_Pause,\n\tFUNC_Resume,\n\tFUNC_RunSP_Bytecode,\n\tRES_1_RunSP_Bytecode,\n"], 
+			[Fold[_Dispatch Enum Methods[[program]Escape Pattern >>,?], "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n\tFUNC_ID,\n\tFUNC_BlueprintSP_FromSP_ID,\n\tFUNC_Pause,\n\tResEnum(1, Pause)\n\tFUNC_Resume,\n\tFUNC_RunSP_Bytecode,\n\tResEnum(1, RunSP_Bytecode)\n"], 
 			[program]Functions >>]]
 		]Append["\tEND,\n\tEND_THREAD\n} funcids;\n\n"]
 		]Append["#define DispatchEntries \\\n"] 
@@ -1575,7 +1595,13 @@
 	{
 		out <- text
 	}{
-		out <- [text]Append[[["\tFuncDef("]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[")\n"]]
+		If[[[func]Name >>]Contains["@"]]
+		{
+			deftype <- "\tMethodDef("
+		}{
+			deftype <- "\tFuncDef("
+		}
+		out <- [text]Append[[[deftype]Append[Escape Rhope Name[[func]Name >>,[func]Escape Pattern >>]]]Append[")\n"]]
 	}
 }
 
@@ -1673,14 +1699,7 @@
 #include \"array.c\"
 #include \"worker.c\"
 
-int main(int argc, char **argv)
-{
-	blueprint * bp;
-	int numret;
-	int idx;
-	object * inout[3];
-	register_builtin_types();
-	register_type_byid(TYPE_MUTABLEGLOBAL, sizeof(mutable_object)-sizeof(object), NULL, NULL, NULL);\n\n"]
+#include \"main_start.c\" \n\n"]
 		]Append[ [[program]Type Registry >>]Type Inits[[program]Method Registry >>, [program]Field Registry >>] ]
 		]Append[Fold[_Global Type Inits C[?, ?, p], "", [program]Global Stores >>]]
 		]Append[Fold[_Set Consts C Program[?, ?, ?, [program]Type Registry >>], "", constants]]
@@ -1688,40 +1707,16 @@
 		]Append[Fold[_Global Store Inits C[?, ?, [program]Type Registry >>], "", [program]Global Stores >>]]
 		]Append[Fold[Init Type Names[?, ?, ?, [program]Type Registry >>], "", [[program]Type Registry >>]Lookup >>]]
 		]Append["
-	rhope(FUNC_List, inout, 0, 1);
-	for (idx = 0; idx < argc; ++idx)
-	{
-		inout[1] = make_String(argv[idx]);
-		rhope(FUNC_Append, inout, 2, 2);
-	}
-	numret = rhope(FUNC_Main, inout, 1, 1);
-#ifdef ENABLE_LEAK_DETECTION\n"]
+#include \"main_mid.c\"
+
+#ifdef ENABLE_LEAK_DETECTION\n\n"]
 		]Append[Fold[_Consts C Release[?, ?, ?, p], "", constants]]
 		]Append[
 	"
 	print_mem_info(manager);
 	print_live_object_types(manager);
 #endif //ENABLE_LEAK_DETECTION
-	
-#ifdef ENABLE_PROFILING
-	for (idx = 0; idx < END; ++idx)
-	{
-		if(profile_counts[idx])
-			printf(\"Func: %d\tCount: %llu\tTime: %llu\tAvg: %f\tSelf: %llu\tAvg: %f\tNested Count: %llu\\n\", idx, profile_counts[idx], profile_totals[idx], ((double)profile_totals[idx])/((double)profile_counts[idx]), profile_selftotals[idx], ((double)profile_selftotals[idx])/((double)profile_counts[idx]), profile_nestedcounts[idx]);
-	}
-#endif
-	if (!numret)
-		return 0;
-	if (numret < 0)
-		return numret;
-	if (get_blueprint(inout[0])->type_id == TYPE_INT32)
-		return ((t_Int32 *)inout[0])->Num;
-
-	rhope(FUNC_If, inout, 1, 2);
-	if (inout[0])
-		return 0;
-	return 1;
-}\n\n"]
+#include \"main_end.c\"\n\n"]
 
 }
 
--- a/runtime/blueprint.h	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/blueprint.h	Fri Oct 07 00:10:02 2011 -0700
@@ -11,20 +11,17 @@
 int32_t _internal_blueprint_eq(object * left, object * right);
 int32_t _internal_blueprint_rawsize(object * bp);
 
-typedef struct {
-	blueprint * bp;
-} lt_Build;
+#define ldec_Build lvar(blueprint *, bp)
+LocalsType(ldec_Build, Build)
 
-typedef struct {
-	blueprint * bp;
-} lt_BlueprintSP_Of;
 
-typedef struct {
-	object * id;
-} lt_ID;
+#define ldec_BlueprintSP_Of lvar(blueprint *, bp)
+LocalsType(ldec_BlueprintSP_Of ,BlueprintSP_Of)
 
-typedef struct {
-	uint32_t type;
-} lt_BlueprintSP_FromSP_ID;
+#define ldec_ID lvar(object *, id)
+LocalsType(ldec_ID, ID)
+
+#define ldec_BlueprintSP_FromSP_ID lvar(uint32_t, type)
+LocalsType(ldec_BlueprintSP_FromSP_ID, BlueprintSP_FromSP_ID)
 
 #endif //BLUEPRINT_H_
--- a/runtime/builtin.c	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/builtin.c	Fri Oct 07 00:10:02 2011 -0700
@@ -104,15 +104,22 @@
 
 object * make_String(char * text)
 {
+#ifdef RAW_FUNC
+	returntype ret;
+#endif
 	object * params[1];
 	t_Array * arr = (t_Array *)_internal_array_allocnaked(strlen(text), make_Blueprint(TYPE_UINT8));
 	arr->payload.Length = arr->payload.Storage;
 	memcpy(((char *)arr) + sizeof(t_Array), text, arr->payload.Length);
 	
 	params[0] = (object *)arr;
+#ifdef RAW_FUNC
+	ret = f_String(1, params);
+	return ret.retvals[0];
+#else
 	rhope(FUNC_String, params, 1, 1);
-	
 	return params[0];
+#endif
 }
 
 object * make_Bool(int32_t val)
@@ -139,18 +146,32 @@
 
 object * make_List(int32_t numels,...)
 {
+#ifdef RAW_FUNC
+	returntype ret;
+#endif
 	int32_t idx, elidx;
 	object * inout[3];
 	va_list args;
 
 	va_start(args, numels);
+#ifdef RAW_FUNC
+	ret = f_List(1, inout);
+	inout[0] = ret.retvals[0];
+#else
 	rhope(FUNC_List, inout, 0, 1);
+#endif
 	
 	for (idx = 0; idx < numels; ++idx)
 	{
 		elidx = va_arg(args, int32_t);
 		inout[1] = make_Int32(elidx);
 		inout[2] = va_arg(args, object *);
+#ifdef RAW_FUNC
+		ret = f_Append(3, inout);
+		inout[0] = ret.retvals[0];
+#else
+		rhope(FUNC_Append, inout, 3, 3);
+#endif
 	}
 	return inout[0];
 }
--- a/runtime/builtinworkers.c	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/builtinworkers.c	Fri Oct 07 00:10:02 2011 -0700
@@ -1,56 +1,59 @@
 Func(Build,
-	NumParams 1)
+	NumParams 1,
+	NumOutputs 1)
 	
 	Param(0, TYPE_BLUEPRINT)
 	
-	lv_Build->bp = ((t_Blueprint *)(cdata->params[0]))->bp;
-	release_ref(cdata->params[0]);
+	lv(Build, bp) = ((t_Blueprint *)(my_params(0)))->bp;
+	release_ref(my_params(0));
 	
-	Ret(0, new_object_bp(lv_Build->bp))
+	Ret(0, new_object_bp(lv(Build, bp)))
 EndFunc(Build)
 DISPATCH
 
 Func(BlueprintSP_Of,
-	NumParams 1)
+	NumParams 1,
+	NumOutputs 1)
 	
-	lv_BlueprintSP_Of->bp = get_blueprint(cdata->params[0]);
-	release_ref(cdata->params[0]);
+	lv(BlueprintSP_Of, bp) = get_blueprint(my_params(0));
+	release_ref(my_params(0));
 	
 	Ret(0, new_object(TYPE_BLUEPRINT))
-	((t_Blueprint *)cdata->params[0])->bp = lv_BlueprintSP_Of->bp;
+	((t_Blueprint *)my_outputs(0))->bp = lv(BlueprintSP_Of, bp);
 EndFunc(BlueprintSP_Of)
 DISPATCH
 
-Func(ID, NumParams 1)
+Func(ID, NumParams 1, NumOutputs 1)
 
 	Param(0, TYPE_BLUEPRINT)
 
-	lv_ID->id = new_object(TYPE_UINT32);
-	((t_UInt32 *)lv_ID->id)->Num = ((t_Blueprint *)cdata->params[0])->bp->type_id;
-	release_ref(cdata->params[0]);
-	Ret(0, lv_ID->id)
+	lv(ID, id) = new_object(TYPE_UINT32);
+	((t_UInt32 *)lv(ID, id))->Num = ((t_Blueprint *)my_params(0))->bp->type_id;
+	release_ref(my_params(0));
+	Ret(0, lv(ID, id))
 EndFunc(ID)
 DISPATCH
 
-Func(BlueprintSP_FromSP_ID, NumParams 1)
+Func(BlueprintSP_FromSP_ID, NumParams 1, NumOutputs 2)
 
 	Param(0, TYPE_UINT32)
 
-	lv_BlueprintSP_FromSP_ID->type = ((t_UInt32 *)cdata->params[0])->Num;
-	if (lv_BlueprintSP_FromSP_ID->type >= max_registered_type || !registered_types[lv_BlueprintSP_FromSP_ID->type]) {
-		Ret(1, cdata->params[0])
+	lv(BlueprintSP_FromSP_ID, type) = ((t_UInt32 *)my_params(0))->Num;
+	if (lv(BlueprintSP_FromSP_ID, type) >= max_registered_type || !registered_types[lv(BlueprintSP_FromSP_ID, type)]) {
+		Ret(1, my_params(0))
 		Ret(0, NULL)
 	} else {
-		release_ref(cdata->params[0]);	
+		release_ref(my_params(0));	
 		Ret(0, new_object(TYPE_BLUEPRINT))
-		((t_Blueprint *)cdata->params[0])->bp = registered_types[lv_BlueprintSP_FromSP_ID->type];
+		((t_Blueprint *)my_outputs(0))->bp = registered_types[lv(BlueprintSP_FromSP_ID, type)];
 		Ret(1, NULL)
 	}
 	
 EndFunc(BlueprintSP_FromSP_ID)
 DISPATCH
 
-FuncNoLocals(Pause, NumParams 1)
+#ifndef RAW_FUNC
+FuncNoLocals(Pause, NumParams 1, NumOutputs 1)
 	Param(0, TYPE_WORKER)
 
 	ct->resume_cdata = my_cdata;
@@ -74,7 +77,7 @@
 EndFuncNoLocals
 DISPATCH
 
-FuncNoLocals(Resume, NumParams 2)
+FuncNoLocals(Resume, NumParams 2, NumOutputs 2)
 	Param(0, TYPE_CONTEXT)
 
 	temp_ct = ((t_Context *)my_cdata->params[0])->ct;
@@ -216,4 +219,18 @@
 	}
 EndFunc(RunSP_Bytecode)
 DISPATCH
+#else
+FuncNoLocals(Pause, NumParams 1, NumOutputs 0)
+	exit(2);
+EndFuncNoLocals
 
+FuncNoLocals(Resume, NumParams 2, NumOutputs 0)
+	exit(2);
+EndFuncNoLocals
+
+FuncNoLocals(RunSP_Bytecode, NumParams 2, NumOutputs 0)
+	exit(2);
+EndFuncNoLocals
+#endif //RAW_FUNC
+
+
--- a/runtime/context.c	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/context.c	Fri Oct 07 00:10:02 2011 -0700
@@ -5,6 +5,8 @@
 #include <stddef.h>
 #include <stdio.h>
 
+#ifndef RAW_FUNC
+
 context * contextqueue[32];
 int32_t cq_readloc=0;
 int32_t cq_writeloc=0;
@@ -126,4 +128,5 @@
 	if(ct->current_stack->free_space == ct->current_stack->data && ct->current_stack->prev)
 		ct->current_stack = ct->current_stack->prev;
 }
+#endif
 
--- a/runtime/context.h	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/context.h	Fri Oct 07 00:10:02 2011 -0700
@@ -8,6 +8,11 @@
 
 #define STACK_CHUNK_SIZE 4096-(sizeof(struct stackchunk *)*2+sizeof(char *))
 
+#ifdef RAW_FUNC
+//hack
+typedef int context;
+#else
+
 typedef struct stackchunk {
 	struct    stackchunk * next;
 	struct    stackchunk * prev;
@@ -23,8 +28,10 @@
 	calldata       *resume_cdata;
 	int32_t        resumeable;
 } context;
+#endif
 
 Box(context *,ct,Context);
+#ifndef RAW_FUNC
 stackchunk * new_stack();
 context * new_context();
 void * alloc_stack(context * ct, uint32_t size);
@@ -34,5 +41,6 @@
 void cqueue_init();
 context * get_cqueue();
 int32_t put_cqueue(context * ct);
+#endif
 object * make_Context(context * ct);
 #endif //_CONTEXT_H_
--- a/runtime/func.h	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/func.h	Fri Oct 07 00:10:02 2011 -0700
@@ -1,8 +1,18 @@
 #ifndef _FUNC_H_
 #define _FUNC_H_
 
+#define MethodName(name,type) f_ ## name ## AT_ ## type
+#define NumParams
+#define NumOutputs
+#define CallSpace
+
 typedef struct object object;
-typedef struct calldata calldata;
+typedef void (*special_func) (object *);
+
+
+#ifdef RAW_FUNC
+#include "func_raw.h"
+#else
 
 typedef enum {
 	NORMAL_RETURN=0,
@@ -12,9 +22,22 @@
 	STACK_UNWIND
 } returntype;
 
+typedef struct calldata calldata;
 
 typedef returntype (*rhope_func)(calldata *);
-typedef void (*special_func) (object *);
+
+#define lv(func,var) lv_ ## func->var
+#define lvar(type, name) type name;
+#define my_params(num) my_cdata->params[num]
+#define child_params(num) cdata->params[num]
+#define my_outputs(num) my_cdata->params[num]
+
+#define result(num) cdata->params[num]
+#define numresults cdata->num_params
+
+#define LocalsType(def,func) typedef struct { def } lt_ ## func;
+
+#define ResEnum(num,name) RES_ ## num ## _ ## name,
 
 #ifdef MULTI_SWITCH
 #define DispatchEntry(name) case FUNC_##name: goto f_##name;
@@ -32,9 +55,6 @@
 #define EndThreadEntry &&DO_END_THREAD
 #endif
 
-
-#define MethodName(name,type) f_ ## name ## AT_ ## type
-
 #ifdef ENABLE_PROFILING
 
 #define START_PROFILE \
@@ -72,7 +92,7 @@
 		}\
 		profile_selftotals[FUNC_ ## name] +=  ((uint64_t)proftime.tv_sec) * 1000000ULL + ((uint64_t)proftime.tv_usec) - cdata->self_start + cdata->self_accum;
 		
-#define Func(name,numparams) \
+#define Func(name,numparams,numret) \
 f_ ## name:\
 		for(idx = numparams; idx < cdata->num_params; ++idx)\
 			release_ref(cdata->params[idx]); cdata->num_params = numparams;\
@@ -83,7 +103,7 @@
 		lv_ ## name = alloc_stack(ct, sizeof(lt_ ## name));\
 		my_cdata = cdata;
 
-#define MethodImpl(name,type_name,mytype_id,numparams) \
+#define MethodImpl(name,type_name,mytype_id,numparams,numret) \
 f_ ## name ## AT_ ## type_name:\
 sf_ ## name ## AT_ ## type_name:\
 		if (cdata->num_params < 1)\
@@ -118,7 +138,7 @@
 		free_stack(ct, lv_ ## name);\
 		func = cdata->func;
 		
-#define Func(name,numparams) \
+#define Func(name,numparams,numret) \
 f_ ## name:\
 		for(idx = numparams; idx < cdata->num_params; ++idx)\
 			release_ref(cdata->params[idx]); cdata->num_params = numparams;\
@@ -126,7 +146,7 @@
 		lv_ ## name = alloc_stack(ct, sizeof(lt_ ## name));\
 		my_cdata = cdata;
 
-#define MethodImpl(name,type_name,mytype_id,numparams) \
+#define MethodImpl(name,type_name,mytype_id,numparams,numret) \
 f_ ## name ## AT_ ## type_name:\
 sf_ ## name ## AT_ ## type_name:\
 		if (cdata->num_params < 1)\
@@ -152,7 +172,7 @@
 		func = cdata->func;
 
 
-#define FuncNoLocals(name,numparams) \
+#define FuncNoLocals(name,numparams,numret) \
 f_ ## name:\
 		for(idx = numparams; idx < cdata->num_params; ++idx)\
 			release_ref(cdata->params[idx]); cdata->num_params = numparams;\
@@ -199,9 +219,6 @@
 		case type_id:\
 			goto m_ ## name ## AT_ ## type_name;
 			
-#define NumParams
-#define CallSpace
-
 #define Param(num,convtypeid) \
 	if(get_blueprint(cdata->params[num])->type_id != convtypeid)\
 	{\
@@ -219,7 +236,7 @@
 	}
 #define Exception
 #define FuncDef(name) lt_ ## name * lv_ ## name;
-#define MethodDef(name) lt_ ## name ## AT_ ## type_name * lv_ ## name ## AT_ ## type_name;
+#define MethodDef(name) lt_ ## name * lv_ ## name;
 
 
 #define PrepCall(callspace) cdata = alloc_cdata(ct, cdata, callspace);
@@ -352,5 +369,6 @@
 			cdata->num_params = numparams;\
 			goto sf_ ## tocall;
 	
-	
+#endif //RAW_FUNC
 #endif //_FUNC_H_
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/runtime/func_raw.h	Fri Oct 07 00:10:02 2011 -0700
@@ -0,0 +1,181 @@
+ 
+typedef struct {
+	int num_ret;
+	object ** retvals;
+} returntype;
+
+typedef returntype (*rhope_func)(int, object **);
+
+#define DispatchEntry(name) f_ ## name,
+#define ResumeEntry(num,name)
+#define ResEnum(num,name)
+#define DispatchVar rhope_func func_lookup[] = { DispatchEntries };
+#define EndEntry
+#define EndThreadEntry
+#define DISPATCH
+
+#define lv(func,var) lv_ ## var
+#define lvar(type, name) type lv_ ## name;
+#define my_params(num) params[num]
+#define child_params(num) call_params[num]
+#define my_outputs(num) retvals[num]
+
+#define result(num) callret.retvals[num]
+#define numresults callret.num_ret
+
+#define LocalsType(def,func)
+
+#define Func(name, numparams, numret) \
+returntype f_ ## name(int num_params, object ** params) {\
+		ldec_ ## name;\
+		static object * retvals[numret];\
+		object * call_params[32];\
+		int idx, vcparam_offset, last_vcparam;\
+		returntype callret,retinfo = {numret, &retvals};\
+		for(idx = numparams; idx < num_params; ++idx)\
+			release_ref(params[idx]); num_params = numparams;
+			
+#define FuncNoLocals(name, numparams, numret) \
+returntype f_ ## name(int num_params, object ** params) {\
+		object * call_params[32];\
+		static object * retvals[numret];\
+		int idx, vcparam_offset, last_vcparam;\
+		returntype callret,retinfo = {numret, &retvals};\
+		for(idx = numparams; idx < num_params; ++idx)\
+			release_ref(params[idx]); num_params = numparams;
+			
+#define Param(num,convtypeid) \
+	if(get_blueprint(params[num])->type_id != convtypeid)\
+	{\
+		printf("uh oh, need conversion from type %d to type %d for param %d and that's not implemented yet!", get_blueprint(params[num])->type_id, convtypeid, num);\
+		exit(1);\
+	}
+
+#define CopiedParam(num,convtypeid) Param(num,convtypeid) params[num] = copy_object(params[num]);
+
+#define Ret(num,val) retvals[num] = (object *)(val);
+#define NumRet(num)
+
+#define EndFunc(name) return retinfo;}
+#define EndFuncNoLocals return retinfo;}
+
+#define MethodImpl(name,type_name,mytype_id,numparams,numret) \
+returntype f_ ## name ## AT_ ## type_name(int num_params, object ** params) {\
+		if (num_params < 1)\
+		{\
+			printf("Direct call to %s@%s had no arguments!", #name, #type_name);\
+			printf("%d\n", *((char *)0));\
+			exit(1);\
+		}\
+		if(get_blueprint(params[0])->type_id != mytype_id)\
+		{\
+			printf("uh oh, need conversion from type %d to %s(%d) for %s and that's not implemented yet!\n", get_blueprint(params[0])->type_id, #type_name, mytype_id, #name);\
+			exit(1);\
+		}\
+		return m_ ## name ## AT_ ## type_name(num_params, params);\
+}\
+returntype m_ ## name ## AT_ ## type_name(int num_params, object ** params) {\
+		ldec_ ## name ## AT_ ## type_name;\
+		static object * retvals[numret];\
+		object * call_params[32];\
+		int idx, vcparam_offset, last_vcparam;\
+		returntype callret,retinfo = {numret, &retvals};\
+		for(idx = numparams; idx < num_params; ++idx)\
+			release_ref(params[idx]); num_params = numparams;
+			
+			
+#define MethodImplNoLocals(name,type_name,mytype_id,numparams,numret) \
+returntype f_ ## name ## AT_ ## type_name(int num_params, object ** params) {\
+		if (num_params < 1)\
+		{\
+			printf("Direct call to %s@%s had no arguments!", #name, #type_name);\
+			exit(1);\
+		}\
+		if(get_blueprint(params[0])->type_id != mytype_id)\
+		{\
+			printf("uh oh, need conversion from type %d to %s(%d) for %s and that's not implemented yet!\n", get_blueprint(params[0])->type_id, #type_name, mytype_id, #name);\
+			exit(1);\
+		}\
+		return m_ ## name ## AT_ ## type_name(num_params, params);\
+}\
+returntype m_ ## name ## AT_ ## type_name(int num_params, object ** params) {\
+		static object * retvals[numret];\
+		object * call_params[32];\
+		int idx, vcparam_offset, last_vcparam;\
+		returntype callret,retinfo = {numret, &retvals};\
+		for(idx = numparams; idx < num_params; ++idx)\
+			release_ref(params[idx]); num_params = numparams;
+			
+#define Method(name) \
+returntype f_ ## name(int num_params, object ** params) {\
+	switch(get_blueprint(params[0])->type_id)\
+	{
+
+#define EndMethod(mname) \
+	default:\
+		printf("Type ");\
+		fwrite( ((t_Array *)((t_String *)get_blueprint(params[0])->name)->payload.Buffer)+1, 1, ((t_Array *)((t_String *)get_blueprint(params[0])->name)->payload.Buffer)->payload.Length, stdout);\
+		printf("(%d) does not implement method %s\n", get_blueprint(params[0])->type_id, #mname);\
+		printf("%d\n", *((char *)0));\
+		exit(1);\
+	}\
+}
+
+#define MethodDispatch(type_id,name,type_name) \
+	case type_id:\
+		return m_ ## name ## AT_ ## type_name(num_params, params);
+		
+#define FuncDef(name) returntype f_ ## name(int num_params, object ** params);
+#define MethodDef(name) returntype f_ ## name(int num_params, object ** params); returntype m_ ## name(int num_params, object ** params);
+
+#define PrepCall(callspace)
+#define SetParam(num,value) call_params[num] = value;
+#define VCRePrepCall(func,numparams,lastnumparams) \
+	vcparam_offset = 0;\
+	last_vcparam = -1;
+#define VCPrepCall(func,numparams) \
+	vcparam_offset = 0;\
+	last_vcparam = -1;
+#define VCSetParam(func,num,value) \
+	while((num+vcparam_offset) < ((t_Worker *)func)->payload.Size && ((object **)(((t_Worker *)func)+1))[num+vcparam_offset])\
+	{\
+		call_params[num+vcparam_offset] = add_ref(((object **)(((t_Worker *)func)+1))[num+vcparam_offset]);\
+		++vcparam_offset;\
+	}\
+	call_params[num+vcparam_offset] = value;\
+	last_vcparam = num+vcparam_offset;
+	
+#define ValCall(tocall,numparams,resumeto,myname)\
+	last_vcparam++;\
+	while(last_vcparam < ((t_Worker *)tocall)->payload.Size)\
+	{\
+		if (((object **)(((t_Worker *)tocall)+1))[last_vcparam]) \
+			call_params[last_vcparam] = add_ref(((object **)(((t_Worker *)tocall)+1))[last_vcparam]);\
+		++last_vcparam;\
+	}\
+	callret = func_lookup[((t_Worker *)tocall)->payload.Index](numparams + ((t_Worker *)tocall)->payload.Count, &call_params);
+
+#define ValCallNoLocals(tocall,numparams,resumeto,myname)\
+	last_vcparam++;\
+	while(last_vcparam < ((t_Worker *)tocall)->payload.Size)\
+	{\
+		if (((object **)(((t_Worker *)tocall)+1))[last_vcparam]) \
+			call_params[last_vcparam] = add_ref(((object **)(((t_Worker *)tocall)+1))[last_vcparam]);\
+		++last_vcparam;\
+	}\
+	callret = func_lookup[((t_Worker *)tocall)->payload.Index](numparams + ((t_Worker *)tocall)->payload.Count, &call_params);
+	
+#define ValCallPostlude(resumeto,myname)
+#define ValCallNoLocalsPostlude(resumeto,myname)
+
+#define Call(tocall, numparams, resumeto, myname)\
+	callret = f_ ## tocall(numparams, &call_params);
+	
+#define CallNoLocals(tocall, numparams, resumeto, myname)\
+	callret = f_ ## tocall(numparams, &call_params);
+	
+#define FreeCall
+#define FreeCallMethod(myname,mytype)
+#define TPrepCall(callspace)
+#define TCall(tocall, numparams)
+
--- a/runtime/localpointers_fragment.c	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/localpointers_fragment.c	Fri Oct 07 00:10:02 2011 -0700
@@ -1,3 +1,6 @@
+#ifdef RAW_FUNC
+rhope_func func_lookup[];
+#else
 	ct = new_context();
 	cdata = alloc_cdata(ct, NULL, callspace);
 	cdata->num_params = numparams;
@@ -5,4 +8,6 @@
 		cdata->params[idx] = params[idx];
 	cdata->func = END;
 DISPATCH
+#endif
 
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/runtime/main_end.c	Fri Oct 07 00:10:02 2011 -0700
@@ -0,0 +1,26 @@
+	
+#ifdef ENABLE_PROFILING
+	for (idx = 0; idx < END; ++idx)
+	{
+		if(profile_counts[idx])
+			printf("Func: %d\tCount: %llu\tTime: %llu\tAvg: %f\tSelf: %llu\tAvg: %f\tNested Count: %llu\n", idx, profile_counts[idx], profile_totals[idx], ((double)profile_totals[idx])/((double)profile_counts[idx]), profile_selftotals[idx], ((double)profile_selftotals[idx])/((double)profile_counts[idx]), profile_nestedcounts[idx]);
+	}
+#endif
+	if (!numret)
+		return 0;
+	if (numret < 0)
+		return numret;
+	if (get_blueprint(inout[0])->type_id == TYPE_INT32)
+		return ((t_Int32 *)inout[0])->Num;
+
+#ifdef RAW_FUNC
+	ret = f_If(1, inout);
+	if (ret.retvals[0])
+#else
+	rhope(FUNC_If, inout, 1, 2);
+	if (inout[0])
+#endif
+		return 0;
+	return 1;
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/runtime/main_mid.c	Fri Oct 07 00:10:02 2011 -0700
@@ -0,0 +1,24 @@
+#ifdef RAW_FUNC
+	ret = f_List(0, inout);
+	inout[0] = ret.retvals[0];
+	for (idx = 0; idx < argc; ++idx)
+	{
+		inout[1] = make_String(argv[idx]);
+		ret = f_Append(2, inout);
+		inout[0] = ret.retvals[0];
+	}
+	ret = f_Main(1, inout);
+	numret = ret.num_ret;
+	if (numret)
+		inout[0] = ret.retvals[0];
+#else
+
+	rhope(FUNC_List, inout, 0, 1);
+	for (idx = 0; idx < argc; ++idx)
+	{
+		inout[1] = make_String(argv[idx]);
+		rhope(FUNC_Append, inout, 2, 2);
+	}
+	numret = rhope(FUNC_Main, inout, 1, 1);
+#endif
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/runtime/main_start.c	Fri Oct 07 00:10:02 2011 -0700
@@ -0,0 +1,16 @@
+#ifdef RAW_FUNC
+#define rhope(func, io, inputs, callspace) ret = func_lookup[func](inputs, io); inout[0] = ret.retvals[0]
+#endif
+
+int main(int argc, char **argv)
+{
+	blueprint * bp;
+	int numret;
+	int idx;
+#ifdef RAW_FUNC
+	returntype ret;
+#endif
+	object * inout[3];
+	register_builtin_types();
+	register_type_byid(TYPE_MUTABLEGLOBAL, sizeof(mutable_object)-sizeof(object), NULL, NULL, NULL);
+
--- 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)
 {
--- a/runtime/object.h	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/object.h	Fri Oct 07 00:10:02 2011 -0700
@@ -32,7 +32,9 @@
 } blueprint;
 
 struct object {
+#ifndef USE_GC
 	rh_atomic32(refcount);
+#endif
 	blueprint  *bprint;
 };
 
@@ -66,29 +68,34 @@
 
 #define get_blueprint(object) (object)->bprint
 
+#ifdef USE_GC
+#define add_ref(object) object
+#define release_ref(object) 
+#else
 #define add_ref(object) (rh_atomic_add((object), refcount, 1),object)
+void release_ref(object * obj);
+#endif
 
-returntype call_method(uint32_t methodid, calldata * params);
+/*returntype call_method(uint32_t methodid, calldata * params);
 returntype set_field(uint32_t setfieldid, calldata * params);
-returntype get_field(uint32_t getfieldid, calldata * params);
+returntype get_field(uint32_t getfieldid, calldata * params);*/
 object * alloc_object(blueprint * bp);
 void * alloc_variable(uint32_t size);
 object * new_object(uint32_t type);
 object * new_object_bp(blueprint * bp);
 multisize * new_multisize(uint32_t type, uint32_t size);
-void release_ref(object * obj);
 blueprint * register_type_byid(uint32_t type, int32_t size, special_func init, special_func copy, special_func cleanup);
 blueprint * register_type(int32_t size, special_func init, special_func copy, special_func cleanup);
 blueprint * new_blueprint(uint32_t type, int32_t size, special_func init, special_func copy, special_func cleanup);
 void add_method(blueprint * bp, uint32_t methodid, rhope_func impl);
 void add_getter(blueprint * bp, uint32_t fieldid, rhope_func impl);
 void add_setter(blueprint * bp, uint32_t fieldid, rhope_func impl);
-returntype convert_to(uint32_t convertto, calldata * params);
-returntype convert_from(uint32_t convertfrom, calldata * params);
+/*returntype convert_to(uint32_t convertto, calldata * params);
+returntype convert_from(uint32_t convertfrom, calldata * params);*/
 object * copy_object(object * tocopy);
 object * naked_to_boxed(uint32_t type, void * rawdata);
 void boxed_to_naked(object * src, void * dest);
-returntype coerce_value(uint32_t type, calldata * params);
+/*returntype coerce_value(uint32_t type, calldata * params);*/
 blueprint * get_blueprint_byid(uint32_t type);
 
 extern blueprint ** registered_types;
--- a/runtime/rhopefuncs_epilog.c	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/rhopefuncs_epilog.c	Fri Oct 07 00:10:02 2011 -0700
@@ -1,4 +1,6 @@
-
+#ifdef RAW_FUNC
+DispatchVar
+#else
 DO_END:
 	for(idx = 0; idx < cdata->num_params; ++idx)	
 		params[idx] = cdata->params[idx];
@@ -36,4 +38,5 @@
 	}
 	return -1;
 }
+#endif //RAW_FUNC
 
--- a/runtime/rhopefuncs_prolog.c	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/rhopefuncs_prolog.c	Fri Oct 07 00:10:02 2011 -0700
@@ -1,3 +1,12 @@
+#ifdef RAW_FUNC
+FuncDef(Build)
+FuncDef(BlueprintSP_Of)
+FuncDef(ID)
+FuncDef(BlueprintSP_FromSP_ID)
+
+object * tmp;
+#else
+
 #ifdef ENABLE_PROFILING
 uint64_t profile_counts[END];
 uint64_t profile_nestedcounts[END];
@@ -43,4 +52,5 @@
 	FuncDef(ID)
 	FuncDef(BlueprintSP_FromSP_ID)
 	void ** lv_RunSP_Bytecode;
+#endif //RAW_FUNC
 
--- a/runtime/transaction.c	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/transaction.c	Fri Oct 07 00:10:02 2011 -0700
@@ -1,7 +1,11 @@
 #include "transaction.h"
 #include <stdarg.h>
 #include <string.h>
+#ifdef USE_GC
+#include <gc/gc.h>
+#else
 #include <stdlib.h>
+#endif
 
 rh_mutex(trans_lock)
 
@@ -15,23 +19,32 @@
 				return &(trans->cells[idx]);
 		trans = trans->chain;
 	}
-	return NULL;
+	return NULL; 
 }
 
+#ifdef RAW_FUNC
+transaction * cur_transaction;
+void real_begin_transaction(int numobjs,...)
+#else
 void begin_transaction(context * ct, int numobjs,...)
+#endif
 {
 	mutable_object *obj;
 	transaction *parent;
 	va_list args;
 	int32_t idx,got_global_lock=0;
 	
-	parent = ct->transaction ? ct->transaction : NULL;
+	parent = cur_transaction ? cur_transaction : NULL;
 	
-	ct->transaction = malloc(sizeof(transaction)+((numobjs-1)*sizeof(trans_cell)));
-	ct->transaction->parent = parent;
-	ct->transaction->chain = NULL;
+#ifdef USE_GC
+	cur_transaction = GC_malloc(sizeof(transaction)+((numobjs-1)*sizeof(trans_cell)));
+#else
+	cur_transaction = malloc(sizeof(transaction)+((numobjs-1)*sizeof(trans_cell)));
+#endif
+	cur_transaction->parent = parent;
+	cur_transaction->chain = NULL;
 	rh_mutex_init(ct->lock);
-	ct->transaction->num_cells = numobjs;
+	cur_transaction->num_cells = numobjs;
 	va_start(args, numobjs);
 	if (parent)
 	{
@@ -39,22 +52,22 @@
 			for (idx = 0; idx < numobjs; ++idx)
 			{
 				obj = va_arg(args, mutable_object *);
-				ct->transaction->cells[idx].obj = obj;
-				ct->transaction->cells[idx].parent = find_obj_cell(parent, obj);
-				if (ct->transaction->cells[idx].parent)
+				cur_transaction->cells[idx].obj = obj;
+				cur_transaction->cells[idx].parent = find_obj_cell(parent, obj);
+				if (cur_transaction->cells[idx].parent)
 				{
-					ct->transaction->cells[idx].local_data = ct->transaction->cells[idx].parent->local_data;
-					ct->transaction->cells[idx].orig_version = ct->transaction->cells[idx].parent->local_version;
+					cur_transaction->cells[idx].local_data = cur_transaction->cells[idx].parent->local_data;
+					cur_transaction->cells[idx].orig_version = cur_transaction->cells[idx].parent->local_version;
 				} else {
 					if (!got_global_lock)
 					{
 						rh_lock(trans_lock);
 						got_global_lock = 1;
 					}
-					ct->transaction->cells[idx].local_data = obj->data;
-					ct->transaction->cells[idx].orig_version = obj->version;
+					cur_transaction->cells[idx].local_data = obj->data;
+					cur_transaction->cells[idx].orig_version = obj->version;
 				}
-				ct->transaction->cells[idx].local_version = 0;
+				cur_transaction->cells[idx].local_version = 0;
 			}
 			if (got_global_lock)
 			{
@@ -66,16 +79,19 @@
 			for (idx = 0; idx < numobjs; ++idx)
 			{
 				obj = va_arg(args, mutable_object *);
-				ct->transaction->cells[idx].obj = obj;
-				ct->transaction->cells[idx].parent = NULL;
-				ct->transaction->cells[idx].local_data = add_ref(obj->data);
-				ct->transaction->cells[idx].orig_version = obj->version;
-				ct->transaction->cells[idx].local_version = 0;
+				cur_transaction->cells[idx].obj = obj;
+				cur_transaction->cells[idx].parent = NULL;
+				cur_transaction->cells[idx].local_data = add_ref(obj->data);
+				cur_transaction->cells[idx].orig_version = obj->version;
+				cur_transaction->cells[idx].local_version = 0;
 			}
 		rh_unlock(trans_lock);
 	}
 }
 
+#ifdef USE_GC
+#define free_trans(trans)
+#else
 void free_trans(transaction * trans)
 {
 	if (trans)
@@ -84,17 +100,22 @@
 		free(trans);
 	}
 }
+#endif
 
+#ifdef RAW_FUNC
+int32_t real_commit_transaction(int32_t readonly)
+#else
 int32_t commit_transaction(context * ct, int32_t readonly)
+#endif
 {
 	transaction *tmp_trans, *current;
 	object * tmp_obj;
 	int32_t idx,numaddparent;
 
-	if (ct->transaction->parent)
+	if (cur_transaction->parent)
 	{
-		rh_lock(ct->transaction->parent->lock);
-			current = ct->transaction;
+		rh_lock(cur_transaction->parent->lock);
+			current = cur_transaction;
 			while(current)
 			{
 				for (idx = 0; idx < current->num_cells; ++idx)
@@ -103,13 +124,13 @@
 					{
 						if (current->cells[idx].parent->local_version != current->cells[idx].orig_version)
 						{
-							rh_unlock(ct->transaction->parent->lock);
+							rh_unlock(cur_transaction->parent->lock);
 							return 0;
 						}
 					} else {
-						if(find_obj_cell(ct->transaction->parent->chain, current->cells[idx].obj))
+						if(find_obj_cell(cur_transaction->parent->chain, current->cells[idx].obj))
 						{
-							rh_unlock(ct->transaction->parent->lock);
+							rh_unlock(cur_transaction->parent->lock);
 							return 0;
 						} else
 							numaddparent++;
@@ -119,45 +140,49 @@
 			}
 			if (numaddparent)
 			{
+#ifdef USE_GC
+				tmp_trans = GC_malloc(sizeof(transaction)+(numaddparent - 1)*sizeof(trans_cell));
+#else
 				tmp_trans = malloc(sizeof(transaction)+(numaddparent - 1)*sizeof(trans_cell));
-				tmp_trans->chain = ct->transaction->parent->chain;
+#endif
+				tmp_trans->chain = cur_transaction->parent->chain;
 				tmp_trans->num_cells = 0;
-				ct->transaction->parent->chain = tmp_trans;
+				cur_transaction->parent->chain = tmp_trans;
 			}
-			current = ct->transaction;
+			current = cur_transaction;
 			while(current)
 			{
-				for (idx = 0; idx < ct->transaction->num_cells; ++idx)
+				for (idx = 0; idx < cur_transaction->num_cells; ++idx)
 				{
-					if (ct->transaction->cells[idx].parent)
+					if (cur_transaction->cells[idx].parent)
 					{
 						//Only commit a particular object if a change has been made
-						if (ct->transaction->cells[idx].local_version)
+						if (cur_transaction->cells[idx].local_version)
 						{
-							tmp_obj = ct->transaction->cells[idx].parent->local_data;
-							ct->transaction->cells[idx].parent->local_data = ct->transaction->cells[idx].local_data;
+							tmp_obj = cur_transaction->cells[idx].parent->local_data;
+							cur_transaction->cells[idx].parent->local_data = cur_transaction->cells[idx].local_data;
 							release_ref(tmp_obj);
-							ct->transaction->cells[idx].parent->local_version++;
+							cur_transaction->cells[idx].parent->local_version++;
 						} else {
-							release_ref(ct->transaction->cells[idx].local_data);
+							release_ref(cur_transaction->cells[idx].local_data);
 						}
 					} else {
-						memcpy(&(tmp_trans->cells[tmp_trans->num_cells++]), &(ct->transaction->cells[idx]), sizeof(trans_cell));
+						memcpy(&(tmp_trans->cells[tmp_trans->num_cells++]), &(cur_transaction->cells[idx]), sizeof(trans_cell));
 					}
 				}
 				current = current->chain;
 			}
-		rh_unlock(ct->transaction->parent->lock);
+		rh_unlock(cur_transaction->parent->lock);
 	} else {
 		if(readonly)
 		{
-			for (idx = 0; idx < ct->transaction->num_cells; ++idx)
+			for (idx = 0; idx < cur_transaction->num_cells; ++idx)
 			{
-				release_ref(ct->transaction->cells[idx].local_data);
+				release_ref(cur_transaction->cells[idx].local_data);
 			}
 		} else {
 			rh_lock(trans_lock);
-				current = ct->transaction;
+				current = cur_transaction;
 				while(current)
 				{
 					for (idx = 0; idx < current->num_cells; ++idx)
@@ -170,7 +195,7 @@
 					}
 					current = current->chain;
 				}
-				current = ct->transaction;
+				current = cur_transaction;
 				while(current)
 				{
 					for (idx = 0; idx < current->num_cells; ++idx)
@@ -191,21 +216,26 @@
 			rh_unlock(trans_lock);
 		}
 	}
-	rh_mutex_del(ct->transaction->lock);
-	tmp_trans = ct->transaction->parent;
-	free_trans(ct->transaction);
-	ct->transaction = tmp_trans;
+	rh_mutex_del(cur_transaction->lock);
+	tmp_trans = cur_transaction->parent;
+	free_trans(cur_transaction);
+	cur_transaction = tmp_trans;
 	return 1;
 }
 
+
+#ifdef RAW_FUNC
+void prep_retry()
+#else
 void prep_retry(context * ct)
+#endif
 {
 	transaction * current;
 	int32_t idx,got_global_lock=0;
-	if (ct->transaction->parent)
+	if (cur_transaction->parent)
 	{
-		rh_lock(ct->transaction->parent->lock);
-			current = ct->transaction;
+		rh_lock(cur_transaction->parent->lock);
+			current = cur_transaction;
 			while(current)
 			{
 				for (idx = 0; idx < current->num_cells; ++idx)
@@ -213,7 +243,7 @@
 					release_ref(current->cells[idx].local_data);
 					current->cells[idx].local_version = 0;
 					if (!current->cells[idx].parent)
-						current->cells[idx].parent = find_obj_cell(ct->transaction->parent, current->cells[idx].obj);
+						current->cells[idx].parent = find_obj_cell(cur_transaction->parent, current->cells[idx].obj);
 					if (current->cells[idx].parent)
 					{
 						current->cells[idx].local_data = current->cells[idx].parent->local_data;
@@ -234,10 +264,10 @@
 			{
 				rh_unlock(trans_lock);
 			}
-		rh_unlock(ct->transaction->parent->lock);
+		rh_unlock(cur_transaction->parent->lock);
 	} else {
 		rh_lock(trans_lock);
-			current = ct->transaction;
+			current = cur_transaction;
 			while(current)
 			{
 				for (idx = 0; idx < current->num_cells; ++idx)
--- a/runtime/transaction.h	Wed Jul 27 21:32:40 2011 -0700
+++ b/runtime/transaction.h	Fri Oct 07 00:10:02 2011 -0700
@@ -33,8 +33,19 @@
 #include "context.h"
 
 trans_cell * find_obj_cell(transaction * trans, mutable_object * to_find);
+#ifdef RAW_FUNC
+#define begin_transaction(ct, numobjs, ...) real_begin_transaction(numobjs, __VA_ARGS__)
+void real_begin_transaction(int numobjs,...);
+#define commit_transaction(ct, readonly) real_commit_transaction(readonly)
+int32_t real_commit_transaction(int32_t readonly);
+#define prep_retry(ct) real_prep_retry()
+void prep_retry();
+extern transaction * cur_transaction;
+#else
 void begin_transaction(struct context * ct, int numobjs,...);
 int32_t commit_transaction(struct context * ct, int32_t readonly);
 void prep_retry(struct context * ct);
+#define cur_transaction ct->transaction
+#endif
 
 #endif //TRANSACTION_H_