--- a/backendutils.rhope	Wed Jul 27 21:06:57 2011 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,353 +0,0 @@
-
-Escape Rhope Name NU[name:escaped]
-{
-	escaped <- [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[name]Replace["_","UN_"]
-		]Replace["@","AT_"]
-		]Replace[" ","SP_"]
-		]Replace[":","CN_"]
-		]Replace["?","QN_"]
-		]Replace["+","PL_"]
-		]Replace["-","MN_"]
-		]Replace["*","TM_"]
-		]Replace["/","DV_"]
-		]Replace["<","LT_"]
-		]Replace[">","GT_"]
-		]Replace["(","LP_"]
-		]Replace[")","RP_"]
-		]Replace["!","NT_"]
-		]Replace["=","EQ_"]
-		]Replace["'","PR_"]
-		]Replace["\"","DP_"]
-		]Replace["\t","TB_"]
-		]Replace[",", "CM_"]
-		]Replace[".", "PD_"]
-		]Replace["\n", "NL_"]
-		]Replace["{", "LC_"]
-		]Replace["}", "RC_"]
-		]Replace["[", "LS_"]
-		]Replace["]", "RS_"]
-		]Replace["#", "HS_"]
-		]Replace["\\", "BS_"]
-		]Replace["\r", "CR_"]
-		]Replace[";", "SC_"]
-		]Replace["&", "AM_"]
-		]Replace["|", "PI_"]
-		]Replace["%", "PC_"]
-		]Replace["`", "BT_"]
-		]Replace["~", "TD_"]
-}
-
-Escape Rhope Name[name:out]
-{
-	escaped <- Escape Rhope Name NU[[name]Replace["_","__"]]
-	[("char","int","short","long","float","double","void","struct")]Find[escaped]
-	{
-		out <- ["ID_"]Append[escaped]
-	}{
-		out <- Val[escaped]
-	}
-}
-
-Blueprint AddRef
-{
-	Value
-}
-
-AddRef[value:out]
-{
-	out <- [Build["AddRef"]]Value <<[value]
-}
-
-Make Op@AddRef[addref,func:out]
-{
-	//TODO: Make me work with other backends
-	out <- [["add_ref((object *)"]Append[ [[addref]Value >>]Make Op[func] ]]Append[")"]
-}
-
-Strip Addref@AddRef[op:out]
-{
-	out <- [[op]Value >>]Strip Addref
-}
-
-Make Op@String[string,func:out]
-{
-	out <- [func]Resolve[string]
-}
-
-Strip Addref@String[op:out]
-{
-	out <- op
-}
-
-Make Op@Whole Number[num,func:out]
-{
-	out <- num
-}
-
-Strip Addref@Whole Number[op:out]
-{
-	out <- op
-}
-
-Make Op@Real Number[num,func:out]
-{
-	out <- num
-}
-
-Strip Addref@Real Number[op:out]
-{
-	out <- op
-}
-
-Blueprint Output
-{
-	Name
-}
-
-Output[name:out]
-{
-	out <- [Build["Output"]]Name <<[name]
-}
-
-Make Op@Output[op,func:out]
-{
-	out <- [func]Resolve Output[[op]Name >>]
-}
-
-Strip Addref@Output[op:out]
-{
-	out <- op
-}
-
-Blueprint Constant
-{
-	Value
-	Need Addref
-}
-
-Constant[var:out]
-{
-	out <- [[Build["Constant"]]Value <<[var]]Need Addref <<[Yes]
-}
-
-Make Op@Constant[const,func:out]
-{
-	out <- [func]Lookup Constant[[const]Value >>, [const]Need Addref >>]
-}
-
-Strip Addref@Constant[op:out]
-{
-	out <- [op]Need Addref <<[No]
-}
-
-Blueprint Result
-{
-	Output Num
-}
-
-Result[num:out]
-{
-	out <- [Build["Result"]]Output Num <<[num]
-}
-
-Make Op@Result[result,func:out]
-{
-	out <- [func]Result Reference[[result]Output Num>>]
-}
-
-Strip Addref@Result[op:out]
-{
-	out <- op
-}
-
-Blueprint Check Result
-{
-	Output Num
-}
-
-Check Result[num:out]
-{
-	out <- [Build["Check Result"]]Output Num <<[num]
-}
-
-Make Op@Check Result[result,func:out]
-{
-	out <- [func]Checked Result Reference[[result]Output Num>>]
-}
-
-Strip Addref@Check Result[op:out]
-{
-	out <- op
-}
-
-Make Condition[op:out]
-{
-	If[[Type Of[op]]=["OrValue"]]
-	{
-		out <- OrCond[Make Condition[[op]Left >>], Make Condition[[op]Right >>]]
-	}{
-		out <- op
-	}
-}
-
-Blueprint OrValue
-{
-	Left
-	Right
-}
-
-OrValue[left,right:out]
-{
-	out <- [[Build["OrValue"]]Left <<[left]]Right <<[right]
-}
-
-Make Op@OrValue[orval,func:out]
-{
-	out <- [func]If Null Else[[orval]Left >>, [orval]Right >>]
-}
-
-Strip Addref@OrValue[op:out]
-{
-	out <- [[op]Left <<[ [[op]Left >>]Strip Addref ]]Right <<[ [[op]Right >>]Strip Addref ]
-}
-
-Blueprint NotCond
-{
-	Condition
-}
-
-NotCond[cond:out]
-{
-	out <- [Build["NotCond"]]Condition <<[[cond]Strip Addref]
-}
-
-Make Op@NotCond[cond,func:out]
-{
-	out <- ["!"]Append[[[cond]Condition >>]Make Op[func]]
-}
-
-Strip Addref@NotCond[op:out]
-{
-	out <- op
-}
-
-Blueprint OrCond
-{
-	Condition1
-	Condition2
-}
-
-OrCond[cond1,cond2:out]
-{
-	out <- [[Build["OrCond"]]Condition1 <<[[cond1]Strip Addref]]Condition2 <<[[cond2]Strip Addref]
-}
-
-Make Op@OrCond[cond,func:out]
-{
-	out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" || "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]]
-}
-
-Strip Addref@OrCond[op:out]
-{
-	out <- op
-}
-
-Blueprint AndCond
-{
-	Condition1
-	Condition2
-}
-
-AndCond[cond1,cond2:out]
-{
-	out <- [[Build["AndCond"]]Condition1 <<[[cond1]Strip Addref]]Condition2 <<[[cond2]Strip Addref]
-}
-
-Make Op@AndCond[cond,func:out]
-{
-	out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" && "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]]
-}
-
-Strip Addref@AndCond[op:out]
-{
-	out <- op
-}
-
-Blueprint Field Ref
-{
-	Variable
-	Field
-}
-
-Field Ref[var,field:out]
-{
-	out <- [[Build["Field Ref"]]Variable <<[var]]Field <<[field]
-}
-
-Make Op@Field Ref[ref,func:out]
-{
-	out <- [func]Field Result[[ref]Variable >>,[ref]Field >>]
-}
-
-Strip Addref@Field Ref[op:out]
-{
-	out <- op
-}
-
-Blueprint Type Instance
-{
-	Name
-	Params
-	Variant
-	Mutable?
-}
-
-Type Instance[raw name:out]
-{
-	If[[raw name]=[""]]
-	{
-		name <- "Any Type"
-	}{
-		name <- raw name
-	}
-	out <- [[[[Build["Type Instance"]]Name <<[name]]Params <<[()]]Variant <<["Boxed"]]Mutable? <<[No]
-}
-
-Set Variant@Type Instance[type,variant:out,invalid]
-{
-	[("Boxed","Naked","Pointer","Raw Pointer")]Find[variant]
-	{
-		out <- [type]Variant <<[variant]
-	}{
-		invalid <- type
-	}
-}
-
-=@Type Instance[type,compare:out]
-{
-	If[[Type Of[compare]] = ["String"]]
-	{
-		out <- [[type]Name >>] = [compare]
-	}{
-		//TODO: Compare parameters
-		,out <- If[[[type]Name >>] = [[compare]Name >>]]
-		{ out <- [[type]Variant >>] = [[compare]Variant >>] }
-	}
-}
-
-Blueprint Worker Literal
-{
-	Name
-	Args
-}
-
-Worker Literal[name:out]
-{
-	out <- [[Build["Worker Literal"]]Name <<[name]]Args <<[()]
-}
-
-Set Input@Worker Literal[worker,argnum,val:out]
-{
-	out <- [worker]Args <<[ [[worker]Args >>]Set[argnum, val] ]
-}
-

