--- a/cbackend.rhope	Tue Jun 01 01:13:54 2010 -0400
+++ b/cbackend.rhope	Sun Jun 06 20:29:10 2010 -0400
@@ -1,6 +1,5 @@
 Import extendlib.rhope
 Import backendutils.rhope
-Import number.rhope
 
 Blueprint Blueprint Def
 {
@@ -303,7 +302,7 @@
 						]Append[", (special_func)"]
 						]Append[Escape Rhope Name NU[[ctype]Cleanup >>]]         
 					]Append[");"]]] ]
-	out <- Fold[[["_Type Init C Field"]Set Input[0, [ctype]Name >>]]Set Input[1, field reg], Fold[[["_Type Init C"]Set Input[0, [ctype]Name >>]]Set Input[1, method reg], start, [ctype]Methods >>], [ctype]Fields >>]
+	out <- Val[start]//Fold[[["_Type Init C Field"]Set Input[0, [ctype]Name >>]]Set Input[1, field reg], Fold[[["_Type Init C"]Set Input[0, [ctype]Name >>]]Set Input[1, method reg], start, [ctype]Methods >>], [ctype]Fields >>]
 }
 
 Blueprint C Type Registry
@@ -414,6 +413,7 @@
 	Input Types
 	Output Types
 	Resume Index
+	Last NumParams
 }
 
 C Function[name,inputs,outputs,convention:out]