--- a/cbackend.rhope	Wed Jul 27 21:06:57 2011 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1699 +0,0 @@
-Import extendlib.rhope
-Import backendutils.rhope
-
-Blueprint Blueprint Def
-{
-	Name
-	Fixed Size
-	Fields
-	Methods
-}
-
-Blueprint Def[name]
-{
-	out <- [[[[Build["Blueprint Def"]]Name <<[name]]Fixed Size <<[0]]Fields <<[()]]Methods <<[Dictionary[]]
-}
-
-Blueprint C Method Registry
-{
-	Lookup
-	Next ID
-}
-
-C Method Registry[:out]
-{
-	builtins <- [[[[[[[[[[[[[Dictionary[]
-		]Set["+", "METHOD_ADD"]
-		]Set["-", "METHOD_SUB"]
-		]Set["/", "METHOD_DIV"]
-		]Set["*", "METHOD_MUL"]
-		]Set["LShift", "METHOD_LSHIFT"]
-		]Set["RShift", "METHOD_RSHIFT"]
-		]Set["=", "METHOD_EQUALS"]
-		]Set[">", "METHOD_GREATER"]
-		]Set["<", "METHOD_LESS"]
-		]Set["If", "METHOD_IF"]
-		]Set["Set Missing Field", "METHOD_SETFIELDMISSING"]
-		]Set["Get Missing Field", "METHOD_GETFIELDMISSING"]
-		]Set["Missing Method", "METHOD_MISSING"]
-	out <- [[Build["C Method Registry"]]Lookup <<[builtins]]Next ID<<[0]
-
-}
-
-Register Method@C Method Registry[reg,method:out]
-{
-	[[reg]Lookup >>]Index[method]
-	{
-		out <- reg
-	}{
-		method ID <- [reg]Next ID>>
-		new lookup <- [[reg]Lookup >>]Set[method, ["METHOD_FIRST_USER+"]Append[method ID]]
-		out <- [[reg]Lookup <<[new lookup]]Next ID <<[[method ID]+[1]]
-	}
-}
-
-Method ID@C Method Registry[reg,method:out,notfound]
-{
-	out,notfound <- [[reg]Lookup >>]Index[method]
-}
-
-Blueprint C Field Registry
-{
-	Lookup
-	Next ID
-}
-
-C Field Registry[:out]
-{
-	out <- [[Build["C Field Registry"]]Lookup <<[Dictionary[]]]Next ID<<[1]
-
-}
-
-Register Field@C Field Registry[reg,field:out]
-{
-	[[reg]Lookup >>]Index[field]
-	{
-		out <- reg
-	}{
-		field ID <- [reg]Next ID>>
-		new lookup <- [[reg]Lookup >>]Set[field, field ID]
-		out <- [[reg]Lookup <<[new lookup]]Next ID <<[[field ID]+[1]]
-	}
-}
-
-Field ID@C Field Registry[reg,field:out,notfound]
-{
-	out,notfound <- [[reg]Lookup >>]Index[field]
-}
-
-Blueprint C Type
-{
-	Name
-	Fields
-	Methods
-	Init
-	Copy
-	Cleanup
-	
-}
-
-C Type[name:out]
-{
-	out <- [[[[[[Build["C Type"]]Name <<[name]]Fields <<[()]]Methods <<[()]]Init <<["NULL"]]Copy <<["NULL"]]Cleanup <<["NULL"]
-}
-
-Add Field@C Type[ctype,name,type:out]
-{
-	out <- [ctype]Fields <<[ [[ctype]Fields >>]Append[ [[()]Append[name]]Append[type] ] ]
-}
-
-Add Method@C Type[ctype,name:out]
-{
-	out <- [ctype]Methods <<[ [[ctype]Methods >>]Append[name] ]
-}
-
-Register Methods@C Type[ctype,method reg:out]
-{
-	out <- Fold["Register Method", method reg, [ctype]Methods >>]
-}
-
-_Register Field C[reg,field:out]
-{
-	name <- [field]Index[0]
-	out <- [reg]Register Field[name]
-}
-
-Register Fields@C Type[ctype,field reg:out]
-{
-	out <- Fold["_Register Field C", field reg, [ctype]Fields >>]
-}
-
-Rhope Type to C[type:out,array]
-{
-	If[[Type Of[type]]=["Type Instance"]]
-	{
-		variant <- [type]Variant >>
-		If[[[type]Name >>] = ["Array"]]
-		{
-			[("Naked","Raw Pointer")]Find[variant]
-			{
-				/*
-				//Below code assumes that paramaterized types are implemented
-				pre param <- [[type]Params >>]Index[0] {}
-				{ pre param <- Type Instance["Any Type"] }
-				[[type]Params >>]Index[1]
-				{ param,param <- [pre param]Set Variant[~] }
-				{ param <- Val[pre param] }
-				child type <- Rhope Type to C[param]
-				If[[variant] = ["Naked"]]
-				{
-					out <- Val[child type]
-					array <- "[1]"
-				}{
-					out <- [child type]Append[" *"]
-					array <- ""
-				} */
-				out <- "void *"
-				array <- ""
-			}{
-				typename <- "Array"
-			}
-			primitive <- No
-		}{
-			,regulartype <- [("Naked","Raw Pointer")]Find[variant]
-			{
-				[("Int64","Int32","Int16","Int8")]Find[[type]Name >>]
-				{
-					primitive <- Yes
-					[[type]Name >>]Slice[3] {}
-					{ typename <- [["int"]Append[~]]Append["_t"] }
-				}{
-					,regulartype <- [("UInt64","UInt32","UInt16","UInt8")]Find[[type]Name >>]
-					{
-						primitive <- Yes
-						[[type]Name >>]Slice[4] {}
-						{ typename <- [["uint"]Append[~]]Append["_t"] }
-					}
-				}
-			}
-			
-			Val[regulartype]
-			{
-				typename <- [type]Name >>
-				primitive <- No
-			}
-		}
-	}{
-		typename <- type
-		param <- "Any Type"
-		variant <- "boxed"
-		primitive <- No
-	}
-	Val[typename]
-	{ array <- "" }
-	If[[typename] = ["Any Type"]]
-	{
-		out <- "struct object *"
-	}{
-		[("Naked","Raw Pointer")]Find[variant]
-		{
-			If[primitive]
-			{
-				prefix <- ""
-			}{
-				prefix <- "nt_"
-			}
-		}{
-			prefix <- "t_"
-		}
-		
-		If[[variant]=["Naked"]]
-		{
-			postfix <- ""
-		}{
-			postfix <- " *"
-		}
-	}
-	If[primitive]
-	{
-		escaped <- Val[typename]	
-	}{
-		escaped <- Escape Rhope Name[typename]
-	}
-	out <- [[prefix]Append[escaped]]Append[postfix]
-}
-
-_Type Def C Type[text,field:out]
-{
-	name <- [field]Index[0]
-	,postfix <- Rhope Type to C[[field]Index[1]]
-	{ type <- ["\n\t"]Append[~] }
-	
-	out <- [[[[text]Append[type]]Append[" "]]Append[[Escape Rhope Name[name]]Append[postfix]]]Append[";"]
-}
-
-Type Def@C Type[ctype:out]
-{
-	If[[[[ctype]Fields >>]Length] = [1]]
-	{
-		out <- [[[[_Type Def C Type["typedef struct {\n\tobject _SP_header;\n\t", [[ctype]Fields >>]Index[0]]]Append["\n} t_"]]Append[Escape Rhope Name[[ctype]Name >>]]]Append[";"]
-					]Append[ 
-						[[[["typedef "
-							]Append[Rhope Type to C[ [[[ctype]Fields >>]Index[0]]Index[1] ]]
-							]Append[" nt_"]
-							]Append[Escape Rhope Name[[ctype]Name >>]]
-							]Append[";"] ]
-	}{
-		//HACK!!!
-		If[[[ctype]Name >>]=["Blueprint"]]
-		{
-			out <- ""	
-		}{
-			[("Array","Boxed Array","Worker")]Find[[ctype]Name >>]
-			{ oend <- "\nMObject(" }
-			{ oend <- "\nObject(" } 
-			out <- [Fold["_Type Def C Type", "OBegin", [ctype]Fields >>]]Append[ [[oend]Append[Escape Rhope Name[[ctype]Name >>]]]Append[")"] ]
-		}
-	}
-}
-
-_Type Init C[type name,method reg,text,method:out]
-{
-	out <- [[text]Append[[["\n\tadd_method(bp, "]Append[ [method reg]Method ID[method] ]]Append[  [[", MethodName("]Append[Escape Rhope Name[method]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"]
-}
-
-_Type Init C Field[type name,field reg,text,field:out]
-{
-	fname <- [field]Index[0]
-	out <- [[[[text]Append[[["\n\tadd_getter(bp, "]Append[ [field reg]Field ID[fname] ]]Append[  [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" >>"]]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"]
-		]Append[[["\n\tadd_setter(bp, "]Append[ [field reg]Field ID[fname] ]]Append[  [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" <<"]]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"]
-}
-
-Type Init@C Type[ctype,id,method reg,field reg:out]
-{
-	[("Array","Boxed Array", "Worker")]Find[[ctype]Name >>]
-	{ size <- "-1" }
-	{ 
-		[("Int64","Int32","Int16","Int8")]Find[[ctype]Name >>]
-		{
-			[[ctype]Name >>]Slice[3] {}
-			{ typename <- [["int"]Append[~]]Append["_t"] }
-		}{
-			[("UInt64","UInt32","UInt16","UInt8")]Find[[ctype]Name >>]
-			{
-				[[ctype]Name >>]Slice[4] {}
-				{ typename <- [["uint"]Append[~]]Append["_t"] }
-			}{
-				If[[[ctype]Name >>]=["Blueprint"]]
-				{ typename <- "blueprint *" }
-				{ 
-					If[[[ctype]Name >>]=["Boolean"]]
-					{ typename <- "int32_t" }
-					{ typename <- ["nt_"]Append[Escape Rhope Name[[ctype]Name >>]] }
-				}
-			}
-		}
-		size <- [["sizeof("]Append[typename]]Append[")"] 
-	}
-	start <- [["\tbp = register_type_byid("
-		]Append[id]
-		]Append[
-			[[", "]Append[size]
-			]Append[
-				[", (special_func)"]Append[
-					[ 
-						[[[[Escape Rhope Name NU[[ctype]Init >>]
-						]Append[", (special_func)"]
-						]Append[Escape Rhope Name NU[[ctype]Copy >> ]]
-						]Append[", (special_func)"]
-						]Append[Escape Rhope Name NU[[ctype]Cleanup >>]]         
-					]Append[");"]]] ]
-	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
-{
-	Lookup
-	Definitions
-	Next ID
-}
-
-C Type Registry[:out]
-{
-	out <- [[[Build["C Type Registry"]]Lookup << [
-			[[[[[[[[[[[[[[[[[[[Dictionary[]
-			]Set["UInt8", "TYPE_UINT8"]			//1
-			]Set["UInt16", "TYPE_UINT16"]		//2
-			]Set["UInt32", "TYPE_UINT32"]		//3
-			]Set["UInt64", "TYPE_UINT64"]		//4
-			]Set["Int8", "TYPE_INT8"]			//5
-			]Set["Int16", "TYPE_INT16"]			//6
-			]Set["Int32", "TYPE_INT32"]			//7
-			]Set["Int64", "TYPE_INT64"]			//8
-			]Set["Boolean", "TYPE_BOOLEAN"]		//9
-			]Set["Float32", "TYPE_FLOAT32"]		//10
-			]Set["Float64", "TYPE_FLOAT64"]		//11
-			]Set["Real Number", "TYPE_FLOAT64"]	
-			]Set["Blueprint", "TYPE_BLUEPRINT"]	//12
-			]Set["Array", "TYPE_ARRAY"]			//13
-			]Set["Boxed Array", "TYPE_BOXEDARRAY"]//14
-			]Set["Worker", "TYPE_WORKER"]		//15
-			]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"]	//16
-			]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"]	//17
-			]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]]		//18
-		]Definitions << [Dictionary[]]
-		]Next ID <<[0]
-}
-
-_Type Defs C[text,def:out]
-{
-	out <- [[text]Append[[def]Type Def]]Append["\n\n"]
-}
-
-Type Defs@C Type Registry[reg:out]
-{
-	out <- Fold["_Type Defs C", "", [reg]Definitions >>]
-}
-
-_Type Inits C[reg,method reg,field reg,text,def,name:out]
-{
-	out <- [[text]Append[ [def]Type Init[[reg]Type ID[name], method reg, field reg] ]]Append["\n\n"]
-}
-
-Type Inits@C Type Registry[reg,method reg,field reg:out]
-{
-	out <- Fold[[[["_Type Inits C"]Set Input[0, reg]]Set Input[1, method reg]]Set Input[2, field reg], "", [reg]Definitions >>]
-}
-
-Register Type@C Type Registry[reg,def:out]
-{
-	name <- [def]Name >>
-	[[reg]Lookup >>]Index[name]
-	{
-		[[reg]Definitions >>]Index[name]
-		{
-			out <- reg
-		}{
-			out <- [reg]Definitions <<[[[reg]Definitions >>]Set[name, def]]
-		}
-	}{
-		out <- [[[reg]Lookup <<[ [[reg]Lookup >>]Set[name, ["TYPE_FIRST_USER+"]Append[[reg]Next ID >>]] ]
-			]Definitions <<[ [[reg]Definitions >>]Set[name, def] ]
-			]Next ID <<[ [[reg]Next ID >>]+[1] ]
-	}
-}
-
-Type ID@C Type Registry[reg,name:out,notfound]
-{
-	out <- [[reg]Lookup >>]Index[name] {}
-	{
-		,notfound <- If[[name]=["Any Type"]]
-		{ out <- "0" }
-	}
-}
-
-Simple Type?@C Type Registry[reg,name:yep,nope,notfound]
-{
-	,notfound <- [[reg]Definitions >>]Index[name]
-	{
-		yep,nope <- If[[[[~]Fields >>]Length] = [1]]
-	}
-}
-
-Defined?@C Type Registry[reg,name:yep,nope]
-{
-	yep,nope <- [[reg]Definitions >>]Index[name]
-}
-
-Blueprint C Function
-{
-	Name
-	Inputs
-	Outputs
-	Convention
-	Variables
-	Statements
-	Method Registry
-	Field Registry
-	Type Registry
-	Constants
-	Input Types
-	Output Types
-	Resume Index
-	Last NumParams
-}
-
-C Function[name,inputs,outputs,convention:out]
-{
-	out <- C Function With Registry[name,inputs,outputs,convention, C Method Registry[], C Field Registry[], C Type Registry[]]
-}
-
-C Function With Registry[name,inputs,outputs,convention,registry,field reg,type reg:out]
-{
-	out <- [[[[[[[[[[[[[[Build["C Function"]
-		]Name <<[name]
-		]Inputs <<[inputs]
-		]Outputs <<[outputs]
-		]Convention <<[convention]
-		]Variables <<[Dictionary[]]
-		]Statements <<[()]
-		]Method Registry <<[registry]
-		]Field Registry <<[field reg]
-		]Type Registry <<[type reg]
-		]Constants <<[Dictionary[]]
-		]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]
-{
-	out <- [func]Input Types <<[ [[func]Input Types >>]Set[input num, type] ]
-}
-
-Set Output Type@C Function[func,type,output num:out]
-{
-	out <- [func]Output Types <<[ [[func]Output Types >>]Set[output num, type] ]
-}
-
-Register Constant@C Function[func,name,constant:out]
-{
-	out <- [func]Constants <<[ [[func]Constants >>]Set[name, constant] ]
-}
-
-Allocate Var@C Function[func,name,type:out]
-{
-	out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ]
-}
-
-Add Statement@C Function[func,statement:out]
-{
-	out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ]
-}
-
-Add Raw Line@C Function[func,line:out]
-{
-	out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[line]Append["\n"]]] ]
-}
-
-Add Operator Statement@C Function[func,psource1,psource2,pdest,op:out]
-{
-	source1 <- [psource1]Make Op[func]
-	source2 <- [psource2]Make Op[func]
-	dest <- [pdest]Make Op[func]
-	out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]]
-}
-
-Add@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," + "]
-}
-
-Sub@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," - "]
-}
-
-Multiply@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," * "]
-}
-
-Divide@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," / "]
-}
-
-DoLShift@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," << "]
-}
-
-DoRShift@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," >> "]
-}
-
-CompLess@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," < "]
-}
-
-CompGreater@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," > "]
-}
-
-CompEqual@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," == "]
-}
-
-CompLessEqual@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," <= "]
-}
-
-CompGreaterEqual@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," >= "]
-}
-
-CompNotEqual@C Function[func,source1,source2,dest:out]
-{
-	out <- [func]Add Operator Statement[source1,source2,dest," != "]
-}
-
-Move@C Function[func,psource,pdest:out]
-{
-	source <- [psource]Make Op[func]
-	dest <- [pdest]Make Op[func]
-	out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]]
-}
-
-Do AddRef@C Function[func,psource,pdest:out]
-{
-    source <- [psource]Make Op[func] 
-    dest <- [pdest]Make Op[func]
-    out <- [func]Add Statement[[[[dest]Append[" = add_ref((object *)"]]Append[source]]Append[")"]]
-}
-
-AddRef No Dest@C Function[func,psource:out]
-{
-    source <- [psource]Make Op[func] 
-    out <- [func]Add Statement[[["add_ref((object *)"]Append[source]]Append[")"]]
-}
-
-Release@C Function[func,psource:out]
-{
-	source <- [psource]Make Op[func]
-	out <- [func]Add Statement[[["release_ref((object *)"]Append[source]]Append[")"]]
-}
-
-Set Null@C Function[func,pdest:out]
-{
-	dest <- [pdest]Make Op[func]
-	out <- [func]Add Statement[[dest]Append[" = NULL"]]
-}
-
-Lookup Constant@C Function[func,const,doaddref:out]
-{
-	var <- ["_const_"]Append[Escape Rhope Name[const]]
-	If[doaddref]
-	{
-		out <- [["add_ref("]Append[var]]Append[")"]
-	}{
-		out <- Val[var]
-	}
-}
-
-Field Result@C Function[func,var,field:out]
-{
-	as op <- [var]Make Op[func]
-	If[[Type Of[var]] = ["String"]]
-	{
-		[[func]Inputs >>]Find[var]
-		{
-			type <- [[func]Input Types >>]Index[~]
-		}{
-			type <- [[func]Variables >>]Index[var] {}
-			{ 
-				[[func]Outputs >>]Find[var]
-				{
-					type <- [[func]Output Types >>]Index[~]
-				}{
-					//Does it make sense for us to do this?
-					type <- Type Instance["Any Type"] 
-				}
-			}
-		}
-	}{
-		type <- Type Instance["Any Type"] 
-	}
-	If[[[func]Convention >>] = ["rhope"]]
-	{
-		If[[type] = ["Any Type"]]
-		{
-			rvar <- Val[as op]
-		}{
-			rvar <- [[[["(("]Append[ Rhope Type to C[type] ]]Append[")("]]Append[as op]]Append["))"]
-		}
-	}{
-		rvar <- Val[as op]
-	}
-
-	[[func]Type Registry >>]Simple Type?[[type]Name >>]
-	{ access <- "->" }
-	{ access <- "->payload." }
-	out <- [[rvar]Append[access]]Append[Escape Rhope Name[field]]
-}
-
-Read Field@C Function[func,var,field:out,result op]
-{
-	out <- func
-	result op <- Field Ref[var,field]
-}
-
-Write Field@C Function[func,var,field:out,result op]
-{
-	out <- func
-	result op <- Field Ref[var,field]
-}
-
-Set Field Null@C Function[func,var,field:out]
-{
-	out <- [func]Add Statement[ [[func]Field Result[var,field]]Append[" = NULL"] ]
-}
-
-Copy@C Function[func,pdest:out]
-{
-	dest <- [pdest]Make Op[func]
-	out <- [func]Add Statement[ [dest]Append[[[" = copy_object("]Append[dest]]Append[")"]] ]
-}
-
-Box@C Function[func,psource,pdest,type:out]
-{
-	dest <- [pdest]Make Op[func]
-	source <- [psource]Make Op[func]
-	out <- [func]Add Statement[ 
-		[[[[[dest
-		]Append[" = naked_to_boxed("]
-		]Append[ [[func]Type Registry >>]Type ID[[type]Name >>] ]
-		]Append[", &"]
-		]Append[source]
-		]Append[")"] ]
-}
-
-Unbox@C Function[func,psource,pdest:out]
-{
-	dest <- [pdest]Make Op[func]
-	source <- [psource]Make Op[func]
-	out <- [func]Add Statement[ 
-		[[[["boxed_to_naked("
-		]Append[source]
-		]Append[", &"]
-		]Append[dest]
-		]Append[")"] ]
-}
-
-Get Raw Pointer@C Function[func,psource,pdest:out]
-{
-	dest <- [pdest]Make Op[func]
-	source <- [psource]Make Op[func]
-	out <- [func]Add Statement[ [[[dest]Append[" = (void*)("]]Append[source]]Append[" + 1)"] ]
-}
-
-Array Raw Pointer@C Function[func,psource,pdest:out]
-{
-	dest <- [pdest]Make Op[func]
-	source <- [psource]Make Op[func]
-	out <- [func]Add Statement[ [[[dest]Append[" = ((char *)"]]Append[source]]Append[")+ sizeof(t_Array)"] ]
-}
-
-_Function Arg C[func,val,inputnum:out]
-{
-	out <- [func]Add Raw Line[
-		[[[["SetParam("
-		]Append[inputnum]
-		]Append[", "]
-		]Append[val]
-		]Append[")"]
-	]
-}
-
-_Val Function Arg C[func,val,inputnum,worker:out]
-{
-	out <- [func]Add Raw Line[
-		[[[[[["VCSetParam("
-		]Append[worker]
-		]Append[", "]
-		]Append[inputnum]
-		]Append[", "]
-		]Append[val]
-		]Append[")"]
-	]
-}
-
-Method Call@C Function[func,method,args:out]
-{
-	out <- [func]Call[method,args]
-}
-
-Val Call@C Function[func,to call,args:out]
-{
-	worker <- Make Op[Strip Addref[to call], func]
-	rargs <- Map[args, ["Make Op"]Set Input[1, func]]
-
-	If[[[func]Last NumParams >>] = [-1]]
-	{
-		prepped <- [[func]Add Raw Line[ 
-			[[[["VCPrepCall("
-				]Append[worker]
-				]Append[", "]
-				]Append[[rargs]Length]
-				]Append[")"] ]
-		]Last NumParams <<[[rargs]Length]
-	}{
-		prepped <- [[func]Add Raw Line[ 
-			[[[[[["VCRePrepCall("
-				]Append[worker]
-				]Append[", "]
-				]Append[[rargs]Length]
-				]Append[", "]
-				]Append[[func]Last NumParams >>]
-				]Append[")"] ]
-		]Last NumParams <<[[rargs]Length]
-	}
-	
-	out <- [[[[Fold[["_Val Function Arg C"]Set Input[3, worker], prepped, rargs]
-	]Add Raw Line[
-		[[[[[[[["ValCall("
-		]Append[worker]
-		]Append[", "]
-		]Append[[rargs]Length]
-		]Append[", "]
-		]Append[[func]Resume Index >>]
-		]Append[", "]
-		]Append[Escape Rhope Name[[func]Name >>]]
-		]Append[")"]]
-	]Add Raw Line["DISPATCH"]
-	]Add Raw Line[
-		[[[["ValCallPostlude("
-		]Append[[func]Resume Index >>]
-		]Append[", "]
-		]Append[Escape Rhope Name[[func]Name >>]]
-		]Append[")"]]
-	]Resume Index <<[ [[func]Resume Index >>]+[1] ]
-}
-
-Call@C Function[func,name,args:out]
-{
-	If[[name]=["Call@Worker"]]
-	{
-		//TODO: Handle case when user explicitly calls the fully qualified version, but the type of the first arg isn't Worker
-		out <- [func]Val Call[[args]Index[0], Tail[args,1]]
-	}{
-		If[[name]=["Call"]]
-		{
-			to call <- [args]Index[0]
-			last numparams <- [func]Last NumParams >>
-			out <- [[[[[[func]Add Raw Line[[["if (get_blueprint("]Append[Make Op[Strip Addref[to call], func]]]Append[")->type_id == TYPE_WORKER) {"]]
-			]Val Call[to call, Tail[args,1]]
-			]Add Raw Line["} else {"]
-			]Last NumParams <<[last numparams]
-			]Func Base["Call",args, "Call"]
-			]Add Raw Line["}"]
-		}{
-			out <- [func]Func Base[Escape Rhope Name[name],args, "Call"]
-		}
-	}
-}
-
-Func Base@C Function[func,tocall,args,type:out]
-{
-	Print[ [[func]Name >>]Append[ [": Func Base("]Append[tocall] ] ]
-	rargs <- Map[args, ["Make Op"]Set Input[1, func]]
-
-	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]
-		]Append[", "]
-		]Append[[rargs]Length]
-		]Append[", "]
-		]Append[[func]Resume Index >>]
-		]Append[", "]
-		]Append[Escape Rhope Name[[func]Name >>]]
-		]Append[")"]]
-	]Resume Index <<[ [[func]Resume Index >>]+[1] ]
-}
-
-Call Foreign@C Function[func,name,language,args,store result:out]
-{
-	rargs <- Map[args, ["Make Op"]Set Input[1, func]]
-	//Assume language = "C" for now
-	base <- [[[name]Append["("]]Append[ Join[rargs, ", "] ]]Append[")"]
-	,do store <- If[[Type Of[store result]]=["String"]]
-	{ 
-		,do store <- If[[store result]=[""]]
-		{ stmt <- Val[base] }
-	}
-	
-	Val[do store]
-	{ stmt <- [[Make Op[store result, func]]Append[" = "]]Append[base] }
-	out <- [func]Add Statement[stmt]
-}
-
-Get Field Call@C Function[func,field,source:out]
-{
-	out <- [func]Func Base[Escape Rhope Name[[field]Append[" >>"]], [()]Append[source], "Call"]
-}
-
-Set Field Call@C Function[func,field,object,value:out]
-{
-	out <- [func]Func Base[Escape Rhope Name[[field]Append[" <<"]], [[()]Append[object]]Append[value], "Call"]
-}
-
-Tail Method Call@C Function[func,method,args:out]
-{
-	out <- [func]Func Base[[[func]Method Registry >>]Method ID[method],args, "TMCall"]
-}
-
-Tail Call@C Function[func,name,args:out]
-{
-	out <- [func]Func Base[Escape Rhope Name[name],args, "TCall"]
-}
-
-Resolve@C Function[func,op:out]
-{
-	If[[[func]Convention >>] = ["rhope"]]
-	{
-		[[func]Inputs >>]Find[op]
-		{
-			out <- [["my_cdata->params["]Append[~]]Append["	]"]
-		}{
-			out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]Append[Escape Rhope Name[op]]
-		}
-	}{
-		out <- Escape Rhope Name[op]
-	}
-}
-
-Resolve Output@C Function[func,name:out]
-{
-	If[[[func]Convention >>] = ["rhope"]]
-	{
-		out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]Append[Escape Rhope Name[name]]
-	}{
-		out <- Escape Rhope Name[name]
-	} 
-}
-
-Instruction Stream@C Function[func:out]
-{
-	out <- [func]Statements <<[()]
-}
-
-_If C[func, statement:out]
-{
-	out <- [func]Statements <<[ [[func]Statements >>]Append[ ["\t"]Append[statement] ] ]
-}
-
-Do If@C Function[func,condition,stream:out]
-{
-	cond <- [condition]Make Op[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 >>]
-
-}
-
-Discard Outputs@C Function[func,first to discard:out]
-{
-	out <- [[[[[func
-		]Add Raw Line[[["for(idx = "]Append[first to discard]]Append["; idx < cdata->num_params; ++idx)"]]
-		]Add Raw Line["{"]
-		]Add Raw Line["	if (cdata->params[idx])"]
-		]Add Raw Line["		release_ref(cdata->params[idx]);"]
-		]Add Raw Line["}"]
-}
-
-Result Reference@C Function[func,output:out]
-{
-	out <- [["cdata->params["]Append[output]]Append["]"]
-}
-
-Checked Result Reference@C Function[func,output:out]
-{
-	out <- [[[["("]Append[output]]Append[" < cdata->num_params ? cdata->params["]]Append[output]]Append["] : NULL)"]
-}
-
-
-If Null Else@C Function[func,left,right:out]
-{
-	check <- [[Make Condition[left]]Strip Addref]Make Op[func]
-	l <- [left]Make Op[func]
-	r <- [right]Make Op[func]
-	out <- [[[[[["("
-		]Append[check]
-		]Append[" ? "]
-		]Append[l]
-		]Append[" : "]
-		]Append[r]
-		]Append[")"]
-}
-
-_Set Outputs C[string,inputname,inputnum,func:out]
-{
-	out <- [string]Append[[[ [ ["\tRet("]Append[inputnum] ]Append[ [[", lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]]Append[Escape Rhope Name[inputname]]]Append[")\n"]]
-}
-
-Set Outputs@C Function[func:out]
-{
-	If[[[func]Convention >>] = ["rhope"]]
-	{
-		out <- [[[Fold[["_Set Outputs C"]Set Input[3, func], "", [func]Outputs >>]]Append["\tNumRet("]]Append[[[func]Outputs >>]Length]]Append[")\n"]
-	}{
-		[[func]Outputs >>]Index[0]
-		{
-			out <- [["\treturn "]Append[Escape Rhope Name[~]]]Append[";\n"]
-		}{
-			out <- ""
-		}
-	}
-}
-_Output Defs C[string,varname,index,func:out]
-{
-	out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[[[func]Output Types >>]Index[index]]] ]]Append[[" "]Append[Escape Rhope Name[varname]]]]Append[";\n"]
-}
-_Var Defs C[string,type,varname:out]
-{
-	out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[type]] ]]Append[[" "]Append[Escape Rhope Name[varname]]]]Append[";\n"]
-}
-
-
-Definitions@C Function[func:out]
-{
-	Print[["Definitions@C Function: "]Append[[func]Name >>]]
-	{
-	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["} lt_"]]Append[Escape Rhope Name[[func]Name >>]]]Append[";\n"]
-	}{
-		localtype <- ""
-	}
-	
-	If[ [[func]Convention >>] = ["rhope"] ]
-	{
-		/* parts <- [[func]Name >>]Split["@"]
-		[parts]Index[1]
-		{
-			proto <- [[[["MethodDef("
-				]Append[Escape Rhope Name[[parts]Index[0]]]
-				]Append[", "]
-				]Append[Escape Rhope Name[~]]
-				]Append[")\n"]
-		}{
-			proto <- [["FuncDef("]Append[Escape Rhope Name[[func]Name >>]]]Append[")\n"]
-		} */
-		out <- Val[localtype]
-	}{
-		out <- [[func]Naked Proto]Append[";\n"]
-	}
-	}
-}
-
-_Proto Input[list,input,index,types:out]
-{
-	out <- [list]Append[ [[Rhope Type to C[[types]Index[index]]]Append[" "]]Append[Escape Rhope Name[input]] ]
-}
-
-Naked Proto@C Function[func:out]
-{
-	[[func]Output Types >>]Index[0]
-	{
-		outtype <- [Rhope Type to C[~]]Append[" "]
-	}{
-		outtype <- "void "
-	}
-	out <- [[[[outtype
-			]Append[ Escape Rhope Name NU[[func]Name >>]]
-			]Append["("]
-			]Append[ [Fold[["_Proto Input"]Set Input[3, [func]Input Types >>], (), [func]Inputs >>]]Join[", "] ]
-			]Append[")"]
-}
-
-Type Check@C Function[func,text,type,input num:out]
-{
-	If[[type] = ["Any Type"]]
-	{
-		out <- text
-	}{
-		out <- [text]Append[ [["\tParam("]Append[input num]]Append[ [[", "]Append[ [[func]Type Registry >>]Type ID[type] ]]Append[")"] ] ]
-	}
-}
-
-Check Param Type C[text,type,input num,func:out]
-{
-	If[[Type Of[type]] = ["String"]]
-	{
-		typename <- type
-	}{
-		typename <- [type]Name >>
-	}
-	If[[typename] = ["Any Type"]]
-	{
-		out <- text
-	}{
-		out <- [text]Append[[[["\tParam("]Append[input num]]Append[ [","]Append[ [[func]Type Registry >>]Type ID[typename] ] ]]Append[")\n"]]
-	}
-}
-
-Text@C Function[func:out]
-{	
-	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]
-		}
-		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("]
-				]Append[cname]
-				]Append[",\n\tNumParams "]
-				]Append[ [[func]Inputs >>]Length ]
-				]Append[")\n\n"]
-				]Append[param check]
-				]Append[ [[func]Statements >>]Join[""] ]
-				]Append["EndFuncNoLocals\n"]
-				]Append["DISPATCH"]
-		}{
-			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[")\n"]]
-				]Append["DISPATCH"]
-		}
-	}{
-		
-		out <- [[[
-				Fold[["_Output Defs C"]Set Input[3, func], 
-					Fold["_Var Defs C", [[func]Naked Proto]Append["\n{"], [func]Variables >>], [func]Outputs >>]
-			]Append[[[func]Statements >>]Join[""]]
-			]Append[[func]Set Outputs]
-			]Append["}"]
-	}
-}
-
-Blueprint C Program
-{
-	Functions
-	Method Registry
-	Field Registry
-	Type Registry
-	Libraries
-}
-
-C Program[:out]
-{
-	out <- [[[[[Build["C Program"]]Functions <<[Dictionary[]]]Method Registry <<[C Method Registry[]]]Type Registry <<[C Type Registry[]]]Field Registry <<[C Field Registry[]]]Libraries <<[Dictionary[]]
-}
-
-Link@C Program[program,language,library:out]
-{
-	If[[library] = ["runtime"]]
-	{
-		out <- program
-	}{
-		langlibs <- [[program]Libraries >>]Index[language] {}
-		{ langlibs <- Dictionary[] }
-		out <- [program]Libraries <<[ [[program]Libraries >>]Set[language, [langlibs]Set[library, Yes]] ]
-	}
-}
-
-Register Type@C Program[program,def:out]
-{
-	out <- [[[program]Type Registry <<[ [[program]Type Registry >>]Register Type[def] ]
-		]Method Registry <<[ [def]Register Methods[[program]Method Registry >>] ]
-		]Field Registry <<[ [def]Register Fields[[program]Field Registry >>] ]
-}
-
-Create Type@C Program[program,name:out]
-{
-	out <- C Type[name]
-}
-
-Create Function@C Program[program,name,inputs,outputs,convention:out]
-{
-	out <- C Function With Registry[name,inputs,outputs,convention, [program]Method Registry >>, [program]Field Registry >>, [program]Type Registry >>]
-}
-
-Store Function@C Program[program,func:out]
-{
-	out <- [program]Functions <<[ [[program]Functions >>]Set[ [func]Name >>, func] ]
-}
-
-Method?@C Program[program,funcname:is,isnot]
-{
-	is,isnot <- [[program]Method Registry >>]Method ID[funcname]
-}
-
-_Defs C Program[text,func:out]
-{
-	def <- [func]Definitions
-	If[[def]=[""]]
-	{
-		out <- text
-	}{
-		out <- [text]Append[[def]Append["\n\n"]]
-	}
-}
-
-_Text C Program[text,func,type reg:out]
-{
-	out <- [text]Append[[[ [func]Type Registry <<[type reg] ]Text]Append["\n\n"]]
-}
-
-Combine Consts[consts,func:out]
-{
-	out <- Combine[[func]Constants >>, consts]
-}
-
-_Consts C Program[text,value,name:out]
-{
-	out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ]
-}
-
-_Consts C Release[text,value,name:out]
-{
-	out <- [text]Append[ [["\trelease_ref(_const_"]Append[Escape Rhope Name[name]]]Append[");\n"] ]
-}
-
-_List Literal El[text,val,index,type reg:out]
-{
-	out <- [[[[text
-		]Append[", "]
-		]Append[index]
-		]Append[", "]
-		]Append[Const Construct C[val, type reg]]
-}
-
-Const Construct C[value,type reg:out]
-{
-	valtype <- Type Of[value]
-	[("Int32","Whole Number")]Find[valtype]
-	{
-		out <- [["make_Int32("]Append[value]]Append[")"]
-	}{
-		If[[valtype] = ["Type Instance"]]
-		{
-			//TODO: Support parametric types
-			typeid <- [type reg]Type ID[[value]Name >>]
-			out <- [["make_Blueprint("]Append[typeid]]Append[")"]
-		}{
-			If[[valtype] = ["Yes No"]]
-			{
-				If[value]
-				{
-					out <- "make_Bool(1)"
-				}{
-					out <- "make_Bool(0)"
-				}
-			}{
-				If[[valtype] = ["Machine Integer"]]
-				{
-					If[[value]Signed? >>]
-					{ s <- "I" }
-					{ s <- "UI" }
-					
-					out <- [[[[[["make_"
-						]Append[s]
-						]Append["nt"]
-						]Append[[value]Size >>]
-						]Append["("]
-						]Append[[value]Value >>]
-						]Append[")"]
-				}{
-					If[[valtype] = ["String"]]
-					{
-						out <- [["make_String(\""]Append[ [[[[value]Replace["\\", "\\\\"]]Replace["\n", "\\n"]]Replace["\r", "\\r"]]Replace["\"", "\\\""] ]]Append["\")"]
-					}{
-						If[[valtype]=["Worker Literal"]]
-						{
-							//TODO: Figure out how to fully support these in nested cases
-							//or workaround the problem higher up in the food chain
-							[[value]Args >>]Last
-							{ size <- [~]+[1] }
-							{ size <- "0" }
-							out <- [[[[[["make_Worker(FUNC_"
-									]Append[Escape Rhope Name[[value]Name >>]]
-									]Append[", "]
-									]Append[size]
-									]Append[", "]
-									]Append[Fold[["+"]Set Input[0, 1], 0, [value]Args >>]]
-									]Append[")"]
-						}{
-							If[[valtype]=["List"]]
-							{
-								out <- [Fold[["_List Literal El"]Set Input[3, type reg], ["make_List("]Append[[value]Length], value]]Append[")"]
-							}{
-								out <- "UnhandledLiteralType"
-							}
-						}
-					}
-				}
-			}
-		}
-			
-	}
-}
-
-_Set Worker Params C[text,param,num,type reg,name:out]
-{
-	out <- [text]Append[
-		[[[[[["\t((object **)(((t_Worker *)_const_"
-			]Append[name]
-			]Append[")+1))["]
-			]Append[num]
-			]Append["] = "]
-			]Append[Const Construct C[param, type reg]]
-			]Append[";\n"] ]
-}
-
-_Set Consts C Program[text,value,name,type reg:out]
-{
-	valtype <- Type Of[value]
-	[("String","Worker Literal","List")]Find[valtype]
-	{
-		out <- text
-	}{
-		Const Construct C[value,type reg]
-		{ out <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] }
-	}
-}
-
-_Set List Els[text,el,index,type reg:out]
-{
-	out <- [[text]Append[
-		[["\tinout[1] = "
-		]Append[Const Construct C[index,type reg]]
-		]Append[
-			[[";\n\tinout[2] = "
-			]Append[Const Construct C[el, type reg]]
-			]Append[";\n"]
-
-		]]]Append["\trhope(FUNC_Set, inout, 3, 3);\n"]
-}
-
-_Set Late Consts C[text,value,name,type reg:out]
-{
-	valtype <- Type Of[value]
-	[("String","Worker Literal","List")]Find[valtype]
-	{
-		If[[valtype]=["List"]]
-		{
-			out <- [Fold[["_Set List Els"]Set Input[3, type reg], [text]Append["\trhope(FUNC_List, inout, 0, 1);\n"], value]
-				]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = inout[0];\n"]]
-		}{
-			Const Construct C[value,type reg]
-			{ init <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] }
-		
-			If[[valtype]=["Worker Literal"]]
-			{
-				out <- Fold[[["_Set Worker Params C"]Set Input[3, type reg]]Set Input[4, Escape Rhope Name[name]], init, [value]Args >>]
-			}{
-				out <- Val[init]
-			}
-		}
-	}{
-		out <- text
-	}
-}
-
-_Dispatch Switch Sub[text, num, name:out]
-{
-	out <- [[[[[text
-		]Append["\tResumeEntry("]
-		]Append[num]
-		]Append[","]
-		]Append[name]
-		]Append[")\\\n"]
-}
-
-_Dispatch Switch[text,func,raw name:out]
-{
-	If[[[func]Convention >>] = ["rhope"]]
-	{
-		name <- Escape Rhope Name[raw name]
-		out <- [[text]Append[ [["\tDispatchEntry("]Append[name]]Append[")\\\n"] ]
-			]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[ [["\tDispatchEntry("]Append[name]]Append[")\\\n"] ]
-}
-
-_Dispatch Enum Sub[text, num, name:out]
-{
-	out <- [[[[[text
-		]Append["\tRES_"]
-		]Append[num]
-		]Append["_"]
-		]Append[name]
-		]Append[",\n"]
-}
-
-_Dispatch Enum[text,func,raw name:out]
-{
-	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
-	}
-}
-
-_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", 
-			[Fold["_Dispatch Enum Methods", "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n\tFUNC_ID,\n\tFUNC_BlueprintSP_FromSP_ID,\n"], 
-			[program]Functions >>]]
-		]Append["\tEND\n} funcids;\n\n"]
-		]Append["#define DispatchEntries \\\n"] 
-		]Append[Fold["_Dispatch Switch", 
-			[Fold["_Dispatch Switch Methods", "", all methods]]Append["\tDispatchEntry(Build)\\\n\tDispatchEntry(BlueprintSP_Of)\\\n\tDispatchEntry(ID)\\\n\tDispatchEntry(BlueprintSP_FromSP_ID)\\\n"], 
-			[program]Functions >>]]
-		]Append["\tEndEntry\n\n"]
-}
-
-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"]
-}
-
-Init Type Names[text,typeid,name,reg:out]
-{
-	[reg]Defined?[name]
-	{ out <- [text]Append[ [[[["\tregistered_types["]Append[typeid]]Append["]->name = "]]Append[Const Construct C[name, reg]]]Append[";\n"] ] }
-	{ out <- text }
-}
-
-Text@C Program[program:out]
-{
-	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\"
-#include \"func.h\"
-#include \"integer.h\"
-#include \"blueprint.h\"
-#include \"array.h\"
-#include \"worker.h\"
-#include \"bool.h\"
-#include <sys/time.h>\n\n"
-	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
-#ifdef ENABLE_PROFILING
-uint64_t profile_counts[END];
-uint64_t profile_nestedcounts[END];
-uint64_t profile_totals[END];
-uint64_t profile_selftotals[END];
-uint64_t profile_activationlevel[END];
-#endif
-
-int32_t rhope(uint32_t func, object ** params, uint16_t numparams, uint16_t callspace)
-{
-#ifdef ENABLE_PROFILING
-	struct timeval time;
-#endif
-	uint16_t resume,idx, vcparam_offset, last_vcparam;
-	context * ct;
-	calldata * cdata, *temp_cdata, *my_cdata;
-	DispatchVar
-	FuncDef(Build)
-	FuncDef(BlueprintSP_Of)
-	FuncDef(ID)
-	FuncDef(BlueprintSP_FromSP_ID)\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[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
-
-Func(ID, NumParams 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)
-EndFunc(ID)
-DISPATCH
-
-Func(BlueprintSP_FromSP_ID, NumParams 1)
-
-	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])
-		Ret(0, NULL)
-	} else {
-		release_ref(cdata->params[0]);	
-		Ret(0, new_object(TYPE_BLUEPRINT))
-		((t_Blueprint *)cdata->params[0])->bp = registered_types[lv_BlueprintSP_FromSP_ID->type];
-		Ret(1, NULL)
-	}
-	
-EndFunc(BlueprintSP_FromSP_ID)
-DISPATCH\n"]
-		]Append[Fold[["_Text C Program"]Set Input[2, [program]Type Registry >>], "", Filter[[program]Functions >>, "Native"]]]
-		]Append["
-DO_END:
-	for(idx = 0; idx < cdata->num_params; ++idx)	
-		params[idx] = cdata->params[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 -1;
-}
-
-#include \"builtin.c\"
-#include \"array.c\"
-#include \"worker.c\"
-
-int main(int argc, char **argv)
-{
-	blueprint * bp;
-	int numret,retval;
-	int idx,sidx;
-	object * inout[3];
-	int32_t *counts, string_type_id=0;
-	t_String ** live_strings;
-	char ** typenames;
-	t_Array * typename;
-	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[Fold[["Init Type Names"]Set Input[3, [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);"]
-		]Append[Fold["_Consts C Release", "", constants]]
-		]Append[
-	"
-	if (!numret)
-		retval = 0;
-	else if (numret < 0)
-		retval = numret;
-	else if (get_blueprint(inout[0])->type_id == TYPE_INT32)
-	{
-		retval = ((t_Int32 *)inout[0])->Num;
-		release_ref(inout[0]);
-	} else {
-		rhope(FUNC_If, inout, 1, 2);
-		if (inout[0])
-		{
-			retval = 0;
-			release_ref(inout[0]);
-		} else {
-			retval = 1;
-			release_ref(inout[1]);
-		}
-	}
-	typenames = malloc(sizeof(char *)*max_registered_type);
-	for(idx = 0; idx < max_registered_type; ++idx)
-	{
-		if(registered_types[idx])
-		{
-			typename = (t_Array *)( ((t_String *)registered_types[idx]->name)->payload.Buffer );
-			typenames[idx] = malloc(typename->payload.Length+1);
-			memcpy(typenames[idx], typename+1, typename->payload.Length);
-			typenames[idx][typename->payload.Length] = 0;
-			if(!strcmp(typenames[idx], \"String\"))
-				string_type_id = idx;
-			release_ref(registered_types[idx]->name);
-		} else {
-			typenames[idx] = NULL;
-		}
-	}
-		
-	print_mem_info(manager);
-	counts = malloc(sizeof(int32_t)*max_registered_type);
-	get_live_object_counts(manager, counts);
-	for(idx = 0; idx < max_registered_type; ++idx)
-	{
-		if(counts[idx])
-		{
-			printf(\"%d objects of type %s (%d)\\n\", counts[idx], typenames[idx], idx);
-			if(idx == string_type_id)
-			{
-				live_strings = malloc(sizeof(t_String *)*counts[idx]);
-				find_live_objects_oftype(manager, string_type_id, (void **)live_strings);
-				for(sidx = 0; sidx < counts[idx]; ++sidx)
-				{
-					printf(\"\t%d: \", sidx);
-					fwrite(((t_Array *)live_strings[sidx]->payload.Buffer)+1, 1, ((t_Array *)live_strings[sidx]->payload.Buffer)->payload.Length, stdout);
-					puts(\"\");
-				}
-			}
-		}
-	}
-	fflush(stdout);
-	
-#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
-	return retval;
-}\n\n"]
-
-}
-
-

--- a/compile_old.rhope	Wed Jul 27 21:06:57 2011 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-Import parser_old.rhope
-
-Main[args]
-{
-	fname <- [args]Index[1]
-	{
-		file <- <String@File[~]
-		,text <- [file]Get FString[[file]Length]
-		params <- New@Parser[]
-		Print[["Parsing "]Append[fname]]
-		Null[text, params, New@Parse Program[], 0]
-		{
-			Print["Parsing imports"]
-			Process Imports[~, params]
-			{
-				tree <- [~]Workers << [ Map[[~]Workers >>, ["Check Worker Literals"]Set Input[1, ~]] ]
-				{ Print["Compiling"] }
-			}
-			compiled <- [Tree to Program Native[tree]]Compile Program[C Program[]]
-			{ Print["Compiled program to backend"] }
-			outfile <- <String@File[ [fname]Append[".c"] ]
-			[outfile]Put String[ [compiled]Text ]
-			{ Print[["Wrote output to "]Append[ [fname]Append[".c"] ]] }
-		}
-	}{
-		REPL[New@Parser[]]
-	}
-}
-

--- a/number.rhope	Wed Jul 27 21:06:57 2011 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,210 +0,0 @@
-
-
-Compile Number Method[backend, op, type:out]
-{
-	name <- [[[op]Index[0]]Append["@"]]Append[type]
-	backend func <- [op]Index[1]
-	type inst <- Type Instance[type]
-	func <- [[[[backend]Create Function[name,("a","b"), ("out"), "rhope"]
-	]Set Input Type[type inst, 0]
-	]Set Input Type[type inst, 1]
-	]Set Output Type[type inst, 0]
-	
-	,ina <- [[func]Copy["a"]
-	]Read Field["a", "Num"]
-	{ ,inb <- [~]Read Field["b", "Num"]
-	{ ,outa <- [~]Write Field["a", "Num"]
-	{ after op <- [
-		[backend func]Do[ 
-				[
-					[
-						[
-							[()]Append[~]
-						]Append[ina]
-					]Append[inb]
-				]Append[outa] ]
-	]Index[0] }}}
-	
-	out <- [backend]Store Function[ [[after op]Move["a","out"]]Release["b"] ]
-	
-}
-
-Compile Number Comp Method[backend, op, type:out]
-{
-	name <- [ [ [op]Index[0] ]Append["@"] ]Append[type]
-	backend func <- [op]Index[1]
-	type inst <- Type Instance[type]
-	func <- [[[[[[ [backend]Create Function[name,("a","b"), ("out"), "rhope"]
-	]Set Input Type[type inst, 0]
-	]Set Input Type[type inst, 1]
-	]Set Output Type[Type Instance["Boolean"], 0]
-	]Register Constant["Blueprint_Boolean", Type Instance["Boolean"]]
-	]Call["Build", [()]Append[Constant["Blueprint_Boolean"]]]
-	]Move[Result[0], "out"]
-	
-	,ina <- [func]Read Field["a", "Num"]
-	{ ,inb <- [~]Read Field["b", "Num"]
-	{ ,outa <- [~]Write Field["out", "Val"]
-	{ after op <- [
-		[backend func]Do[ 
-				[
-					[
-						[
-							[()]Append[~]
-						]Append[ina]
-					]Append[inb]
-				]Append[outa] ]
-	]Index[0] }}}
-	
-	out <- [backend]Store Function[ [[after op]Release["a"]]Release["b"] ]
-	
-}
-
-Compile Conversion Method[backend,intype,outtype,prefix:out]
-{
-	func <- [[[[[[backend]Create Function[[prefix]Append[[[outtype]Append["@"]]Append[intype]], ("in"), ("out"), "rhope"]
-	]Set Input Type[Type Instance[intype], 0]
-	]Set Output Type[Type Instance[outtype], 0]
-	]Register Constant[["Blueprint_"]Append[outtype], Type Instance[outtype]]
-	]Call["Build", [()]Append[ Constant[["Blueprint_"]Append[outtype]] ]]
-	]Move[Result[0], "out"]
-
-	,src <- [func]Read Field["in", "Num"]
-	{ ,dst <- [~]Write Field["out", "Num"]
-	{ ffunc <- [[~]Move[src, dst]]Release["in"] }}
-
-	out <- [backend]Store Function[ffunc]
-}
-
-Compile Abs UInt Method[backend,type:out]
-{
-	outtype <- ["U"]Append[type]
-	func <- [[[[[[[[[backend]Create Function[["Abs UInt@"]Append[type], ("in"), ("out"), "rhope"]
-	]Set Input Type[Type Instance[type], 0]
-	]Set Output Type[Type Instance[["U"]Append[type]], 0]
-	]Register Constant[["Blueprint_"]Append[outtype], Type Instance[outtype]]
-	]Allocate Var["abs", Type Instance[type]]
-	]Call["Build", [()]Append[ Constant[["Blueprint_"]Append[outtype]] ]]
-	]Move[Result[0], "out"]
-	]Call["Abs", [()]Append["in"]]
-	]Move[Result[0], "abs"]
-	{ Print["After Call to Abs"] }
-
-	,src <- [func]Read Field["abs", "Num"]
-	{ ,dst <- [~]Write Field["out", "Num"]
-	{ ffunc <- [[~]Move[src, dst]]Release["abs"] }}
-
-	out <- [backend]Store Function[ffunc]
-}
-
-_Generate Number Methods[backend, type:out]
-{
-	opmap <- (("+", "Add"), ("-", "Sub"), ("*", "Multiply"), ("/", "Divide"), ("LShift", "DoLShift"), ("RShift", "DoRShift"))
-	compops <- (("<", "CompLess"), (">", "CompGreater"), ("=", "CompEqual"), ("<=", "CompLessEqual"), (">=", "CompGreaterEqual"), ("!=", "CompNotEqual"))
-	
-	Fold[["Compile Number Method"]Set Input[2, type], backend, opmap]
-	{ Fold[["Compile Number Comp Method"]Set Input[2, type], ~, compops]
-	{ Fold[[["Compile Conversion Method"]Set Input[1, type]]Set Input[3, ""], ~, Legal Conversions[type]]
-	{ 
-		almost <- Fold[[["Compile Conversion Method"]Set Input[1, type]]Set Input[3, "Trunc "], ~, Truncations[type]] 
-		If[[type]Starts With["I"]]
-		{
-			out <- Compile Abs UInt Method[almost,type]
-		}{
-			out <- Val[almost]
-		}
-	}}}
-}
-		
-Generate Number Methods[backend:out]
-{	
-	numtypes <- ("Int8","Int16","Int32","Int64","UInt8","UInt16","UInt32","UInt64")
-	
-	out <- Fold["_Generate Number Methods", backend, numtypes]
-}
-
-Register Number Method[program, method, type, outtype:out]
-{
-	name <- [[method]Append["@"]]Append[type]
-	out <- [[program]Register Worker[name, "rhope", 2, 1]
-	]Bind Worker[name, 
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("left","right")]
-		]Input Types <<[ [[()]Append[ Type Instance[type]]]Append[Type Instance[type]] ]
-		]Outputs <<[("out")]
-		]Output Types <<[ [()]Append[Type Instance[outtype]] ]
-		]Builtin? <<[Yes]
-	]
-}
-
-Register Conversion Method[program, intype, outtype,prefix:out]
-{
-	name <- [prefix]Append[[[outtype]Append["@"]]Append[intype]]
-	out <- [[program]Register Worker[name, "rhope", 1, 1]
-	]Bind Worker[name,
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("in")]
-		]Input Types <<[ [()]Append[Type Instance[intype]] ]
-		]Outputs <<[("out")]
-		]Output Types <<[ [()]Append[Type Instance[outtype]] ]
-		]Builtin? <<[Yes]
-	]
-}
-
-Legal Conversions[type:convs]
-{
-	bigger <- Filter[(16,32,64), [">"]Set Input[1, size]]
-        base convs <- Map[bigger, ["Append"]Set Input[0, "Int"]]
-        If[[type]Starts With["U"]]
-        {
-                [type]Slice[4] {}
-                { size <- <String@Whole Number[~] }
-                convs <- Concatenate[base convs, Map[bigger, ["Append"]Set Input[0, "UInt"]]]
-        }{
-                [type]Slice[3] {}
-                { size <- <String@Whole Number[~] }
-                convs <- Val[base convs]
-        }
-}
-
-Truncations[type:truncs]
-{
-	,u <- [type]Get DString["Int"]
-	{ size <- <String@Whole Number[~] }
-	truncs <- Map[Filter[(8,16,32), ["<"]Set Input[1, size]], ["Append"]Set Input[0, [u]Append["Int"]]]
-}
-
-_Register Number Methods[program,type:out]
-{
-	methods <- ("+", "-", "*", "/", "LShift", "RShift")
-	compmethods <- ("<", ">", "=", "<=", ">=", "!=")
-	register <- ["Register Number Method"]Set Input[2, type]
-	Fold[[register]Set Input[3, type], program, methods]
-	{ Fold[[register]Set Input[3, "Boolean"], ~, compmethods]
- 	{ Fold[[["Register Conversion Method"]Set Input[1, type]]Set Input[3, ""], ~, Legal Conversions[type]]
-	{ 
-		almost <- Fold[[["Register Conversion Method"]Set Input[1, type]]Set Input[3, "Trunc "], ~, Truncations[type]]
-		If[[type]Starts With["I"]]
-		{
-			name <- ["Abs UInt@"]Append[type]
-			out <- [[almost]Register Worker[name, "rhope", 1, 1]
-			]Bind Worker[name
-				[[[[[NWorker["rhope"]
-				]Inputs <<[("in")]
-				]Input Types <<[ [()]Append[Type Instance[type]] ]
-				]Outputs <<[("out")]
-				]Output Types <<[ [()]Append[Type Instance[["U"]Append[type]]] ]
-				]Builtin? <<[Yes]
-			]
-		}{
-			out <- Val[almost]
-		}
-	}}}
-}
-
-Register Number Methods[program:out]
-{
-	numtypes <- ("Int8","Int16","Int32","Int64","UInt8","UInt16","UInt32","UInt64")
-	out <- Fold["_Register Number Methods", program, numtypes]
-}
-