@@ -423,7 +423,7 @@
 
 C Function With Registry[name,inputs,outputs,convention,registry,field reg,type reg:out]
 {
-	out <- [[[[[[[[[[[[[Build["C Function"]
+	out <- [[[[[[[[[[[[[[Build["C Function"]
 		]Name <<[name]
 		]Inputs <<[inputs]
 		]Outputs <<[outputs]
@@ -437,6 +437,7 @@
 		]Input Types <<[ Fold[["Append"]Set Input[1, "Any Type"], (), inputs] ]
 		]Output Types <<[ Fold[["Append"]Set Input[1, "Any Type"], (), outputs] ]
 		]Resume Index <<[1]
+		]Last NumParams <<[-1]
 }
 
 Set Input Type@C Function[func,type,input num:out]
@@ -565,7 +566,7 @@
 {
 	source <- [psource]Make Op[func]
 	Print[["Release: "]Append[source]]
-	out <- [func]Add Statement[[["release_ref("]Append[source]]Append[")"]]
+	out <- [func]Add Statement[[["release_ref((object *)"]Append[source]]Append[")"]]
 }
 
 Set Null@C Function[func,pdest:out]
@@ -708,7 +709,23 @@
 Func Base@C Function[func,tocall,args,type:out]
 {
 	rargs <- Map[args, ["Make Op"]Set Input[1, func]]
-	out <- [[Fold["_Function Arg C", [func]Add Raw Line[ [["PrepCall("]Append[[rargs]Length]]Append[")"] ], rargs]
+
+	If[[[rargs]Length] > [[func]Last NumParams >>]]
+	{	
+		If[[[func]Last NumParams >>] = [-1]]
+		{
+			freed <- Val[func]
+		}{
+			freed <- [func]Add Raw Line["FreeCall"]
+		}
+		prepped <- [[freed]Add Raw Line[ [["PrepCall("]Append[[rargs]Length]]Append[")"] ]
+		]Last NumParams <<[[rargs]Length]
+	}{
+		prepped <- Val[func]
+	}
+	
+	
+	out <- [[Fold["_Function Arg C", prepped, rargs]
 	]Add Raw Line[
 		[[[[[[[[[type]Append["("]
 		]Append[tocall]
@@ -738,21 +755,14 @@
 	out <- [func]Add Statement[stmt]
 }
 
-Field Base@C Function[func,field,args,type:out]
-{
-	rargs <- Map[args, ["Make Op"]Set Input[1, func]]
-	out <- [Fold["_Function Arg C", func, rargs]
-	]Add Raw Line[[[ [type]Append["("] ]Append[ [[func]Field Registry >>]Field ID[field] ]]Append[")"]]
-}
-
 Get Field Call@C Function[func,field,source:out]
 {
-	out <- [func]Field Base[field, [()]Append[source], "GFieldCall"]
+	out <- [func]Func Base[Escape Rhope Name[[field]Append[" >>"]], [()]Append[source], "Call"]
 }
 
 Set Field Call@C Function[func,field,object,value:out]
 {
-	out <- [func]Field Base[field, [[()]Append[object]]Append[value], "SFieldCall"]
+	out <- [func]Func Base[Escape Rhope Name[[field]Append[" <<"]], [[()]Append[object]]Append[value], "Call"]
 }
 
 Tail Method Call@C Function[func,method,args:out]
@@ -771,9 +781,9 @@
 	{
 		[[func]Inputs >>]Find[op]
 		{
-			out <- [["cdata->params["]Append[~]]Append["]"]
+			out <- [["my_cdata->params["]Append[~]]Append["	]"]
 		}{
-			out <- ["locals->"]Append[Escape Rhope Name[op]]
+			out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]Append[Escape Rhope Name[op]]
 		}
 	}{
 		out <- Escape Rhope Name[op]
@@ -784,7 +794,7 @@
 {
 	If[[[func]Convention >>] = ["rhope"]]
 	{
-		out <- ["locals->"]Append[Escape Rhope Name[name]]
+		out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]Append[Escape Rhope Name[name]]
 	}{
 		out <- Escape Rhope Name[name]
 	} 
@@ -803,16 +813,17 @@
 Do If@C Function[func,condition,stream:out]
 {
 	cond <- [condition]Make Op[func]
-	out <- [Fold["_If C", [[func
+	out <- [[Fold["_If C", [[func
 		]Add Raw Line[ [["if("]Append[cond]]Append[")"] ]
 		]Add Raw Line["{"], [stream]Statements >>]
 		]Add Raw Line["}"]
+		]Resume Index <<[[stream]Resume Index >>]
 
 }
 
 Result Reference@C Function[func,output:out]
 {
-	out <- [["call->params["]Append[output]]Append["]"]
+	out <- [["cdata->params["]Append[output]]Append["]"]
 }
 
 If Null Else@C Function[func,left,right:out]
@@ -829,16 +840,16 @@
 		]Append[")"]
 }
 
-_Set Outputs C[string,inputname,inputnum:out]
+_Set Outputs C[string,inputname,inputnum,func:out]
 {
-	out <- [string]Append[[[ [ ["\tRet("]Append[inputnum] ]Append[", locals->"]]Append[inputname]]Append[")\n"]]
+	out <- [string]Append[[[ [ ["\tRet("]Append[inputnum] ]Append[ [[", lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]]Append[inputname]]Append[")\n"]]
 }
 
 Set Outputs@C Function[func:out]
 {
 	If[[[func]Convention >>] = ["rhope"]]
 	{
-		out <- Fold["_Set Outputs C", "", [func]Outputs >>]
+		out <- [[[Fold[["_Set Outputs C"]Set Input[3, func], "", [func]Outputs >>]]Append["\tNumRet("]]Append[[[func]Outputs >>]Length]]Append[")\n"]
 	}{
 		[[func]Outputs >>]Index[0]
 		{
@@ -864,7 +875,7 @@
 	{
 	If[ [[[func]Convention >>] = ["rhope"]] And [[ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] > [0]] ]
 	{
-		localtype <- [[[Fold[["_Output Defs C"]Set Input[3, func], Fold["_Var Defs C","typedef struct {\n", [func]Variables >>], [func]Outputs >>]]Append["} l_"]]Append[Escape Rhope Name[[func]Name >>]]]Append[";\n"]
+		localtype <- [[[Fold[["_Output Defs C"]Set Input[3, func], Fold["_Var Defs C","typedef struct {\n", [func]Variables >>], [func]Outputs >>]]Append["} lt_"]]Append[Escape Rhope Name[[func]Name >>]]]Append[";\n"]
 	}{
 		localtype <- ""
 	}
@@ -881,7 +892,7 @@
 				]Append[")\n"]
 		}{
 			proto <- [["FuncDef("]Append[Escape Rhope Name[[func]Name >>]]]Append[")\n"]
-		} */
+		} */
 		out <- Val[localtype]
 	}{
 		out <- [[func]Naked Proto]Append[";\n"]
@@ -941,41 +952,50 @@
 {	
 	Print[["Text@C Function: "]Append[[func]Name >>]]
 	If[ [[func]Convention >>] = ["rhope"] ]
-	{
-		,before <- [[func]Name >>]Get DString["@"]
-		{
-			type <- "MethodImpl"
-			cname <- [[[[Escape Rhope Name[before]
-				]Append[", "]
-				]Append[Escape Rhope Name[~]]
-				]Append[", "]
-				]Append[ [[func]Type Registry >>]Type ID[~] ]
-		}{}{}{
-			type <- "Func"
-			cname <- Val[fname]
-		}
+	{
+		,before <- [[func]Name >>]Get DString["@"]
+		{
+			type <- "MethodImpl"
+			cname <- [[[[Escape Rhope Name[before]
+				]Append[", "]
+				]Append[Escape Rhope Name[~]]
+				]Append[", "]
+				]Append[ [[func]Type Registry >>]Type ID[~] ]
+		}{}{}{
+			type <- "Func"
+			cname <- Val[fname]
+		}
 		fname <- Escape Rhope Name[[func]Name >>]
 		param check <- Fold[["Check Param Type C"]Set Input[3, func], "", [func]Input Types >>]
 		If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ]
 		{
-			out <- [[[[[[[ [type]Append["NoLocals("]
+			out <- [[[[[[[[ [type]Append["NoLocals("]
 				]Append[cname]
 				]Append[",\n\tNumParams "]
 				]Append[ [[func]Inputs >>]Length ]
 				]Append[")\n\n"]
 				]Append[param check]
 				]Append[ [[func]Statements >>]Join[""] ]
-				]Append["EndFuncNoLocals"]
+				]Append["EndFuncNoLocals\n"]
+				]Append["DISPATCH"]
 		}{
-			out <- [[[[[[[[ [type]Append["("]
+			If[[[func]Last NumParams >>] = [-1]]
+			{
+				freecall <- ""
+			}{
+				freecall <- "\n\tFreeCall\n"
+			}
+			out <- [[[[[[[[[[ [type]Append["("]
 				]Append[cname]
 				]Append[",\n\tNumParams "]
 				]Append[ [[func]Inputs >>]Length ]
 				]Append[")\n\n"]
 				]Append[param check]
 				]Append[ [[func]Statements >>]Join[""] ]
+				]Append[freecall]
 				]Append[[func]Set Outputs]
-				]Append[[["EndFunc("]Append[fname]]Append[")"]]
+				]Append[[["EndFunc("]Append[fname]]Append[")\n"]]
+				]Append["DISPATCH"]
 		}
 	}{
 		
@@ -1138,17 +1158,23 @@
 }
 
 _Dispatch Switch[text,func,raw name:out]
-{
-	If[[[func]Convention >>] = ["rhope"]]
+{
+	If[[[func]Convention >>] = ["rhope"]]
 	{
 		name <- Escape Rhope Name[raw name]
 		out <- [[text]Append[ [[[["\tcase FUNC_"]Append[name]]Append[": goto f_"]]Append[name]]Append[";\\\n"] ]
-			]Append[Fold[["_Dispatch Switch Sub"]Set Input[2, name], "", Range[1, [func]Resume Index >>]]]
-	}{
-		out <- text
+			]Append[Fold[["_Dispatch Switch Sub"]Set Input[2, name], "", Range[1, [func]Resume Index >>]]]
+	}{
+		out <- text
 	}
 }
 
+_Dispatch Switch Methods[text,id,raw name:out]
+{
+	name <- Escape Rhope Name[raw name]
+	out <- [text]Append[ [[[["\tcase FUNC_"]Append[name]]Append[": goto f_"]]Append[name]]Append[";\\\n"] ]
+}
+
 _Dispatch Enum Sub[text, num, name:out]
 {
 	out <- [[[[[text
@@ -1160,44 +1186,105 @@
 }
 
 _Dispatch Enum[text,func,raw name:out]
-{
-	If[[[func]Convention >>] = ["rhope"]]
+{
+	If[[[func]Convention >>] = ["rhope"]]
 	{
 		name <- Escape Rhope Name[raw name]
 		out <- [[text]Append[ [["\tFUNC_"]Append[name]]Append[",\n"] ]
-			]Append[Fold[["_Dispatch Enum Sub"]Set Input[2, name], "", Range[1, [func]Resume Index >>]]]
-	}{
-		out <- text
+			]Append[Fold[["_Dispatch Enum Sub"]Set Input[2, name], "", Range[1, [func]Resume Index >>]]]
+	}{
+		out <- text
 	}
 }
 
-Dispatch@C Program[program:out]
+_Dispatch Enum Methods[text,types,name:out]
+{
+	out <- [text]Append[ [["\tFUNC_"]Append[Escape Rhope Name[name]]]Append[",\n"] ]
+}
+
+Dispatch@C Program[program,all methods:out]
 {
 	out <- [[[[["typedef enum {\n"
-		]Append[Fold["_Dispatch Enum", "", [program]Functions >>]]
+		]Append[Fold["_Dispatch Enum", 
+			[Fold["_Dispatch Enum Methods", "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n"], 
+			[program]Functions >>]]
 		]Append["\tEND\n} funcids;\n\n"]
 		]Append["#define DISPATCH switch(func) { \\\n"]
-		]Append[Fold["_Dispatch Switch", "", [program]Functions >>]]
+		]Append[Fold["_Dispatch Switch", 
+			[Fold["_Dispatch Switch Methods", "", all methods]]Append["\tcase FUNC_Build: goto f_Build;\\\n\tcase FUNC_BlueprintSP_Of: goto f_BlueprintSP_Of;\\\n"], 
+			[program]Functions >>]]
 		]Append["\tcase END: goto DO_END;\\\n}\n\n"]
-}
-
-Not Native[func:out]
-{
-	If[[[func]Convention >>] = ["rhope"]]
-	{ out <- No }
-	{ out <- Yes }
-}
-
-Native[func:out]
-{
-	out <- [[func]Convention >>] = ["rhope"]
+}
+
+Not Native[func:out]
+{
+	If[[[func]Convention >>] = ["rhope"]]
+	{ out <- No }
+	{ out <- Yes }
+}
+
+Native[func:out]
+{
+	out <- [[func]Convention >>] = ["rhope"]
+}
+
+Local Pointers[text,func:out]
+{
+	If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ]
+	{
+		out <- text
+	}{
+		out <- [text]Append[[["\tFuncDef("]Append[Escape Rhope Name[[func]Name >>]]]Append[")\n"]]
+	}
+}
+
+_Method to Types[dict,name,type:out]
+{
+	typelist <- [dict]Index[name] {}
+	{ typelist <- () }
+
+	out <- [dict]Set[name, [typelist]Append[[type]Name >>]]
+
+}
+
+_Field to Types[dict,field,type:out]
+{
+	name <- [field]Index[0]
+	out <- _Method to Types[_Method to Types[dict, [name]Append[" >>"], type], [name]Append[" <<"], type]
+
+}
+
+Method to Types[dict,type:out]
+{
+	out <- Fold[["_Method to Types"]Set Input[2, type], dict, [type]Methods >>]
+}
+
+Field to Types[dict,type:out]
+{
+	out <- Fold[["_Field to Types"]Set Input[2, type], dict, [type]Fields >>]
+}
+
+_Method Dispatch[text, type, method, reg: out]
+{
+	out <- [[[[[[[text]Append["\tMethodDispatch("]]Append[ [reg]Type ID[type] ]]Append[","]]Append[Escape Rhope Name[method]]]Append[","]]Append[Escape Rhope Name[type]]]Append[")\n"]
+}
+
+Method Dispatch[text, types, method, reg: out]
+{
+	out <- [[[Fold[[["_Method Dispatch"]Set Input[2, method]]Set Input[3, reg], [[[text]Append["Method("]]Append[ Escape Rhope Name[method] ]]Append[")\n"], types]
+		]Append["EndMethod("]
+		]Append[Escape Rhope Name[method]]
+		]Append[")\n\n"]
 }
 
 Text@C Program[program:out]
 {
 	Print["Text@C Program"]
+	type defs <- [[program]Type Registry >>]Definitions >>
 	constants <- Fold["Combine Consts", Dictionary[], [program]Functions >>]
+	all methods <- Fold["Field to Types", Fold["Method to Types", Dictionary[], type defs], type defs]
 	headers <- "#include <stdio.h>
+#include <stdlib.h>
 #include \"builtin.h\"
 #include \"object.h\"
 #include \"context.h\"
@@ -1206,28 +1293,82 @@
 #include \"blueprint.h\"
 #include \"array.h\"
 #include \"bool.h\"\n\n"
-	out <- [[[[[[[[[[[headers
-		]Append[[program]Dispatch]
-		]Append[[[program]Type Registry >>]Type Defs]
+	out <- [[[[[[[[[[[[[[[headers
+		]Append[[program]Dispatch[all methods]]
+		]Append[[[program]Type Registry >>]Type Defs]
 		]Append[Fold["_Consts C Program", 
 					Fold["_Defs C Program", "", [program]Functions >>], 
 					constants]]
-		]Append[Fold[["_Text C Program"]Set Input[2, [program]Type Registry >>], "", Filter[[program]Functions >>, "Not Native"]]]
-		]Append["\n
-void rhope(uint32_t func)
-{
-	uint16_t resume,idx;
-	context * ct;
-	calldata * cdata, *temp_cdata;"]
+		]Append[Fold[["_Text C Program"]Set Input[2, [program]Type Registry >>], "", Filter[[program]Functions >>, "Not Native"]]]
+		]Append["\n
+uint16_t rhope(uint32_t func, object ** params, uint16_t numparams, uint16_t callspace)
+{
+	uint16_t resume,idx;
+	context * ct;
+	calldata * cdata, *temp_cdata, *my_cdata;\n\nFuncDef(Build)\nFuncDef(BlueprintSP_Of)\n"]
+		]Append[Fold["Local Pointers", "", [program]Functions >>]]
+		]Append["
+	ct = new_context();
+	cdata = alloc_cdata(ct, NULL, callspace);
+	cdata->num_params = numparams;
+	for(idx = 0; idx < numparams; ++idx)
+		cdata->params[0-idx] = params[idx];
+	cdata->func = END;
+DISPATCH\n"]
+		]Append[Fold[["Method Dispatch"]Set Input[3, [program]Type Registry >>], "", all methods]]
+		]Append["
+Func(Build,
+	NumParams 1)
+	
+	Param(0, TYPE_BLUEPRINT)
+	
+	lv_Build->bp = ((t_Blueprint *)(cdata->params[0]))->bp;
+	release_ref(cdata->params[0]);
+	
+	Ret(0, new_object_bp(lv_Build->bp))
+EndFunc(Build)
+DISPATCH
+
+Func(BlueprintSP_Of,
+	NumParams 1)
+	
+	lv_BlueprintSP_Of->bp = get_blueprint(cdata->params[0]);
+	release_ref(cdata->params[0]);
+	
+	Ret(0, new_object(TYPE_BLUEPRINT))
+	((t_Blueprint *)cdata->params[0])->bp = lv_BlueprintSP_Of->bp;
+EndFunc(BlueprintSP_Of)
+DISPATCH\n"]
 		]Append[Fold[["_Text C Program"]Set Input[2, [program]Type Registry >>], "", Filter[[program]Functions >>, "Native"]]]
-		]Append["\n\nint main(int argc, char **argv)
+		]Append["
+DO_END:
+	for(idx = 0; idx < cdata->num_params; ++idx)	
+		params[idx] = cdata->params[0-idx];
+	free_context(ct);
+	return cdata->num_params;
+
+_exception:
+	puts(\"Exception! Trace follows:\");
+	while(cdata && cdata->func != END)
+	{
+		printf(\"%d\\n\", cdata->func);
+		cdata = cdata->lastframe;
+	}
+	return 0;
+}
+
+#include \"builtin.c\"
+#include \"array.c\"
+
+int main(int argc, char **argv)
 {
+	blueprint * bp;
 	register_builtin_types();\n\n"]
 		]Append[ [[program]Type Registry >>]Type Inits[[program]Method Registry >>, [program]Field Registry >>] ]
 		]Append[Fold[["_Set Consts C Program"]Set Input[3, [program]Type Registry >>], "", constants]]
 		]Append[Fold[["_Set Late Consts C"]Set Input[3, [program]Type Registry >>], "", constants]]
 		]Append["
-	rhope(FUNC_Main);
+	rhope(FUNC_Main, NULL, 0, 0);
 	return 0;
 }\n\n"]