--- a/nworker.rhope	Wed Jul 27 21:06:57 2011 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1644 +0,0 @@
-Import extendlib.rhope
-Import cbackend.rhope
-Import number.rhope
-Import boolean.rhope
-
-Blueprint Condition Set
-{
-	Variables
-	Subsets
-	Condition Type
-}
-
-AndSet[:out]
-{
-	out <- [[[Build["Condition Set"]]Variables <<[Dictionary[]]]Subsets <<[Dictionary[]]]Condition Type <<["And"]
-}
-
-OrSet[:out]
-{
-	out <- [[[Build["Condition Set"]]Variables <<[Dictionary[]]]Subsets <<[Dictionary[]]]Condition Type <<["Or"]
-}
-
-To String@Condition Set[set:out]
-{
-	out <- [[[[[set]Condition Type >>
-	]Append["Set:\n\tVariables:\n\t\t"]
-	]Append[ Join[Keys[[set]Variables >>], "\n\t\t"] ]
-	]Append["\n\tSubsets:\n\t\t"]
-	]Append[ Join[Keys[[set]Subsets >>], "\n\t\t"] ]
-}
-
-Add Condition@Condition Set[set,cond:out]
-{
-	If[[Type Of[cond]] = ["Condition Set"]]
-	{
-		out <- [set]Subsets <<[ [[set]Subsets>>]Set[[cond]To String, cond] ]
-	}{
-		out <- [set]Variables <<[ [[set]Variables >>]Set[cond, Yes] ]
-	}
-}
-
-=@Condition Set[set1,set2:out]
-{
-	,out <- If[[[set1]Condition Type >>] = [[set2]Condition Type >>]]
-	{
-		,out <- If[[[set1]Variables >>] = [[set2]Variables >>]]
-		{
-			out,out <- If[[[set1]Subsets >>] = [[set2]Subsets >>]]
-		}
-	}
-}
-
-_For Backend Var[current,junk,variable,type:out]
-{
-	out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[variable] ]]Index[0]
-}
-
-_For Backend Subset[current,subset,type:out]
-{
-	[subset]For Backend
-	{
-		out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[~] ]]Index[0]
-	}{
-		out <- current
-	}
-}
-
-Empty?@Condition Set[set:not empty,empty]
-{
-	Print["Empty?@Condition Set"]
-	[[set]Variables >>]First
-	{
-		not empty <- Yes
-	}{
-		,empty <- [[set]Subsets >>]First Non-empty Set
-		{
-			not empty <- Yes
-		}
-	}
-}
-
-_First Non-empty Set[setlist,index:out,none]
-{
-	current <- [setlist]Index[index]
-	[[current]Variables >>]First
-	{
-		out <- index
-	}{
-		,trynext <- [[current]Subsets >>]First Non-empty Set
-		{
-			out <- index
-		}
-	}
-	Val[trynext]
-	{
-		,none <- [setlist]Next[index]
-		{
-			out,none <- _First Non-empty Set[setlist, ~]
-		}
-	}
-}
-
-First Non-empty Set[setlist:index,none]
-{
-	,none <- [setlist]First
-	{
-		index,none <- _First Non-empty Set[setlist,~]
-	}
-}
-
-For Backend@Condition Set[set:out,none]
-{
-	firstvar <- [[set]Variables >>]First
-	{
-		[[set]Variables >>]Next[~]
-		{
-			vars <- _Fold[[set]Variables >>, ~, firstvar, ["_For Backend Var"]Set Input[3, [set]Condition Type >>]]
-		}{
-			vars <- Val[firstvar]
-		}
-		out <- Fold[["_For Backend Subset"]Set Input[2, [set]Condition Type >>], vars, [set]Subsets >>]
-	}{
-		[[set]Subsets >>]First Non-empty Set
-		{
-			firstsub <- [[[set]Subsets >>]Index[~]]For Backend
-			[[set]Subsets >>]Next[~]
-			{
-				out <- _Fold[[set]Subsets >>, ~, firstsub, ["_For Backend Subset"]Set Input[2, [set]Condition Type >>]]
-			}{
-				out <- Val[firstsub]
-			}
-		}{
-			none <- Yes
-		}
-	}
-}
-
-Set@Range[range,index,val:out]
-{
-	out <- [[()]Concatenate[range]
-	]Set[index,val]
-}
-
-List of Lists[num:out]
-{
-	out <- Fold[["Append"]Set Input[1, ()],(), Range[0,num]]
-}
-
-Blueprint Worker Ref
-{
-	Name
-	Convention
-	Inputs
-	Min Inputs
-	Outputs
-	Min Outputs
-	Is Method?
-}
-
-Worker Ref[name,convention,inputs,outputs,ismethod?:out]
-{
-	out <- [[[[[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs]]Is Method? <<[ismethod?]]Min Inputs <<[inputs]]Min Outputs <<[outputs]
-}
-
-Blueprint Node Ref
-{
-	Index
-	IO Num
-}
-
-Node Ref[index,ionum:out]
-{
-	out <- [[Build["Node Ref"]]Index <<[index]]IO Num <<[ionum]
-}
-
-=@Node Ref[left,right:out]
-{
-	,out <- If[[[left]Index >>] = [[right]Index >>]]
-	{
-		out <- [[left]IO Num>>] = [[right]IO Num >>]
-	}
-}
-
-Blueprint NWorker Node
-{
-	Type
-	Data
-	Inputs
-	Min Inputs
-	Input Types
-	Outputs
-	Min Outputs
-	Output Types
-	Wires From
-	Wires To
-	Conditions
-}
-
-Wire To@NWorker Node[node,from,output,pre input:out]
-{
-	existing cons <- [[node]Wires To >>]Index[input] {}
-	{ existing cons <- () }
-	input <- [pre input]+[1]
-	out <- [node]Wires To <<[
-		[[node]Wires To >>]Set[input,
-			[existing cons]Append[Node Ref[from,output]]
-		]
-	]
-}
-
-Wire From@NWorker Node[node,to,input,output:out]
-{
-	existing cons <- [[node]Wires From >>]Index[output] {}
-	{ exist cons <- () }
-	out <- [node]Wires From <<[
-		[[node]Wires From >>]Set[output,
-			[existing cons]Append[Node Ref[to,input]]
-		]
-	]
-}
-
-_Has Input Types@NWorker Node[node,input num:does,does not]
-{
-	does <- If[[input num] > [[node]Inputs >>]] {}
-	{
-		,does not <- [[node]Input Types >>]Index[input num]
-		{
-			count <- [~]Index[1]
-			,does not <- If[[count] = [[[[node]Wires To >>]Index[input num]]Length]]
-			{
-				does,does not <- [node]_Has Input Types[[input num]+[1]]
-			}
-		}
-	}
-}
-
-Has Input Types?@NWorker Node[node:does,does not]
-{
-	If[[[[node]Inputs >>]Length] > [0]]
-	{
-		does,does not <- _Has Input Types[node,0]
-	}{
-		does <- Yes
-	}
-}
-
-_Dependency[dlist,ref:out]
-{
-	[dlist]Find[ref]
-	{
-		out <- dlist
-	}{
-		out <- [dlist]Append[ref]
-	}
-}
-
-Dependencies@NWorker Node[node:out]
-{
-	out <- Fold[["Fold"]Set Input[0, "_Dependency"], (), [node]Wires To >>]
-}
-
-
-NWorker Node[type,data,inputs,outputs:out]
-{
-	out <- [[[[[[[[[[[Build["NWorker Node"]
-		]Type <<[type]
-		]Data <<[data]
-		]Inputs <<[inputs]
-		]Min Inputs <<[inputs]
-		]Outputs <<[outputs]
-		]Min Outputs <<[outputs]
-		]Wires From <<[List of Lists[outputs]]
-		]Wires To <<[List of Lists[[inputs]+[1]]]
-		]Conditions <<[AndSet[]]
-		]Input Types <<[()]
-		]Output Types <<[()]
-}
-
-Blueprint NWorker
-{
-	Convention
-	Nodes
-	Inputs
-	Input Types
-	Outputs
-	Output Types
-	Uses
-	NodeResults
-	Free Temps
-	Name
-	Builtin?
-	Library
-}
-
-NWorker[convention:out]
-{
-	out <- [[[[[[[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]]Input Types <<[()]]Output Types <<[()]]Name <<["Anonymous"]]Builtin? <<[No]]Library << [""]
-}
-
-Add Node@NWorker[worker,type,data,inputs,outputs:out,node index]
-{
-	out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]]
-	node index <- [[worker]Nodes >>]Length
-}
-
-Add Full Node@NWorker[worker,type,data,inputs,min inputs,outputs,min outputs:out,node index]
-{
-	out <- [worker]Nodes <<[[[worker]Nodes >>]Append[ 
-		[[[NWorker Node[type,data,inputs,outputs]
-		]Min Inputs <<[min inputs]
-		]Min Outputs <<[min outputs]
-		]Wires To <<[List of Lists[[min inputs]+[1]]]
-	]]
-	node index <- [[worker]Nodes >>]Length
-}
-
-Propagate Type[nodelist,dest,prog,worker,type:out]
-{
-	node <- [nodelist]Index[[dest]Index >>]
-	
-	[[node]Input Types >>]Index[[dest]IO Num >>]
-	{
-		existing type <- [~]Index[0]
-		new count <- [[~]Index[1]]+[1]
-		If[[[existing type]Name >>] = [[type]Name >>]]
-		{
-			If[[[existing type]Variant >>] = [[type]Variant >>]]
-			{
-				If[[[existing type]Params >>] = [[type]Params >>]]
-				{
-					new type <- Val[existing type]
-				}{
-					new variant <- [existing type]Variant >>
-					new params <- ()
-				}
-			}{
-				new variant <- "Boxed"
-				If[[[existing type]Params >>] = [[type]Params >>]]
-				{
-					new params <- [existing type]Params >>
-				}{
-					new params <- ()
-				}
-			}
-			new type <- [[existing type]Set Variant[new variant]]Params <<[new params]
-		}{
-			new type <- Type Instance["Any Type"]
-		}
-	}{
-		new type <- Val[type]
-		new count <- 1
-	}
-	new node <- [node]Input Types <<[  		
-		[ [node]Input Types >> ]Set[ [dest]IO Num >>, [[()]Append[new type]]Append[new count] ]
-	]
-	out <- Infer Types Node[[nodelist]Set[[dest]Index >>, new node], new node, [dest]Index >>, prog, worker]
-}
-
-Propagate Types[nodelist,dests,output num,prog,worker,source node:out]
-{
-	out <- Fold[[[["Propagate Type"]Set Input[2, prog]]Set Input[3, worker]]Set Input[4, [[source node]Output Types >>]Index[output num]], nodelist, dests]
-}
-
-Infer Types Node[nodelist,node,index,prog,worker:out]
-{
-	If[[[node]Type >>] = ["const"]]
-	{
-		const type <- Type Of[[node]Data >>]
-		//Temporary hack
-		If[[const type] = ["Whole Number"]]
-		{
-			outtype <- Type Instance["Int32"]
-		}{
-			If[[const type] = ["Type Instance"]]
-			{
-				outtype <- Type Instance["Blueprint"]
-			}{
-				If[[const type] = ["Machine Integer"]]
-				{
-					If[[[node]Data >>]Signed? >>]
-					{ base <- "Int" }
-					{ base <- "UInt" }
-					
-					outtype <- Type Instance[[base]Append[ [[node]Data >>]Size >> ]]
-				}{
-					If[[const type] = ["Worker Literal"]]
-					{
-						outtype <- Type Instance["Worker"]
-					}{
-						outtype <- Type Instance[const type]
-					}
-				}
-			}
-		}
-		nextnode <- [node]Output Types <<[ [()]Append[outtype] ]
-		
-	}{
-		If[[[node]Type >>] = ["input"]]
-		{
-			nextnode <- [node]Output Types <<[ [()]Append[ [[worker]Input Types >>]Index[[node]Data >>] ] ]
-		}{
-			If[[[node]Type >>] = ["output"]]
-			{
-				out <- nodelist
-
-			}{
-				[node]Has Input Types?
-				{
-					If[[[node]Type >>] = ["setfield"]]
-					{
-						nextnode <- [node]Output Types <<[ [()]Append[ [[[node]Input Types >>]Index[0]]Index[0] ] ]
-					}{
-						If[[[node]Type >>] = ["getfield"]]
-						{
-							type <- [[[node]Input Types >>]Index[0]]Index[0]
-							If[[[type]Name >>] = ["Any Type"]]
-							{
-								outtype <- Val[type]
-							}{
-								outtype <- [prog]Find Field[[node]Data >>, type] {}
-								{
-									//TODO: Return errors rather than printing them
-									Print[
-										[[[[["Type "
-										]Append[[type]Name >>]
-										]Append[" does not have a field named "]
-										]Append[[node]Data >>]
-										]Append[" in worker "]
-										]Append[worker name]]
-								}
-							}
-							nextnode <- [node]Output Types <<[ [()]Append[outtype] ]
-						}{
-							worker name <- [[node]Data >>]Name >>
-							[prog]Is Method?[worker name]
-							{
-								first arg type <- [[[node]Input Types >>]Index[0]]Index[0]
-								If[[[first arg type]Name >>] = ["Any Type"]]
-								{
-									outtypes <- Fold[["Append"]Set Input[1, Type Instance["Any Type"]], (), Range[0, [node]Inputs >>]]
-								}{
-									worker def <- [prog]Find Method[worker name, first arg type] {}
-									{
-										//TODO: Return errors instead of printing them
-										Print[
-											[[[[["Type "
-											]Append[[first arg type]Name >>]
-											]Append[" does not support method "]
-											]Append[worker name]
-											]Append[" in worker "]
-											]Append[ [worker]Name >> ]]
-									}
-								}
-							}{
-								worker def <- [prog]Find Worker Def[worker name]
-							}
-							outtypes <- [worker def]Output Types >>
-							nextnode <- [node]Output Types <<[ outtypes ]
-						}
-					}
-				}{
-					out <- nodelist
-				}
-			}
-		}
-	}
-	
-	Val[nextnode]
-	{
-		nextlist <- [nodelist]Set[index, nextnode]
-		out <- Fold[[[["Propagate Types"]Set Input[3, prog]]Set Input[4, worker]]Set Input[5, nextnode], nodelist, [nextnode]Wires From >>]
-	}
-}
-
-Infer Types@NWorker[worker,prog:out]
-{
-	out <- [worker]Nodes <<[Fold[[["Infer Types Node"]Set Input[3, prog]]Set Input[4, worker], [worker]Nodes >>, [worker]Nodes >>]]
-}
-
-Add Worker Call@NWorker[worker,tocall:out,node index]
-{
-	out, node index <- [worker]Add Full Node["call",tocall,[tocall]Inputs >>, [tocall]Min Inputs >>,[tocall]Outputs >>, [tocall]Min Outputs >>]
-}
-
-Add Constant@NWorker[worker,constant:out,node index]
-{
-	out, node index <- [worker]Add Node["const",constant,0,1]
-}
-
-Add Input@NWorker[worker,name,number:out,node index]
-{
-	out,node index <- [worker]Add Typed Input[name,number,Type Instance["Any Type"]]
-}
-
-Add Anon Input@NWorker[worker,number:out]
-{
-	If[[number]>[Length[[worker]Inputs >>]]]
-	{
-		prepped <- [worker]Add Anon Input[[number]-[1]]
-	}{
-		prepped <- Val[worker]
-	}
-	out <- out <- [[prepped]Inputs <<[[[prepped]Inputs >>]Set[number,[" unnamed"]Append[number]]]
-		]Input Types <<[[[prepped]Input Types >>]Set[number,Type Instance["Any Type"]]]
-}
-
-Add Typed Input@NWorker[worker,name,number,type:out,node index]
-{
-	If[[number]>[Length[[worker]Inputs >>]]]
-	{
-		prepped <- [worker]Add Anon Input[[number]-[1]]
-	}{
-		prepped <- Val[worker]
-	}
-	,node index <- [prepped]Add Node["input",number,0,1]
-	{ 
-		out <- [[~]Inputs <<[[[~]Inputs >>]Set[number,name]]
-		]Input Types <<[[[~]Input Types >>]Set[number,type]]
-	}
-}
-
-Add Output@NWorker[worker,name,number:out,node index]
-{
-	out,node index <- [worker]Add Typed Output[name,number,Type Instance["Any Type"]]
-}
-
-Add Typed Output@NWorker[worker,name,number,type:out,node index]
-{
-	,node index <- [worker]Add Node["output",number,1,0]
-	{ 
-		out <- [[~]Outputs <<[[[~]Outputs >>]Set[number,name]]
-		]Output Types <<[[[~]Output Types >>]Set[number,type]]
-	}
-}
-
-Add Object Get@NWorker[worker,fieldname:out,node index]
-{
-	out, node index <- [worker]Add Node["getfield",fieldname,1,1]
-}
-
-Add Object Set@NWorker[worker,fieldname:out,node index]
-{
-	out, node index <- [worker]Add Node["setfield",fieldname,2,1]
-}
-
-Add Wire@NWorker[worker,from,output,to,input:out]
-{
-	fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output]
-	tow <- [[[worker]Nodes >>]Index[to]]Wire To[from,output,input]
-	nodes <- [[[worker]Nodes >>]Set[from, fromw]]Set[to, tow]
-	out <- [worker]Nodes <<[nodes]
-}
-
-Uses@NWorker[worker,uses:out]
-{
-	out <- [worker]Uses <<[uses]
-}
-
-_No Dependencies[list,node,index:out]
-{
-	[[node]Wires To>>]Index[1]
-	{
-		out <- Val[list]
-	}{
-		[[[node]Wires To>>]Index[0]]First
-		{
-			out <- Val[list]
-		}{
-			out <- [list]Append[index]
-		}
-	}
-}
-
-No Dependencies@NWorker[worker:out]
-{
-	out <- Fold["_No Dependencies", (), [worker]Nodes >>]
-}
-
-_Collect Dests[candidates,wire:out]
-{
-	out <- [candidates]Set[[wire]Index >>, Yes]
-}
-
-Collect Dests@NWorker[worker,candidates,node index:out]
-{
-	out <- Fold[["Fold"]Set Input[0, "_Collect Dests"], candidates, [[[worker]Nodes >>]Index[node index]]Wires From >>]
-}
-
-Check Dependency@NWorker[worker,nodes,wires,wire index:met?]
-{
-	ref <- [wires]Index[wire index]
-	[nodes]Find[[ref]Index >>]
-	{
-		[wires]Next[wire index]
-		{
-			met? <- [worker]Check Dependency[nodes,wires,~]
-		}{
-			met? <- Yes
-		}
-	}{
-		met? <- No
-	}
-}
-_Check Dependencies@NWorker[worker,nodes,inputs,input index:met?]
-{
-	wires <- [inputs]Index[input index]
-	[wires]First
-	{
-		current met? <- [worker]Check Dependency[nodes, wires, ~]
-	}{
-		current met? <- Yes
-	}
-	If[current met?]
-	{
-		[inputs]Next[input index]
-		{
-			met? <- [worker]_Check Dependencies[nodes,inputs,~]
-		}{
-			met? <- Yes
-		}
-	}{
-		met? <- No
-	}
-}
-
-Check Dependencies@NWorker[worker,nodes,candidate:met?]
-{
-	inputs <- [[[worker]Nodes >>]Index[candidate]]Wires To >>
-	[inputs]First
-	{
-		met? <- [worker]_Check Dependencies[nodes, inputs, ~]
-	}{
-		met? <- Yes
-	}
-}
-
-Dependants@NWorker[worker,direct nodes,nodes:out]
-{
-	candidates <- Keys[Fold[["Collect Dests"]Set Input[0,worker], (), direct nodes]]
-	out <- Filter[candidates, [["Check Dependencies"]Set Input[0, worker]]Set Input[1, nodes]]
-}
-
-_Dependency Groups@NWorker[worker,last,all,grouped:out]
-{
-	current <- [worker]Dependants[last,all]
-	[current]First
-	{
-		out <- [worker]_Dependency Groups[current, [all]Concatenate[current], [grouped]Append[current]]
-	}{
-		out <- grouped
-	}
-}
-Dependency Groups@NWorker[worker:out]
-{
-	no deps <- [worker]No Dependencies
-	out <- [worker]_Dependency Groups[no deps, no deps, [()]Append[no deps]]
-}
-
-Const Name[val,node index,worker name:out]
-{
-	If[[Type Of[val]] = ["Type Instance"]]
-	{
-		//TODO: Support parametric types
-		datstring <- [val]Name >>
-	}{
-		If[[Type Of[val]] = ["Machine Integer"]]
-		{
-			If[[val]Signed? >>]
-			{ s <- "i" }
-			{ s <- "u" }
-			datstring <- [[[val]Value >>]Append[s]]Append[[val]Size >>]
-		}{
-			If[[Type Of[val]] = ["Worker Literal"]]
-			{
-				If[[[[val]Args >>]Length] > [0]]
-				{
-					datstring <- [[["Arg "]Append[node index]]Append[" "]]Append[worker name]
-				}{
-					datstring <- [val]Name >>
-				}
-			}{
-				If[[Type Of[val]] = ["List"]]
-				{
-					If[[[val]Length] > [0]]
-					{
-						datstring <- [[["Arg "]Append[node index]]Append[" "]]Append[worker name]
-					}{
-						datstring <- "Empty"
-					}
-				}{
-					datstring <- val
-				}
-			}
-		}
-	}
-	out <- [[Type Of[val]]Append["_"]]Append[datstring]
-}
-
-Format Input@NWorker[worker,noderef:out]
-{
-	node <- [[worker]Nodes >>]Index[[noderef]Index >>]
-	
-	[("call","getfield","setfield")]Find[[node]Type >>]
-	{
-		maybe addref <- [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>]
-	}{
-		conditions <- [node]Conditions >>
-		
-		If[[[node]Type >>] = ["input"]]
-		{
-			input name <- [[worker]Inputs >>]Index[ [node]Data >> ]
-			[conditions]For Backend
-			{
-				out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ]
-			}{
-				out <- AddRef[input name] 
-			}
-		}{
-			If[[[node]Type >>] = ["const"]]
-			{
-				[conditions]For Backend
-				{
-					out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ]
-				}{
-					out <- Constant[Const Name[[node]Data >>, [noderef]Index >>, [worker]Name >>]]
-				}
-			}
-		}
-	}
-
-	Val[maybe addref]
-	{
-		If[[Length[[[node]Wires From >>]Index[[noderef]IO Num >>]]] > [1]]
-		{
-			out <- AddRef[maybe addref]
-		}{
-			out <- Val[maybe addref]
-		}
-	}
-}
-
-Collect Input@NWorker[worker,nodeinput:out]
-{
-	inputchoices <- Map[nodeinput, ["Format Input"]Set Input[0, worker]]
-
-	[inputchoices]First
-	{
-		first <- [inputchoices]Index[~]
-		[inputchoices]Next[~]
-		{
-			out <- _Fold[inputchoices, ~, first, "OrValue"]
-		}{
-			out <- Val[first]
-		}
-	}{
-		out <- "Missing"
-	}
-}
-
-Collect Inputs@NWorker[worker,node:out]
-{
-	out <- Map[Tail[[node]Wires To>>, 1], ["Collect Input"]Set Input[0, worker]]
-}
-
-Collect Input Condition@NWorker[worker,set,noderef:out]
-{
-	node <- [[worker]Nodes >>]Index[ [noderef]Index >> ]
-	If[[[node]Outputs >>] > [1]]
-	{
-		out <- [set]Add Condition[ [["__result_"]Append[[noderef]Index >>]]Append[["_"]Append[[noderef]IO Num >>]] ]
-	}{
-		out <- [set]Add Condition[[node]Conditions >>]
-	}
-}
-
-Collect Condition@NWorker[worker,set,nodeinput:out]
-{
-	out <- [set]Add Condition[Fold[["Collect Input Condition"]Set Input[0, worker], OrSet[], nodeinput]]
-}
-
-Collect Conditions@NWorker[worker,node:out]
-{
-	out <- Fold[["Collect Condition"]Set Input[0, worker], AndSet[], [node]Wires To>>]
-}
-
-Save Result[func,num,node index:out]
-{
-	out var <- [[["__result_"]Append[node index]]Append["_"]]Append[num]
-	/*out <- [[func]Allocate Var[out var, "Any Type"]
-		]Move[Result[num], out var]
-	*/
-	out <- [func]Move[Result[num], out var]	
-}
-
-Save Maybe Result[func,num,node index:out]
-{
-	out var <- [[["__result_"]Append[node index]]Append["_"]]Append[num]
-	out <- [func]Move[Check Result[num], out var]
-}
-
-Max Used Output[node,cur:out]
-{
-	If[[cur] < [0]]
-	{
-		out <- cur
-	}{
-		[[[node]Wires From >>]Index[cur]]Index[0]
-		{
-			out <- cur
-		}{
-			out <- Max Used Output[node, [cur]-[1]]
-		}
-	}
-}
-
-Compile Call Node[node,program,func,inputs,node index:out]
-{
-	If[[[node]Type >>] = ["getfield"]]
-	{
-		with call <- [func]Get Field Call[[node]Data >>, [inputs]Index[0]]
-		save outs <- [node]Outputs >>
-		out <- Val[after save]
-	}{
-		If[[[node]Type >>] = ["setfield"]]
-		{
-			with call <- [func]Set Field Call[[node]Data >>, [inputs]Index[0], [inputs]Index[1]]
-			save outs <- [node]Outputs >>
-			out <- Val[after save]
-		}{
-			[program]Method?[[[node]Data >>]Name >>]
-			{
-				with call <- [func]Method Call[[[node]Data >>]Name >>, inputs]
-			}{
-				with call <- [func]Call[[[node]Data >>]Name >>, inputs]
-			}
-			first unused <- [Max Used Output[node, [[node]Outputs >>]-[1]]]+[1]
-			If[[first unused] > [[node]Min Outputs >>]]
-			{
-				save outs <- [node]Min Outputs >>
-				after maybe <- Fold[["Save Maybe Result"]Set Input[2, node index], after save, Range[save outs, first unused]]
-			}{
-				save outs <- Val[first unused]
-				after maybe <- Val[after save]
-			}
-			If[[first unused] < [[node]Outputs >>]]
-			{
-				out <- [after maybe]Discard Outputs[first unused]
-			}{
-				out <- Val[after maybe]
-			}
-		}
-	}
-	after save <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, save outs]]
-}
-
-Compile Node@NWorker[worker,program,func,nodes,current:out,out worker]
-{
-	node index <- [nodes]Index[current]
-	node <- [[worker]Nodes >>]Index[node index]
-	conditions <- [node]Conditions >>
-	[("call","getfield","setfield")]Find[[node]Type >>]
-	{
-		inputs <- [worker]Collect Inputs[node]
-		[conditions]For Backend
-		{
-			stream <- [func]Instruction Stream
-			nfunc <- [func]Do If[~, nstream]
-		}{
-			stream <- Val[func]
-			nfunc <- Val[nstream]
-		}
-		nstream <- Compile Call Node[node, program, stream, inputs, node index]
-	}{
-		If[[[node]Type >>] = ["output"]]
-		{
-			inputs <- [worker]Collect Inputs[node]
-			[conditions]For Backend
-			{
-				stream <- [func]Instruction Stream
-				nfunc <- [func]Do If[~, nstream]
-			}{
-				stream <- Val[func]
-				nfunc <- Val[nstream]
-			}
-			nstream <- [stream]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ]
-		}{
-			If[[[node]Type >>] = ["const"]]
-			{
-				constname <- Const Name[[node]Data >>, node index, [worker]Name >>]
-				withconst <- [func]Register Constant[constname, [node]Data >>]
-				[conditions]For Backend
-				{
-					stream <- [[withconst]Instruction Stream
-						]Move[Strip Addref[Constant[constname]], [[["__result_"]Append[node index]]Append["_"]]Append[0]]
-					nfunc <- [withconst]Do If[~, stream]
-				}{
-					nfunc <- Val[withconst]
-				}
-			}{
-				[conditions]For Backend
-				{
-					input name <- [[worker]Inputs >>]Index[ [node]Data >> ]
-					stream <- [[func]Instruction Stream
-						]Move[input name, [[["__result_"]Append[node index]]Append["_"]]Append[0]]
-					nfunc <- [func]Do If[~, stream]
-				}{
-					nfunc <- Val[func]
-				}
-			}
-			
-		}
-	}
-	[nodes]Next[current]
-	{
-		out,out worker <- [worker]Compile Node[program,nfunc,nodes,~]
-	}{
-		out <- Val[nfunc]
-		out worker <- Val[worker]
-	}
-}
-
-Save Node Conditions@NWorker[worker,node index:out]
-{
-	node <- [[worker]Nodes >>]Index[node index]
-	conditions <- [worker]Collect Conditions[node]
-	out <- [worker]Nodes <<[ [[worker]Nodes >>]Set[node index, [node]Conditions <<[conditions]] ]
-	
-}
-
-Save Group Conditions@NWorker[worker, groups,current:out]
-{
-	nodes <- [groups]Index[current]
-	nworker <- Fold["Save Node Conditions", worker, nodes]
-
-	[groups]Next[current]
-	{
-		out <- [nworker]Save Group Conditions[groups,~]
-	}{
-		out <- Val[nworker]
-	}
-}
-
-Compile Group@NWorker[worker,program,func,groups,current:out,out worker]
-{
-	nodes <- [groups]Index[current]
-	[nodes]First
-	{
-		nfunc,nworker <- [worker]Compile Node[program,func,nodes,~]
-	}{
-		nfunc <- Val[func]
-		nworker <- Val[worker]
-	}
-	[groups]Next[current]
-	{
-		out,out worker <- [nworker]Compile Group[program,nfunc,groups,~]
-	}{
-		out <- Val[nfunc]
-		out worker <- Val[nworker]
-	}
-}
-
-Release Var@NWorker[worker,func,name:out]
-{
-	//__result_index_ionum
-	parts <- [name]Split["_"]
-	index <- <String@Whole Number[ [parts]Index[3] ]
-	io num <- <String@Whole Number[ [parts]Index[4] ]
-	node <- [[worker]Nodes >>]Index[index]
-	dests <- [[node]Wires From >>]Index[io num] {}
-	{ 
-		Print["oops"]
-		{ Pretty Print[node, ""] 
-		{ Pretty Print[parts, ""]}} }
-	,normal <- If[[[dests]Length] = [1]]
-	{	
-		dest ionum <- [[dests]Index[0]]IO Num >>
-		If[[[[dests]Index[0]]IO Num >>]=[-1]]
-		{
-			normal <- Yes
-		}{
-			dest index <- [[dests]Index[0]]Index >>
-			dest node <- [[worker]Nodes >>]Index[dest index]
-		
-			[[dest node]Conditions >>]For Backend
-			{
-				out <- [func]Do If[AndCond[NotCond[~], name],  [[func]Instruction Stream]Release[name]]
-			}{
-				out <- func
-			}
-		}
-	}
-	
-	Val[normal]
-	{
-		do if <- If[[[node]Outputs >>] > [1]] {}
-		{
-			do if <- [[node]Conditions >>]Empty? {}
-			{
-				out <- [func]Release[name]
-			}
-		}
-	
-		Val[do if]
-		{
-			stream <- [[func]Instruction Stream]Release[name]
-			out <- [func]Do If[name, stream]
-		}
-	}
-}
-
-Result Var[vars,io num,index:out]
-{
-	out <- [vars]Append[[[["__result_"]Append[index]]Append["_"]]Append[io num]]
-}
-
-Node Result Vars[vars,node,index:out]
-{
-	[("call","getfield","setfield")]Find[[node]Type >>]
-	{
-		If[[[node]Type >>]=["call"]]
-		{
-			save outs <- [Max Used Output[node, [[node]Outputs >>]-[1]]]+[1]
-		}{
-			save outs <- [node]Outputs >>
-		}
-		out <- Fold[["Result Var"]Set Input[2, index], vars, Range[0, save outs]]
-	}{
-		out <- vars
-	}
-}
-
-Result Vars@NWorker[worker:out]
-{
-	out <- Fold["Node Result Vars", (), [worker]Nodes >>]
-}
-
-_No Release[vars,node,index,worker:out]
-{
-	[("const","input")]Find[[node]Type >>]
-	{
-		[[node]Conditions >>]For Backend
-		{
-			out <- Result Var[vars, 0, index]
-		}{	
-			out <- vars
-		}
-	}{
-		out <- vars
-	}
-}
-
-No Release Results@NWorker[worker:out]
-{
-	out <- Fold[["_No Release"]Set Input[3, worker], (), [worker]Nodes >>]
-}
-
-Make Basic Type[type:out]
-{
-	out <- [Type Instance[[type]Name >>]]Params <<[ [type]Params >> ]
-}
-
-FInputs[ifunc, input type, index, inputs:out]
-{	
-	func <- [ifunc]Set Input Type[Make Basic Type[input type], index]
-	name <- [inputs]Index[index]
-	If[[[input type]Variant >>] = ["Naked"]]
-	{
-		
-		naked <- [" naked"]Append[name]
-		
-		out <- [[[func]Allocate Var[naked, input type]
-		]Unbox[name, naked]
-		]Release[name]
-	}{
-		If[[input type]Mutable? >>]
-		{
-			name <- [inputs]Index[index]
-			copied <- [func]Copy[name, name]
-			
-		}{
-			copied <- Val[func]
-		}
-		If[[[input type]Variant >>] = ["Raw Pointer"]]
-		{
-			raw <- [" raw"]Append[name]
-			If[[[input type]Name >>]=["Array"]]
-			{
-				
-				out <- [[copied]Allocate Var[raw, input type]
-				]Array Raw Pointer[name, raw]
-			}{
-				out <- [[copied]Allocate Var[raw, input type]
-				]Get Raw Pointer[name, raw]
-			}
-		}{
-			out <- Val[copied]
-		}
-	}
-}
-
-Release Raw Inputs[func,input type,index,inputs,outputs:out]
-{
-	If[[[input type]Variant >>] = ["Raw Pointer"]]
-	{
-		name <- [inputs]Index[index]
-		If[[input type]Mutable? >>]
-		{
-			[outputs]Find[[inputs]Index[index]]
-			{
-				out <- func
-			}{
-				out <- [func]Release[name]	
-			}
-		}{
-			out <- [func]Release[name]
-		}
-	}{
-		out <- func
-	}
-}
-
-FParams[input:out]
-{
-	iname <- [input]Index[0]
-	type <- [input]Index[1]
-	If[[[type]Variant >>] = ["Naked"]]
-	{ out <- [" naked"]Append[iname] }
-	{ 
-		If[[[type]Variant >>] = ["Raw Pointer"]]
-		{ out <- [" raw"]Append[iname] }
-		{ out <- Val[iname] }
-	}
-}
-_Return Param[outputs, inputs, input types, index:out,none]
-{
-	output <- [outputs]Index[index]
-	[inputs]Find[output]
-	{
-		If[[[input types]Index[~]]Mutable? >>]	
-		{
-			,none <- [outputs]Next[index]
-			{
-				out,none <- _Return Param[outputs, inputs, input types, ~]
-			}
-		} { 
-			out <- index
-		}
-	}{
-		out <- index
-	}
-}
-
-Return Param[outputs, inputs, input types:out,none]
-{
-	,none <- [outputs]First
-	{ out,none <- _Return Param[outputs, inputs, input types, ~] }
-	
-}
-
-Save Foreign Result[func, output, index, output types, inputs, input types:out]
-{
-	type <- [output types]Index[index]
-	If[[[type]Variant >>] = ["Naked"]]
-	{
-		out <- [func]Box[[" naked"]Append[output], output, type]
-	}{
-		[inputs]Find[output]
-		{
-			If[[[input types]Index[~]]Mutable? >>]
-			{ 
-				out <- [func]Move[output, Output[output]]
-			}{
-				out <- func
-			}
-		}{	
-			out <- func
-		}
-	}
-}
-
-Compile Foreign Stub[worker,program,name:out]
-{
-	ifunc <- [[program]Create Function[name, [worker]Inputs >>, [worker]Outputs >>, "rhope"]
-	]Output Types <<[Map[[worker]Output Types >>, "Make Basic Type"]]
-	
-	rp num <- Return Param[[worker]Outputs >>, [worker]Inputs >>, [worker]Input Types >>]
-	{
-		rbase <- [[worker]Outputs >>]Index[rp num]
-		If[[[[[worker]Output Types >>]Index[rp num]]Variant >>] = ["Naked"]]
-		{
-			rparam <- [" naked"]Append[rbase]
-			rfunc <- [ifunc]Allocate Var[rparam, [[worker]Output Types >>]Index[rp num]]
-		}{
-			rparam <- Val[rbase]
-			rfunc <- Val[ifunc]
-		}
-	}{
-		rparam <- ""
-		rfunc <- Val[ifunc]
-	}
-	
-	Fold[["FInputs"]Set Input[3, [worker]Inputs >>], rfunc, [worker]Input Types >>]
-	{ [~]Call Foreign[name, [worker]Convention >>, Map[Zip[[worker]Inputs >>, [worker]Input Types >>], "FParams"], rparam]
-	{ Fold[[["Release Raw Inputs"]Set Input[3, [worker]Inputs >>]]Set Input[4, [worker]Outputs >>], ~, [worker]Input Types >>]
-	{ Fold[[[["Save Foreign Result"]Set Input[3, [worker]Output Types >>]]Set Input[4, [worker]Inputs >>]]Set Input[5, [worker]Input Types >>], ~, [worker]Outputs >>]
-	{ out <- [program]Store Function[~] }}}}
-}		
-
-Compile Worker@NWorker[worker,program,name:out]
-{
-	If[[worker]Builtin? >>]
-	{
-		out <- program
-	}{
-		If[[[worker]Library >>] = [""]]
-		{	
-			ifunc <- Fold["Set Output Type", Fold["Set Input Type", [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>], [worker]Input Types >>], [worker]Output Types >>]
-			
-			
-			
-			groups <- [worker]Dependency Groups
-			[groups]First
-			{
-				with conds <- [worker]Save Group Conditions[groups, ~]
-				final func <- [with conds]Compile Group[program,func,groups, ~]
-			}{
-				final func <- Val[func]
-			}
-			res vars <- [worker]Result Vars
-			init vars <- Concatenate[res vars, [with conds]No Release Results]
-			
-			func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, init vars], init vars], [worker]Outputs >>]
-			out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, with conds], final func, res vars], [worker]Inputs >>]]
-		}{
-			out <- Compile Foreign Stub[worker,[program]Link[[worker]Convention >>, [worker]Library >> ],name]
-		}
-	}
-}
-
-Test[:out]
-{
-	ref+ <- Worker Ref["+","rhope",2,1]
-	ref* <- Worker Ref["*","rhope",2,1]
-	,a <- [NWorker["rhope"]
-	]Add Input["a", 0] {
-		,b <- [~]Add Input["b", 1] {
-		,c <- [~]Add Input["c", 2] {
-		,outref <- [~]Add Output["out", 0] {
-		,call+ <- [~]Add Worker Call[ref+] {
-		,call* <- [~]Add Worker Call[ref*] {
-		out <- [[[[[~]Add Wire[a,0,call+,0]
-		]Add Wire[b,0,call+,1]
-		]Add Wire[call+,0,call*,0]
-		]Add Wire[c,0,call*,1]
-		]Add Wire[call*,0,outref,0]
-	}}}}}}
-}
-
-Test Graph to Backend[:out]
-{
-	out <- [Test[]]Compile Worker[C Program[], "Test"]
-}
-
-Blueprint NBlueprint
-{
-	Fields
-	Methods
-}
-
-NBlueprint[:out]
-{
-	out <- [[Build["NBlueprint"]]Fields <<[()]]Methods <<[Dictionary[]]
-}
-
-Add Field@NBlueprint[bp,name,type:out]
-{
-	out <- [bp]Fields <<[ [[bp]Fields >>]Append[ [[()]Append[name]]Append[type] ] ]
-}
-
-Add Method@NBlueprint[bp,name:out]
-{
-	out <- [bp]Methods <<[ [[bp]Methods >>]Set[name, Yes] ]
-}
-
-Understands Method@NBlueprint[bp,name:out]
-{
-	out <- [[bp]Methods >>]Index[name] {}
-	{ out <- No }
-}
-
-Get Field Type@NBlueprint[bp,name:out,notfound]
-{
-	,notfound <- [[bp]Fields >>]Index[name]
-	{ out <- [~]Index[1] }
-}
-
-_Compile Blueprint Fields[type,field:out]
-{
-	name <- [field]Index[0]
-	ftype <- [field]Index[1]
-	out <- [type]Add Field[name,ftype]
-}
-
-_Compile Blueprint Methods[type,junk,name:out]
-{
-	If[[[name]=["Call"]] And [[[type]Name >>] = ["Worker"]]]
-	{
-		out <- type
-	}{
-		out <- [type]Add Method[name]
-	}
-}
-
-Make Init[func,field:out]
-{
-	name <- [field]Index[0]
-	variant <- [[field]Index[1]]Variant >>
-	If[[variant] = ["Boxed"]]
-	{
-		out <- [func]Set Field Null["obj", name]
-	}{
-		out <- func
-	}
-}
-
-Make Copy[func,field:out]
-{
-	name <- [field]Index[0]
-	variant <- [[field]Index[1]]Variant >>
-	If[[variant] = ["Boxed"]]
-	{
-		got <- [func]Read Field["obj", name] {}
-		{ 
-			stream <- [[got]Instruction Stream
-				]AddRef No Dest[~] 
-			out <- [got]Do If[~, stream]
-		}
-	}{
-		out <- func
-	}
-}
-
-Make Cleanup[func,field:out]
-{
-	name <- [field]Index[0]
-	variant <- [[field]Index[1]]Variant >>
-	If[[variant] = ["Boxed"]]
-	{
-		got <- [func]Read Field["obj", name] {}
-		{ 
-			stream <- [[got]Instruction Stream
-				]Release[~] 
-			out <- [got]Do If[~, stream]
-		}
-	}{
-		out <- func
-	}
-}
-
-Make Special@NBlueprint[bp,backend,func name,bp name,pop worker:out]
-{
-	func <- [[backend]Create Function[func name,("obj"),(),"cdecl"]
-		]Set Input Type[Type Instance[bp name], 0]
-	out <- [backend]Store Function[Fold[pop worker, func, [bp]Fields >>]]
-}
-
-Getters Setters[backend,field,type name:out]
-{
-	//TODO: Throw an exception or something if we read a field that is empty
-	name <- [field]Index[0]
-	type <- [field]Index[1]
-	mytype <- Type Instance[type name]
-	start getter,getref <- [[[[backend]Create Function[ [[[name]Append[" >>"]]Append["@"]]Append[type name], ("obj"), ("out"), "rhope"]
-		]Set Input Type[mytype, 0]
-		]Set Output Type[[type]Set Variant["Boxed"], 0]
-		]Read Field["obj", name]
-	If[[[type]Variant >>] = ["Boxed"]]
-	{
-		getter <- [[start getter]Do AddRef[getref, "out"]]Release["obj"]
-	}{
-		getter <- [[start getter]Box[getref, "out", type]]Release["obj"]
-	}
-		
-	begin setter <- [[[[[backend]Create Function[ [[[name]Append[" <<"]]Append["@"]]Append[type name], ("obj","newval"), ("out"), "rhope"]
-		]Set Input Type[mytype, 0]
-		]Set Input Type[[type]Set Variant["Boxed"], 1]
-		]Set Output Type[mytype, 0]
-		]Copy["obj"]
-		
-	If[[[type]Variant >>] = ["Boxed"]]
-	{
-		,origref <- [begin setter]Read Field["obj", name]
-		{ 
-			stream <- [[~]Instruction Stream
-			]Release[origref]
-			,setref <- [[~]Do If[origref, stream]
-			]Write Field["obj", name]
-			{
-				setter <- [[~]Move["newval", setref]
-				]Move["obj", "out"]
-			}
-		}
-	}{
-		,setref <- [begin setter]Write Field["obj", name]
-		{ 
-			setter <- [[[~]Unbox["newval", setref]
-			]Release["newval"]
-			]Move["obj", "out"]
-		}
-	}
-	
-	out <- [[backend]Store Function[getter]]Store Function[setter]
-	
-}
-
-Compile Blueprint@NBlueprint[bp,backend,name:out]
-{
-	//Rhope identifiers can't start with spaces, so we can use identifiers that start with spaces for special functions
-	init name <- [" init "]Append[name]
-	[("Array","Boxed Array","Worker")]Find[name]
-	{
-		[("internalarraynaked","internalarrayboxed","internalworker")]Index[~]
-		{
-			copy name <- [~]Append["copy"]
-			cleanup name <- [~]Append["cleanup"]
-		}
-	}{
-		copy name <- [" copy "]Append[name]
-		cleanup name <- [" cleanup "]Append[name]
-	}
-	type <- [[[Fold["_Compile Blueprint Methods", Fold["_Compile Blueprint Fields", [backend]Create Type[name], [bp]Fields >>], [bp]Methods >>]
-	]Init <<[init name]
-	]Copy <<[copy name]
-	]Cleanup <<[cleanup name]
-	
-	out <- [backend]Register Type[type]
-}
-
-Compile Special@NBlueprint[bp,backend,name:out]
-{
-	init name <- [" init "]Append[name]
-	[("Array","Boxed Array","Worker")]Find[name]
-	{
-		after copyclean <- Val[backend]
-	}{		
-		copy name <- [" copy "]Append[name]
-		cleanup name <- [" cleanup "]Append[name]
-		after copyclean <- [bp]Make Special[
-					[bp]Make Special[backend, copy name, name, "Make Copy"], 
-				cleanup name, name, "Make Cleanup"]
-	}
-	out <- Fold[["Getters Setters"]Set Input[2, name], [bp]Make Special[after copyclean, init name, name, "Make Init"], [bp]Fields >>]
-}
-
-Blueprint NProgram
-{
-	Blueprints
-	Workers
-	Worker Refs
-}
-
-NProgram[:out]
-{
-	out <- [[[Build["NProgram"]]Blueprints <<[Dictionary[]]]Workers <<[Dictionary[]]]Worker Refs <<[Dictionary[]]
-}
-
-Bind Worker@NProgram[prog,name,worker:out]
-{	
-	after bind <- [prog]Workers << [ [[prog]Workers >>]Set[name, [worker]Name <<[name]] ]
-	parts <- [name]Split["@"]
-	[parts]Index[1]
-	{
-		orig bp <- [[after bind]Blueprints >>]Index[~] {}
-		{ orig bp <- NBlueprint[] }
-		out <- [after bind]Blueprints <<[ [[after bind]Blueprints >>]Set[~, [orig bp]Add Method[[parts]Index[0]] ] ]
-	}{
-		out <- Val[after bind]
-	}
-}
-
-Bind Blueprint@NProgram[prog,name,blueprint:out]
-{
-	out <- [prog]Blueprints << [ [[prog]Blueprints >>]Set[name, blueprint] ]
-}
-
-_Compile Program BP[backend, blueprint, name:out]
-{
-	out <- [blueprint]Compile Blueprint[backend, name]
-}
-
-_Compile Program BP Special[backend, blueprint, name:out]
-{
-	out <- [blueprint]Compile Special[backend, name]
-}
-
-_Compile Program[backend, worker, name:out]
-{
-	out <- [worker]Compile Worker[backend, name]
-}
-
-Compile Program@NProgram[prog, backend:out]
-{
-	backend with bps <- Generate Boolean Methods[Generate Number Methods[Fold["_Compile Program BP Special", Fold["_Compile Program BP", backend, [prog]Blueprints >>], [prog]Blueprints >>]]]
-	workers with infer <- SMap[[prog]Workers >>, ["Infer Types"]Set Input[1, prog]]
-	out <- Fold["_Compile Program", backend with bps,  workers with infer]
-}
-
-Register Method@NProgram[prog, name, convention, inputs, outputs: out]
-{
-	[[prog]Worker Refs >>]Index[name]
-	{
-		ref <- [[[[~]Inputs <<[ Max[[~]Inputs >>, inputs] ]
-		]Min Inputs <<[ Min[[~]Min Inputs >>, inputs] ]
-		]Outputs <<[ Max[[~]Outputs >>, outputs] ]
-		]Min Outputs <<[ Min[[~]Min Outputs >>, outputs] ]
-	}{
-		ref <- Worker Ref[name, convention, inputs, outputs, Yes]
-	}
-	out <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, ref]]
-}
-
-Register Worker@NProgram[prog, name, convention, inputs, outputs: out]
-{
-	[[prog]Worker Refs >>]Index[name]
-	{
-		ref <- [[[[~]Inputs <<[ Max[[~]Inputs >>, inputs] ]
-		]Min Inputs <<[ Min[[~]Min Inputs >>, inputs] ]
-		]Outputs <<[ Max[[~]Outputs >>, outputs] ]
-		]Min Outputs <<[ Min[[~]Min Outputs >>, outputs] ]
-	}{
-		ref <- Worker Ref[name, convention, inputs, outputs, No]
-	}
-	after reg <- [prog]Worker Refs <<[ 
-		[ [prog]Worker Refs >> ]Set[name, ref]
-	]
-
-	parts <- [name]Split["@"]
-	[parts]Index[1]
-	{
-		out <- [after reg]Register Method@NProgram[[parts]Index[0], convention, inputs, outputs]
-	}{
-		out <- Val[after reg]
-	}
-}
-
-Register Builtins@NProgram[prog:out]
-{
-	registered <- [[[[[[[[prog]Register Worker["Print", "rhope", 1, 1]
-	]Register Worker["If@Boolean", "rhope", 1, 2]
-	]Register Worker["Build", "rhope", 1, 1]
-	]Register Worker["Blueprint Of", "rhope", 1, 1]
-	]Register Worker["Call@Worker", "rhope", 1, 2] //We're using 2 because we need to assume that the outputs are conditional
-	]Register Worker["ID", "rhope", 1, 1]
-	]Register Worker["Blueprint From ID", "rhope", 1, 2]
-	]Register Number Methods
-	
-	out <- [[[[[[[registered]Bind Worker["If@Boolean",
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("condition")]
-		]Input Types <<[ [()]Append[Type Instance["Boolean"]] ]
-		]Outputs <<[("isyes","isno")]
-		]Output Types <<[ [[()]Append[Type Instance["Boolean"]]]Append[Type Instance["Boolean"]] ]
-		]Builtin? <<[Yes]]
-	]Bind Worker["Print",
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("value")]
-		]Input Types <<[ [()]Append[Type Instance["Any Type"]] ]
-		]Outputs <<[("out")]
-		]Output Types <<[ [()]Append[Type Instance["Int32"]] ]
-		]Builtin? <<[Yes]] 
-	]Bind Worker["Build",
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("type")]
-		]Input Types <<[ [()]Append[Type Instance["Blueprint"]] ]
-		]Outputs <<[("out")]
-		]Output Types <<[ [()]Append[Type Instance["Any Type"]] ]
-		]Builtin? <<[Yes]] 
-	]Bind Worker["Blueprint Of",
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("object")]
-		]Input Types <<[ [()]Append[Type Instance["Any Type"]]]
-		]Outputs <<[("type")]
-		]Output Types <<[ [()]Append[Type Instance["Blueprint"]]]
-		]Builtin? <<[Yes]]
-	]Bind Worker["Call@Worker",
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("worker")]
-		]Input Types <<[ [()]Append[Type Instance["Worker"]] ]
-		]Outputs <<[("ret1","ret2")]
-		]Output Types <<[ [[()]Append[Type Instance["Any Type"]]]Append[Type Instance["Any Type"]] ]
-		]Builtin? << [Yes]]
-	]Bind Worker["ID",
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("bp")]
-		]Input Types <<[ [()]Append[Type Instance["Blueprint"]]]
-		]Outputs <<[("id")]
-		]Output Types <<[ [()]Append[Type Instance["UInt32"]]]
-		]Builtin? << [Yes]]
-	]Bind Worker["Blueprint From ID",
-		[[[[[NWorker["rhope"]
-		]Inputs <<[("id")]
-		]Input Types <<[ [()]Append[Type Instance["UInt32"]]]
-		]Outputs <<[("bp","none")]
-		]Output Types <<[ [[()]Append[Type Instance["Blueprint"]]]Append[Type Instance["Any Type"]]]
-		]Builtin? << [Yes]]
-}
-
-Find Worker@NProgram[prog, name:out,notfound]
-{
-	out,notfound <- [[prog]Worker Refs >>]Index[name]
-}
-
-Find Worker Def@NProgram[prog,name:out,notfound]
-{
-	out,notfound <- [[prog]Workers >>]Index[name]
-}
-
-Find Method@NProgram[prog, name, type:out,notfound]
-{
-	bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>]
-	,notfound <- If[[bp]Understands Method[name]]
-	{
-		out <- [[prog]Workers >>]Index[[[name]Append["@"]]Append[[type]Name >>]]
-	}
-}
-
-Find Field@NProgram[prog, name, type:fieldtype,notfound]
-{
-	bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>]
-	fieldtype,notfound <- [bp]Get Field Type[name]
-}
-
-Implicit Conversion@NProgram[prog, fromtype, totype:func,notfound]
-{
-	notfound <- No
-}
-
-Is Method?@NProgram[prog,name:is,is not]
-{
-	,is not <- [[prog]Worker Refs>>]Index[name]
-	{
-		is,is not <- If[[~]Is Method? >>]
-	}
-}