--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/parser_old.rhope	Wed Jul 27 21:28:43 2011 -0700
@@ -0,0 +1,1683 @@
+Import nworker.rhope
+
+//Rather than rewrite the code that uses this
+//let's implement Get DString using Partition
+Get DString[str,delims:after,before,delim,not found]
+{
+	before,delim,after,not found <- [str]Partition[delims] {} {} {}
+	{
+		before <- str
+	}
+}
+
+
+Blueprint Parser
+{
+	Arg Begin
+	Arg End
+	Line Comment
+	Comment Begin
+	Comment End
+	Assign
+	Block Begin
+	Block End
+	Blueprint Type Delim
+	Empty Block
+	Binary Operator
+	String Begin
+	String End
+	String Escape 
+	List Begin
+	List End
+	List Delim
+	In Out Delim
+	Index Begin
+	Index End
+	Previous
+	Block Val
+	Set Field
+	Get Field
+	Import
+	Blueprint
+	Global Separator
+	Uses
+	Hex Escape
+	Escape Map
+	Foreign
+	Globals
+}
+
+Parser[:out]
+{
+	out <- [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Build[Parser()]
+	]Arg Begin << ["["]
+	]Arg End <<["]"]
+	]Line Comment <<["//"]
+	]Comment Begin <<["/*"]
+	]Comment End <<["*/"]
+	]Assign <<["<-"]
+	]Block Begin <<["{"]
+	]Block End <<["}"]
+	]Blueprint Type Delim <<[":"]
+	]Empty Block <<[";"]
+	]Binary Operator <<["`"]
+	]String Begin <<["\""]
+	]String End <<["\""]
+	]String Escape <<["\\"]
+	]List Begin <<["("]
+	]List End <<[")"]
+	]List Delim <<[","]
+	]In Out Delim <<[":"]
+	]Index Begin <<["("]
+	]Index End <<[")"]
+	]Previous <<["@"]
+	]Set Field <<["<<"]
+	]Get Field <<[">>"]
+	]Import <<["Import"]
+	]Blueprint <<["Blueprint"]
+	]Global Separator <<["::"]
+	]Hex Escape <<["x"]
+	]Uses <<["uses"]
+	]Escape Map <<[[[[Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]]
+	]Foreign <<["Foreign"]
+	]Globals <<["Globals"]
+}
+
+Blueprint Output Reference
+{
+	Index
+	Output Number
+}
+
+Output Reference[index,num:out]
+{
+	out <- [[Build[Output Reference()]]Index <<[index]]Output Number <<[num]
+}
+
+Add Pipe Reference[refs,name,reference:out]
+{
+	reflist <- [refs]Index[name] {}
+	{
+		reflist <- ()
+	}
+	out <- [refs]Set[name, [reflist]Append[reference]]
+}
+
+Assignment Save Reference[refs,assignment,output num,parse worker,index:out]
+{
+	[[parse worker]Outputs >>]Find[=[assignment,?]]
+	{
+		out <- refs
+	}{
+		out <- Add Pipe Reference[refs, assignment, Output Reference[index, output num]]
+	}
+}
+
+Blueprint Foreign Lib
+{
+	Language
+	Name
+}
+
+New Foreign Lib[language, library:out]
+{
+	out <- [[Build[Foreign Lib()]
+	]Language <<[language]
+	]Name <<[library]
+}
+
+Blueprint Global Store
+{
+	Name
+	Vars
+}
+
+Global Store[name:out]
+{
+	out <- [[Build[Global Store()]]Name <<[name]]Vars <<[Dictionary[]]
+}
+
+Blueprint Parse Program
+{
+	Workers
+	Imports
+	Blueprints
+	Global Stores
+	Errors
+}
+
+Parse Program[:out]
+{
+	out <- [[[[[Build[Parse Program()]
+	]Workers <<[Dictionary[]]
+	]Imports <<[Dictionary[]]
+	]Blueprints <<[Dictionary[]]
+	]Global Stores <<[Dictionary[]]
+	]Errors <<[()]
+}
+
+Add Global Store@Parse Program[tree,store:out]
+{
+	out <- [tree]Global Stores <<[ [[tree]Global Stores >>]Set[[store]Name >>, store] ]
+}
+
+Blueprint Blueprint Definition
+{
+	Name
+	Fields
+}
+
+New Blueprint Definition[name,fields:out]
+{
+	out <- [[Build[Blueprint Definition()]]Name << [name]]Fields <<[fields]
+}
+
+Blueprint Parse Worker
+{
+	Name
+	Inputs
+	Outputs
+	Line Number
+	Trees
+	Uses Stores
+	Input Types
+	Output Types
+	Assigned
+}
+
+Parse Worker[name,inputs,outputs,intypes,outtypes,line:out]
+{
+	out <- [[[[[[[[[Build[Parse Worker()]]Name <<[name]]Inputs <<[inputs]]Outputs <<[outputs]]Line Number <<[line]]Trees <<[()]]Uses Stores <<[()]]Input Types <<[intypes]]Output Types <<[outtypes]]Assigned <<[Dictionary[]]
+}
+
+Blueprint Worker Node
+{
+	Name
+	Params
+	Assignments
+	Blocks
+	Index
+}
+
+Worker Node[name,params:out]
+{
+	out <- [[[[Build[Worker Node()]]Name <<[name]]Params <<[params]]Assignments <<[()]]Blocks <<[()]
+}
+
+_Get Assigned Pipes[pipe dict,node:out]
+{
+	out <- [node]Get Assigned Pipes[pipe dict]
+}
+
+Get Assigned Pipes[node,pipe dict:out]
+{
+	Fold[Set[?,?,Yes], pipe dict, [node]Assignments >>]
+	{ out <- Fold[Fold[_Get Assigned Pipes[?], ?], ~, [node]Blocks >>] }
+}
+
+Add List Helper[inlist,worker,program,key,parse worker,refs:out list,out worker,out refs]
+{
+	,nextworker,nextrefs <- [[inlist]Index[key]]Add to Worker[worker, program, parse worker, refs]
+	{ nextlist <- [inlist]Set[key, ~] }
+	[inlist]Next[key]
+	{
+		out list,out worker,out refs <- Add List Helper[nextlist, nextworker, program, ~, parse worker, nextrefs]
+	}{
+		out list <- Val[nextlist]
+		out worker <- Val[nextworker]
+		out refs <- Val[nextrefs]
+	}
+}
+
+Add List to Worker[list,worker,program,parse worker,refs:out list,out worker,out refs]
+{
+	[list]First
+	{
+		out list,out worker,out refs <- Add List Helper[list, worker, program, ~, parse worker, refs]
+	}{
+		out list <- list
+		out worker <- worker
+		out refs <- refs
+	}
+}
+
+_Add Blocks to Worker[blocks,worker,program,parse worker,key,refs:out blocks,out worker,out refs]
+{
+	block, next worker, nextrefs <- Add List to Worker[[blocks]Index[key], worker, program, parse worker, refs]
+	next blocks <- [blocks]Set[key, block]
+	[blocks]Next[key]
+	{
+		out blocks,out worker,out refs <- _Add Blocks to Worker[next blocks, next worker, program, parse worker, ~, nextrefs]
+	}{
+		out blocks <- Val[next blocks]
+		out worker <- Val[next worker]
+		out refs <- Val[nextrefs]
+	}
+}
+
+Add Blocks to Worker[blocks,worker,program,parse worker,refs:out blocks,out worker,out refs]
+{
+	[blocks]First
+	{
+		out blocks, out worker, out refs <- _Add Blocks to Worker[blocks, worker, program, parse worker, ~, refs]
+	}{
+		out blocks <- blocks
+		out worker <- worker
+		out refs <- refs
+	}
+}
+
+Add to Worker@Worker Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
+{
+	[program]Find Worker[[node]Name >>]
+	{
+		after worker <- [worker]Add Worker Call[~] {}
+		{
+			//Print[[[[node]Name >>]Append[" has index "]]Append[~]]
+			assignment refs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
+			[node]Index <<[~]
+			{ 
+				params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs]
+				block list, out worker, out refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs]
+				out node <- [[~]Params <<[params list]]Blocks <<[block list]
+			}
+		}
+	}{
+		make call <- [[parse worker]Assigned >>]Index[[node]Name >>] {}
+		{
+			make call <- [[parse worker]Inputs >>]Find[=[?,[node]Name >>]] {}
+			{
+				Print[["Error: Could not find a worker named "]Append[[node]Name >>]]
+			}
+		}
+		Val[make call]
+		{
+			new params <- Fold[Append[?], [()]Append[Named Pipe Node[[node]Name >>]], [node]Params >>]
+			out node, out worker, out refs <- [[[node]Params <<[new params]]Name <<["Call"]]Add to Worker[worker, program, parse worker, refs]
+		}
+	}
+}
+
+Check Question Mark[params, index:has mark,no mark]
+{
+	param,no mark <-[params]Index[index]
+	{
+		If[[Blueprint Of[param]]=[Named Pipe Node()]]
+		{
+			has mark <-If[[[param]Name >>] = ["?"]] {}
+			{
+				has mark,no mark <- Check Question Mark[params, [index]+[1]]
+			}
+		}{
+			has mark,no mark <- Check Question Mark[params, [index]+[1]]
+		}
+	}
+}
+
+Collect Literal Inputs[literal, params, index, complex inputs:literal out,complex out]
+{
+	param <- [params]Index[index]
+	{
+		If[[Blueprint Of[param]]=[Literal Node()]]
+		{
+			next literal <- [literal]Set Input[index, [param]Value >>]
+			next complex <- Val[complex inputs]
+		}{
+			,doset <- If[[Blueprint Of[param]]=[Named Pipe Node()]]
+			{
+				,doset <- If[[[param]Name >>] = ["?"]]
+				{
+					//Question mark indicates unpopulated input
+					next complex <- Val[complex inputs]
+					next literal <- Val[literal]
+				}
+			}
+
+			Val[doset]
+			{
+				next complex <- [complex inputs]Set[index, param]
+				next literal <- Val[literal]
+			}
+		}
+		literal out, complex out <- Collect Literal Inputs[next literal, params, [index]+[1], next complex]
+	}{
+		literal out <- literal
+		complex out <- complex inputs
+	}
+}
+
+Do Set Input[literal,param,index:out]
+{
+	out <- Worker Node["Set Input", [[[()]Append[literal]]Append[Literal Node[index]]]Append[param]]
+}
+
+Check Worker Literals@Worker Node[node,program:out]
+{
+	new params <- Map[[node]Params >>, Check Worker Literals[?, program]]
+	Check Question Mark[new params, 0]
+	{
+		base literal, complex inputs <- Collect Literal Inputs[Worker Literal[[node]Name >>], new params, 0, ()]
+		new node <- Fold[Do Set Input[?], Literal Node[base literal], complex inputs]
+	}{
+		new node <- [node]Params <<[new params]
+	}
+	out <- [new node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
+}
+
+Add Multi Wire[worker,ref,junk,end index,input num:out]
+{
+	out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num]
+}
+
+Add Param Wire[worker,param,input num,end index,blocks,parse worker,assignments:out]
+{
+	param worker, start index, output num <- [param]Add Wires[worker, blocks, parse worker, assignments] {}
+	{
+		out <- [param worker]Add Wire[start index, output num, end index, input num]
+	}{}{
+		out <- Fold[Add Multi Wire[?, ?, ?, end index, input num], param worker, ~]
+	}
+}
+
+_Add Block Wire[worker,node,junk,blocks,parse worker,assignments:out]
+{
+	out <- [node]Add Wires[worker, blocks, parse worker, assignments]
+}
+
+Add Block Wire[worker,block nodes,output num,parent index,existing blocks,parse worker,assignments:out]
+{
+	blocks <- [existing blocks]Append[Output Reference[parent index, output num]]
+	out <- Fold[_Add Block Wire[?, ?, ?, blocks, parse worker, assignments], worker, block nodes]
+}
+
+Assignments Add Wires[worker,assignment,output num,parse worker,start index:out worker]
+{
+	[[parse worker]Outputs >>]Find[=[assignment,?]]
+	{
+		,output index <- [worker]Add Typed Output[assignment, ~, [[parse worker]Output Types >>]Index[~]]
+		{
+			out worker <- [~]Add Wire[start index, output num, output index, 0]
+		}
+	}{
+		//Ugly hack alert!
+		If[[assignment]Contains["::"]]
+		{
+			parts <- [assignment]Split["::"]
+			,global index <- [worker]Add Global Set[[parts]Index[0], [parts]Index[1]]
+			{
+				out worker <- [~]Add Wire[start index, output num, global index, 0]
+			}
+		}{
+			out worker <- worker
+		}
+	}
+}
+
+Has Block@Worker Node[junk:out,unused]
+{
+	out <- Yes
+}
+
+_Has Block Params[param list,key:out]
+{
+	param <- [param list]Index[key]
+	out <- [param]Has Block {}
+	{
+		[param list]Next[key]
+		{
+			out <- _Has Block Params[param list, ~]
+		}{
+			out <- No
+		}
+	}
+	
+}
+
+Has Block Params[param list:out]
+{
+	[param list]First
+	{
+		out <- _Has Block Params[param list, ~]
+	}{
+		out <- No
+	}
+}
+
+Add Wires@Worker Node[node,worker,blocks,parse worker,assignments:outworker,index,num,unused]
+{
+	outworker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
+}
+
+Add Wires Worker or Field[node,worker,blocks,parse worker,assignments:outworker,index,num,unused]
+{
+	Fold[Assignments Add Wires[?, ?, ?, parse worker, [node]Index >>], worker, [node]Assignments >>]
+	{
+		Fold[Add Block Wire[?, ?, ?, [node]Index >>, blocks, parse worker, assignments], ~, [node]Blocks >>]
+		{ 
+			params worker <- Fold[Add Param Wire[?, ?, ?, [node]Index >>, blocks, parse worker, assignments], ~, [node]Params >>] 
+			{
+				index <- [node]Index >>
+				num <- 0
+			}
+		}
+	}
+	If[Has Block Params[[node]Params >>]]
+	{
+		outworker <- Val[params worker]
+	}{
+		[blocks]Peek
+		{
+			outworker <- [params worker]Add Wire[[~]Index >>, [~]Output Number >>, [node]Index >>, [0]-[1]]
+		}{
+			outworker <- Val[params worker]
+		}
+	}
+}
+
+Blueprint Field Node
+{
+	Name
+	Params
+	Assignments
+	Blocks
+	Index
+	Set?
+}
+
+Has Block@Field Node[junk:has block,unused]
+{
+	has block <- Yes
+}
+
+Field Node[name,params,set:out]
+{
+	out <- [[[[[Build[Field Node()]]Name <<[name]]Assignments <<[()]]Blocks <<[()]]Set? <<[set]]Params <<[params]
+}
+
+Add to Worker@Field Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
+{
+	If[[node]Set? >>]
+	{
+		after worker,index <- [worker]Add Object Set[[node]Name >>]
+	}{
+		after worker,index <- [worker]Add Object Get[[node]Name >>]
+	}
+	Val[index]
+	{
+		assignment refs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
+		[node]Index <<[~]
+		{ 
+			params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs]
+			block list, out worker, out refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs]
+			out node <- [[~]Params <<[params list]]Blocks <<[block list]
+		}
+	}
+}
+
+Add Wires@Field Node[node,worker,blocks,parse worker,assignments:outworker,index,num]
+{
+	outworker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
+}
+
+Check Worker Literals@Field Node[node,program:out]
+{
+	new params <- Map[[node]Params >>, Check Worker Literals[?, program]]
+	out <- [[node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
+		]Params <<[new params]
+}
+
+Blueprint Named Pipe Node
+{
+	Name
+	Assignments
+	Blocks
+	Index
+}
+
+Has Block@Named Pipe Node[node:has block,no block]
+{
+	If[[[node]Index >>] < [0]]
+	{
+		//~ should really be a parser parameter
+		If[[[node]Name >>] = ["~"]]
+		{
+			has block <- Yes
+		}{
+			no block <- No
+		}
+	}{
+		has block <- Yes
+	}
+}
+
+Named Pipe Node[name:out]
+{
+	out <- [[[Build[Named Pipe Node()]]Name <<[name]]Assignments <<[()]]Blocks <<[()]
+}
+
+Add to Worker@Named Pipe Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
+{
+	[[parse worker]Inputs >>]Find[=[[node]Name >>, ?]]
+	{
+		after add <- [worker]Add Typed Input[[node]Name >>, ~, [[parse worker]Input Types>>]Index[~]] {}
+		{
+			assign refs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
+			index node <- [node]Index <<[~]
+		}
+	}{
+		after add <- worker
+		index node <- [node]Index <<[[0]-[1]]
+		//TODO: Handle assignments from a named pipe that isn't an input
+		assign refs <- refs
+	}
+	block list, out worker, out refs <- Add Blocks to Worker[[node]Blocks >>, after add, program, parse worker, assign refs]
+	out node <- [index node]Blocks <<[block list]
+}
+
+Add Wires@Named Pipe Node[node,worker,blocks,parse worker,assignments:outworker,index,num,reflist]
+{
+	reflist <- [assignments]Index[[node]Name >>]
+	{ 
+		//TODO: Fix support for a named pipe with a block
+		outworker <- worker 
+	}{
+		If[[[node]Name >>] = ["~"]]
+		{
+			wires worker <- worker
+			[blocks]Peek
+			{
+				my index <- [~]Index >>
+				num <- [~]Output Number >>
+			}{
+				//TODO: Propagate an error rather than printing it out
+				Print["Error, block reference symbol  located outside of a block"]
+			}
+		}{
+			If[[[node]Index >>] < [0]]
+			{
+				Print[[[["Error, reference to named pipe "]Append[[node]Name >>]]Append[" that was never assigned to in worker "]]Append[[parse worker]Name >>]]
+			}{
+				my index <- [node]Index >>
+				num <- 0
+				assignments worker <- Fold[Assignments Add Wires[?, ?, ?, parse worker, [node]Index >>], worker, [node]Assignments >>]
+				[blocks]Peek
+				{
+					wires worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number >>, [node]Index >>, [0]-[1]]
+				}{
+					wires worker <- Val[assignments worker]
+				}
+			}
+		}
+	}
+	index <- Val[my index]
+	
+	outworker <- Fold[Add Block Wire[?, ?, ?, my index, blocks, parse worker, assignments], wires worker, [node]Blocks >>]
+}
+
+Check Worker Literals@Named Pipe Node[node,program:out]
+{
+	out <- [node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
+}
+
+Blueprint Global Node
+{
+	Store
+	Name
+	Assignments
+	Blocks
+	Index
+}
+
+Global Node[store,name:out]
+{
+	out <- [[[[Build[Global Node()]]Store <<[store]]Name <<[name]]Assignments <<[()]]Blocks <<[()]
+}
+
+Add to Worker@Global Node[node,worker,unused,parse worker,refs:out node,out worker,outrefs]
+{
+	out worker <- [worker]Add Global Get[[node]Store >>, [node]Name >>] {}
+	{
+		outrefs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
+		out node <- [node]Index <<[~]
+	}
+	outrefs <- refs
+}
+
+Add Wires@Global Node[node,worker,blocks,parse worker,assignments:outworker,index,num,unused]
+{
+	outworker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments]
+}
+
+Has Block@Global Node[junk:out,unused]
+{
+	out <- Yes
+}
+
+Check Worker Literals@Global Node[node,program:out]
+{
+	out <- [node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
+}
+
+Blueprint Literal Node
+{
+	Value
+	Assignments
+	Blocks
+	Index
+}
+
+Has Block@Literal Node[junk:out,unused]
+{
+	out <- Yes
+}
+
+Literal Node[value:out]
+{
+	out <- [[[Build[Literal Node()]]Value <<[value]]Assignments <<[()]]Blocks <<[()]
+}
+
+Add to Worker@Literal Node[node,worker,unused,parse worker,refs:out node,out worker,out refs]
+{
+	out worker <- [worker]Add Constant[[node]Value >>] {}
+	{
+		out refs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
+		out node <- [node]Index <<[~]
+	}
+}
+
+Add Wires@Literal Node[node,worker,blocks,parse worker,assignments:outworker,index,num,unused]
+{
+	outworker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments]
+}
+
+Check Worker Literals@Literal Node[node,program:out]
+{
+	out <- [node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
+}
+
+Add Wires Literal or Global[node,worker,blocks,parse worker,junk:outworker,index,num,unused]
+{
+	assignments worker <- Fold[Assignments Add Wires[?, ?, ?, parse worker, [node]Index >>], worker, [node]Assignments >>]
+	[blocks]Peek
+	{
+		outworker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number>>, [node]Index >>, [0]-[1]]
+	}{
+		outworker <- Val[assignments worker]
+	}
+	index <- [node]Index >>
+	num <- 0
+}
+
+Blueprint Block Node
+{
+	Number
+}
+
+Blueprint Parse Error
+{
+	Type
+	Text
+	Line Number
+}
+
+Parse Error[type,text,number:out]
+{
+	out <- [[[Build[Parse Error()]]Type <<[type]]Text <<[text]]Line Number <<[number]
+}
+
+Not Empty[string:out]
+{
+	If[[[string]Length] > [0]]
+	{
+		out <- Yes
+	}{
+		out <- No
+	}
+}
+
+Blueprint Blueprint Field
+{
+	Name
+	Type
+}
+
+New Blueprint Field[name,type:out]
+{
+	out <- [[Build[Blueprint Field()]]Name <<[name]]Type <<[type]
+}
+
+Process Blueprint Field[list,field,params:out]
+{
+	,name <- [field]Get DString[[params]List Begin >>]
+	{
+		type info <- Parse List[~,params,()]
+		type <- [type info]Index[0]
+		{
+			If[[Blueprint Of[~]] = [Named Pipe Node()]]
+			{
+				before variant <- Type Instance[[type]Name >>]
+			}{
+				before variant <-  [type]Params <<[ Map[[type]Params >>, Remove Named Pipe Node[?]] ]
+			}
+			variant <- [type info]Index[1]
+			{
+				,warn <- If[[Blueprint Of[~]] = [Named Pipe Node()]]
+				{
+					fieldtype,warn <- [before variant]Set Variant[[variant]Name >>]
+				}
+				Val[warn]
+				{
+					Print[[[["Warning: Invalid variant for type "]Append[[before variant]Name >>]]Append[" on field "]]Append[name]]
+					fieldtype <- Val[before variant]
+				}
+			}{
+				fieldtype <- Val[before variant]
+			}
+		}{
+			fieldtype <- Type Instance["Any Type"]
+		}
+		out <- [list]Append[New Blueprint Field[name, fieldtype]]
+	} {} {} {
+		out <- [list]Append[New Blueprint Field[name, Type Instance["Any Type"]]]
+	}
+}
+
+Block Comment[string,begin comment,end comment,block count:out]
+{
+	If[[block count] > [0]]
+	{
+		after, before <- [string]Get DString[[[()]Append[begin comment]]Append[end comment]] {} {}
+		{
+			If[[~] = [begin comment]]
+			{
+				out <- Block Comment[after, begin comment, end comment, [block count]+[1]]
+			}{
+				out <- Block Comment[after, begin comment, end comment, [block count]-[1]]
+			}
+		}{
+			//No match
+			out <- ""
+		}
+	}{
+		out <- string
+	}
+}
+
+Line Comment[string:out]
+{
+	[string]Get DString["\n"]
+	{
+		out <- ["\n"]Append[~]
+	} {} {} {
+		out <- ""
+	}
+}
+
+_Get Comment DString[string,delims,line comment,begin comment,end comment,prev before:rest,before,delim,nomatch]
+{
+	after,befored,used delim,nomatch <- [string]Get DString[delims]
+	{
+		If[[used delim] = [line comment]]
+		{
+			after comment <- Line Comment[after]
+		}{
+			If[[used delim] = [begin comment]]
+			{
+				after comment <- Block Comment[after, begin comment, end comment, 1]	
+			}{
+				rest <- Val[after]
+				before <- [prev before]Append[befored]
+				delim <- Val[used delim]
+			}
+		}
+	} {} {} {
+		before <- [prev before]Append[befored]
+	}
+	
+	after comment
+	{
+		rest,more before,delim,nomatch <- _Get Comment DString[~, delims, line comment, begin comment, end comment, prev before]
+		before <- [before]Append[more before]
+	}
+		
+}
+
+As List[val:out]
+{
+	[(List(),List Leaf())]Find[=[Blueprint Of[val], ?]]
+	{
+		out <- val
+	}{
+		out <- [()]Append[val]
+	}
+}
+
+Get Comment DString[string,delims,params:rest,before,delim,not found]
+{
+	line comment <- [params]Line Comment >>
+	begin comment <- [params]Comment Begin >>
+	end comment <- [params]Comment End >>
+	all delims <- [[[delims]As List]Append[begin comment]]Append[line comment]
+	rest, before, delim, not found <- _Get Comment DString[string, delims, line comment, begin comment, end comment, ""]
+}
+
+Comment Left Trim[string,trim chars,params:out]
+{
+	line comment <- [params]Line Comment >>
+	
+	end comment <- [params]Comment End >>
+	trimmed <- Left Trim[string, trim chars]
+	If[[trimmed]Starts With[line comment]]
+	{
+		,after delim <- [trimmed]Slice[[line comment]Length]
+		out <- Comment Left Trim[Line Comment[after delim], trim chars, params]
+	}{
+		begin comment <- [params]Comment Begin >>
+		If[[trimmed]Starts With[begin comment]]
+		{
+			,after delim <- [trimmed]Slice[[line comment]Length]
+			out <- Comment Left Trim[Block Comment[after delim, begin comment, end comment, 1], trim chars, params]
+		}{
+			out <- Val[trimmed]
+		}
+	}
+}
+
+PBlueprint[string,params,tree,lines:out]
+{
+	,whitespace name <- [string]Get Comment DString[[params]Block Begin >>, params]
+	{	
+		,no blueprint <- [whitespace name]Slice[ [[params]Blueprint >>]Length ]
+		name <- Trim[no blueprint, "\r\n\t "]
+		name lines <- 0
+		,body <- [~]Get Comment DString[ [params]Block End >>, params]
+		{
+			body lines <- [body]Split["\n"]
+			more lines <- [[[body lines]Length] - [1]] + [name lines]
+			fields <- Fold[Process Blueprint Field[?, ?, params], (), Filter[Map[body lines, Trim[?,"\n\r\t "]], Not Empty[?]]]
+			new tree <- [tree]Blueprints << [ [[tree]Blueprints >>]Set[name, New Blueprint Definition[name, fields]] ]
+			out <- Null[~, params, new tree, [lines] + [more lines]]
+		} {} {} {
+			out <- [tree]Errors <<[ [[tree]Errors >>]Append[Parse Error["Error",[["Blueprint is missing an block close symbol \""]Append[[params]Block End >>]]Append["\""], lines]] ]
+		}
+		
+	} {} {} {
+		out <- [tree]Errors <<[ [[tree]Errors >>]Append[Parse Error["Error",[["Blueprint is missing an block open symbol \""]Append[[params]Block Begin >>]]Append["\""], lines]] ]
+	}
+}
+
+Parse Import[string,params,tree,lines:out]
+{
+	[line]Slice[ [[params]Import >>]Length ] {}
+	{
+		filename <- Trim[~, " \n\r\t"]
+	}
+	
+	new tree <- [tree]Imports <<[[[tree]Imports >>]Set[filename, Yes]]
+	
+	,line <- [string]Get Comment DString["\n", params]
+	{
+		out <- Null[~, params, new tree, [lines] + [1]]
+	} {} {} {
+		out <- Val[new tree]
+	}
+}
+
+Get Expression Blocks[string,params,blocks:outblocks,after]
+{
+	check block <- Comment Left Trim[string, "\n\r\t ", params]
+	If[[check block]Starts With[[params]Block Begin >>]]
+	{
+		,begin block <- [check block]Slice[[[params]Block Begin >>]Length]
+		trees, after block <- Worker Body[begin block, params, ()]
+		outblocks, after <- Get Expression Blocks[after block, params, [blocks]Append[trees]]
+	}{
+		If[[check block]Starts With[[params]Empty Block >>]]
+		{
+			outblocks <- blocks
+			,after <- [check block]Slice[[[params]Empty Block >>]Length]
+		}{
+			outblocks <- blocks
+			after <- Val[check block]
+		}
+	}
+}
+
+Parse Escape[string,params:char,after]
+{
+	code,rest <- [string]Slice[1]
+	If[[code] = [[params]Hex Escape >>]]
+	{
+		hex,after <- [rest]Slice[2]
+		char <- String[[Array[]]Append[Trunc UInt8[Abs UInt[Hex Int32[hex]]]]]
+	}{
+		after <- Val[rest]
+		char <- [[params]Escape Map >>]Index[code] {}
+		{
+			char <- Val[code]
+		}
+	}
+}
+
+Parse String[string,params,current:value,after]
+{
+	delims <- [[()]Append[[params]String End >>]]Append[[params]String Escape >>]
+	afters, before, delim <- [string]Get Comment DString[delims, params]
+	{
+		If[[delim] = [[params]String End >>]]
+		{
+			value <- [current]Append[before]
+			after <- Val[afters]
+		}{
+			char,after escape <- Parse Escape[afters, params]
+			value,after <- Parse String[after escape, params, [[current]Append[before]]Append[char]]
+		}
+	}
+}
+
+Parse List[string,params,list:value,after]
+{
+	trimmed <- Comment Left Trim[string, "\r\n\t ", params]
+	If[[trimmed]Starts With[[params]List End >>]]
+	{
+		value <- list
+		,after <- [trimmed]Slice[[[params]List End >>]Length]
+	}{
+		If[[trimmed]Starts With[[params]List Delim >>]]
+		{
+			,el string <- [trimmed]Slice[[[params]List Delim >>]Length]
+		}{
+			el string <- Val[trimmed]
+		}
+		element,after el <- Named Pipe or Literal[el string, params]
+		value,after <- Parse List[after el, params, [list]Append[[element]Get Value]]
+	}
+}
+
+Get Value@Literal Node[node:out]
+{
+	out <- [node]Value >>
+}
+
+Get Value@Named Pipe Node[node:out]
+{
+	out <- node
+}
+
+Machine Integer[val, size, signed?:out]
+{
+	conv <- [[[[[[[[()
+	]Append[UInt8[?]]
+	]Append[Int8[?]]
+	]Append[UInt16[?]]
+	]Append[Int16[?]]
+	]Append[UInt32[?]]
+	]Append[Int32[?]]
+	]Append[UInt64[?]]
+	]Append[Int64[?]]
+	
+	base idx <- [[(8,16,32,64)]Find[=[size,?]]]*[2]
+	
+	If[signed?]
+	{
+		idx <- [base idx]+[1]
+	}{
+		idx <- Val[base idx]
+	}
+	out <- [[conv]Index[idx]]Call[val]
+}
+
+Parse Number[string,params:value,after]
+{
+	delims <- [[[[(" ","\t","\n","\r")]Append[[params]List Delim >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List End >>]
+	after delim,valstring <- [string]Get Comment DString[delims, params] {} {}
+	{
+		after <- [~]Append[after delim]
+	}{
+		after <- ""
+	}
+	first two,rest <- [valstring]Slice[2]
+	If[[first two] = ["0x"]]
+	{
+		value <- Hex Int32[rest]
+	}{
+		If[[valstring]Contains["."]]
+		{
+			value <- Real64[valstring]
+		}{
+			size, val, type <- [valstring]Get DString[("i","u")]
+			{
+				value <- Machine Integer[val, Int32[size], [type]=["i"]]
+			} {} {} {
+				value <- Int32[valstring]
+			}
+		}
+	}
+}
+
+Parse Params@Type Instance[literal,params,string:out,after]
+{
+	plist,after <- Parse List[string,params,()]
+	out <- [literal]Params <<[plist]
+}
+
+Named Pipe or Literal[string,params:out,after]
+{
+	name <- Comment Left Trim[string, "\n\r\t ", params]
+	If[[name]Starts With[[params]String Begin >>]]
+	{
+		,string begin <- [name]Slice[[[params]String Begin >>]Length]
+		value,after <- Parse String[string begin, params, ""]
+	}{
+		If[[name]Starts With[[params]List Begin >>]]
+		{
+			,list start <- [name]Slice[[[params]List Begin >>]Length]
+			value,after <- Parse List[list start, params, ()]
+		}{
+			If[[[name]Slice[1]]In["-0123456789"]]
+			{
+				value,after <- Parse Number[name, params]
+			}{
+				delims <- [[[[[[[("\n")]Append[[params]Block Begin >>]]Append[[params]Block End >>]]Append[[params]Empty Block >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]]Append[[params]List End >>]]Append[[params]List Begin >>]
+				afterdelim,raw before,delim,nodelim <- [name]Get Comment DString[delims, params] {} {} {}
+				{ delim <- "" }
+
+				before <- Trim[raw before, "\r\n\t "]
+				If[[delim] = [[params]List Begin >>]]
+				{
+					value,after <- [Type Instance[before]]Parse Params[params,afterdelim]
+				}{
+					Val[afterdelim]
+					{
+						after <- [delim]Append[~]
+					}
+					Val[nodelim]
+					{
+						after <- ""
+					}
+					If[[before] = ["Yes"]]
+					{
+						yesno <- Yes
+					}{
+						If[[before] = ["No"]]
+						{
+							yesno <- No
+						}{
+							If[[before] = [""]]
+							{
+								Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]]
+								{ Print[["Near: "]Append[ [afterdelim]Slice[80]]] }
+							}{
+								If[[before]Contains[[params]Global Separator >>]]
+								{
+									parts <- [before]Split[[params]Global Separator >>]
+									out <- Global Node[Right Trim[[parts]Index[0],"\r\n\t "], Trim[[parts]Index[1], "\r\n\t "]]
+								}{
+									out <- Named Pipe Node[Right Trim[before,"\r\n\t "]]
+								}
+							}
+						}
+					}
+					out <- Literal Node[yesno]
+				}
+			}
+		}
+	}
+	out <- Literal Node[value]
+}
+
+Parse Arguments[string,params,arglist:args,after]
+{
+	targs <- Comment Left Trim[string, "\r\n\t ", params]
+	If[[targs]Starts With[[params]List Delim >>]]
+	{
+		[targs]Slice[[[params]List Delim >>]Length] {} 
+		{
+			final args <- Comment Left Trim[~, "\r\n\t ", params]
+		}
+	}{
+		If[[targs]Starts With[[params]Arg End >>]]
+		{
+			args <- arglist
+			,after <- [targs]Slice[[[params]Arg End >>]Length]
+		}{
+			final args <- Val[targs]
+		}
+	}
+	arg, after arg <- Parse Expression[final args, params]
+	args, after <- Parse Arguments[after arg, params, [arglist]Append[arg]]
+}
+
+Worker or Field[name,args,params:out]
+{
+	get field <- [params]Get Field >>
+	If[[name]Ends With[get field]]
+	{
+		field <- Right Trim[[name]Slice[[[name]Length] - [[get field]Length]], "\n\r\t "]
+		out <- Field Node[field, args, No]
+	}{
+		set field <- [params]Set Field >>
+		If[[name]Ends With[set field]]
+		{
+			field <- Right Trim[[name]Slice[[[name]Length] - [[set field]Length]], "\n\r\t "]
+			out <- Field Node[field, args, Yes]
+		}{
+			out <- Worker Node[name, args]
+		}
+	}
+}
+
+Prefix[string,params,name,existing args:expression,after]
+{	
+	//Parse argument list
+	more args,after <- Parse Arguments[string, params, existing args]
+	expression <- Worker or Field[name, more args, params]
+}
+
+Postfix or Infix[string,params:expression,after]
+{
+	args, after args <- Parse Arguments[string, params, ()]
+	delims <- [[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Empty Block >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]
+	aftere,before,delim <- [after args]Get Comment DString[delims, params]
+	{
+		If[[delim] = [[params]Arg Begin >>]]
+		{
+			expression, after <- Prefix[aftere, params, Trim[before,"\r\n\t "], args]
+		}{
+			If[[delim] = [[params]Empty Block >>]]
+			{
+				after <- Val[aftere]
+			}{
+				,after <- [after args]Slice[[before]Length]
+			}
+			expression <- Worker or Field[Trim[before,"\r\n\t "], args, params]
+		}
+	}
+}
+
+Parse Expression[trimmed,params:final expression,after blocks]
+{
+	delims <- [[[[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Arg End >>]]Append[[params]Assign >>]]Append["\n"]]Append[[params]Empty Block >>]]Append[[params]Block End >>]]Append[[params]String Begin >>]
+	after, before, delim <- [trimmed]Get Comment DString[delims, params]
+	{
+		//If we find an arg begin token, we have a worker expression
+		If[[delim] = [[params]Arg Begin >>]]
+		{
+			maybe name <- Right Trim[before, "\r\t "]
+			//Prefix expressions will have the worker name before the first arg begin token
+			If[[maybe name] = [""]]
+			{
+				expression, after expression <- Postfix or Infix[after, params]
+			}{
+				If[[maybe name]Contains[[params]List Delim >>]]
+				{
+					after expression <- [after literal]Append[[delim]Append[after]]
+					expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
+				}{
+					expression, after expression <- Prefix[after, params, maybe name, ()]
+				}
+			}
+		}{
+			If[[delim] = [[params]Assign >>]]
+			{
+				//Expressions starting with an assignment can be prefix, postfix or infix
+				//or they can be a simple literal or named pipe
+				assignments <- Map[[before]Split[[params]List Delim >>], Trim[?,"\n\r\t "]]
+				,after blocks <- Parse Expression[Comment Left Trim[after, " \n\r\t", params], params]
+				{
+					final expression <- [~]Assignments <<[assignments]
+				}
+			}{
+				//If[[delim] = [[params]String Begin >>]]
+				//{
+				//	If[[Trim[before, "\r\n\t "]] = [""]]
+				//	{
+				//		expression, after expression <- Named Pipe or Literal[[delim]Append[after], params]
+				//	}{
+				//		after expression <- [after literal]Append[[delim]Append[after]]
+				//		expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
+				//	}
+				//}{
+				//	after expression <- [after literal]Append[[delim]Append[after]]
+				//	expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
+				//}
+				expression, after expression <- Named Pipe or Literal[trimmed, params]
+			}
+		}
+		//Any expression can be followed by one or more blocks mapping the inputs of other expressions
+		//to the outputs of the current one
+		blocks,after blocks <- Get Expression Blocks[after expression, params, ()]
+		final expression <- [expression]Blocks <<[blocks]
+	}
+}
+
+Worker Body[string,params,trees:outtrees,after end]
+{
+	trimmed <- Comment Left Trim[string, "\n\r\t ", params]
+	If[[trimmed]Starts With[[params]Block End >>]]
+	{
+		//We're done with this block, return
+		,after end <- [trimmed]Slice[[[params]Block End >>]Length]
+		outtrees <- trees
+	}{
+		expression, after expression <- Parse Expression[trimmed, params]
+		outtrees,after end <- Worker Body[after expression, params, [trees]Append[expression]]
+	}
+}
+
+Process Modifiers[worker,params,modifiers:out]
+{
+	//Eventually this will need to be more sophisticated to handle more modifiers
+	trimmed <- Comment Left Trim[modifiers, "\n\r\t ", params]
+	If[[trimmed]Starts With[[params]Uses >>]]
+	{
+		,after uses <- [trimmed]Slice[[[params]Uses >>]Length]
+		,stores string <- [after uses]Get Comment DString["\n", params]
+		out <- [worker]Uses Stores <<[Map[[stores string]Split[[params]List Delim >>], Trim[?, "\r\n\t "]]]
+	}{
+		out <- worker
+	}
+}
+
+Remove Named Pipe Node[element:out]
+{
+	If[[Blueprint Of[element]] = [Named Pipe Node()]]
+	{
+		out <- [element]Name >>
+	}{
+		If[[Blueprint Of[element]] = [Type Instance()]]
+		{
+			out <- [element]Params <<[ Map[[element]Params >>, Remove Named Pipe Node[?]] ]
+		}{
+			out <- element
+		}
+	}
+}
+
+Parse Param List[text,paramlist,typelist,params:out params,out types]
+{
+	delims <- [[()]Append[[params]List Begin >>]]Append[[params]List Delim >>]
+	after,param name <-[text]Get DString[delims] {}
+	{
+		tname <- Trim[~, "\r\n\t "]
+		If[[tname] = [""]]
+		{
+			nextlist <- Val[paramlist]
+			next types <- Val[typelist]
+		}{
+			nextlist <- [paramlist]Append[tname]
+			next types <-  [typelist]Append[paramtype]
+		}
+	}{
+		If[[~] = [[params]List Begin >>]]
+		{
+			type info,after type <- Parse List[after,params,()]
+			type <- [type info]Index[0]
+			{
+				If[[Blueprint Of[~]] = [Named Pipe Node()]]
+				{
+					before variant <- Type Instance[[type]Name >>]
+				}{
+					before variant <- <- [type]Params <<[ Map[[type]Params >>, Remove Named Pipe Node[?]] ]
+				}
+				variant <- [type info]Index[1]
+				{
+					,warn <- If[[Blueprint Of[~]] = [Named Pipe Node()]]
+					{
+						before mutable,warn <- [before variant]Set Variant[[variant]Name >>]
+					}
+					Val[warn]
+					{
+						Print[[[["Warning: Invalid variant for type "]Append[[before variant]Name >>]]Append[" on input "]]Append[param name]]
+						before mutable <- Val[before variant]
+					}
+				}{
+					before mutable <- Val[before variant]
+				}
+				[type info]Index[2]
+				{
+					paramtype <- [before mutable]Mutable? <<[ [[~]Name >>] = ["Mutable"] ]
+				}{
+					paramtype <- Val[before mutable]
+				}
+			}{
+				paramtype <- Type Instance["Any Type"]
+			}
+			[after type]Get DString[","]
+			{
+				out params,out types <- Parse Param List[~,nextlist,next types,params]
+			} {} {} {
+				out params <- Val[nextlist]
+				out types <- Val[next types]
+			}
+		}{
+			paramtype <- Type Instance["Any Type"]
+			out params,out types <- Parse Param List[after,nextlist,next types,params]
+		}
+		
+	}{
+		paramtype <- Type Instance["Any Type"]
+		out params <- Val[nextlist]
+		out types <- Val[next types]
+	}
+}
+
+Worker Declaration[string,params:worker,rest,no match]
+{
+	,whitespace name <- [string]Get Comment DString[[params]Arg Begin >>, params]
+	{
+		worker name <- Trim[whitespace name, "\n\r\t "]
+		in out <- [params]In Out Delim >>
+		arg end <- [params]Arg End >>
+		delims <- [[()]Append[in out]]Append[arg end]
+		after <- [~]Get Comment DString[delims, params] {} 
+		{
+			arglist <- Trim[~,"\r\n\t "]
+		}{
+			//check if there is an in/out separator
+			//if it isn't present, everything in the arglist is an input
+			If[[~] = [in out]]
+			{
+				rest <- [after]Get Comment DString[arg end, params] {}
+				{
+					outputs,output types <- Parse Param List[~, (), (), params]
+				}
+			}{
+				rest <- Val[after]
+				outputs <- ()
+				output types <- ()
+			}
+			inputs,input types <- Parse Param List[arglist, (), (), params]
+			worker <- Parse Worker[worker name, inputs, outputs, input types, output types, 0]
+		}
+	}{}{}{
+		no match <- string
+	}
+}
+
+Worker Name[string,params,tree,lines:out]
+{
+	,after arglist <- Worker Declaration[string, params]
+	{
+		worker name <- [~]Name >>
+		body text, modifiers <- [after arglist]Get Comment DString[[params]Block Begin >>, params]
+		modified <- Process Modifiers[~, params, modifiers]
+		expression trees, after body <- Worker Body[body text, params, ()]
+		worker <- [modified]Trees <<[expression trees]
+		new worker dict <- [[tree]Workers >>]Set[worker name, worker]
+		out <- Null[after body, params, [tree]Workers <<[new worker dict], 0]
+	} {} {
+		out <- tree
+	}
+}
+
+Parse Foreign Worker[tree, string, lib, params:out]
+{
+	,rest <- Worker Declaration[string, params]
+	{
+		foreign <- [~]Trees << [lib]
+		next <- [tree]Workers << [[[tree]Workers >>]Set[[foreign]Name >>, foreign]]
+		out <- Parse Foreign Worker[next, rest, lib, params]
+	} {} {
+		out <- tree
+	}
+}
+
+Parse Foreign[string,params,tree,lines:out]
+{	
+	,after foreign <- [string]Slice[[[params]Foreign >>]Length]
+	[after foreign]Get Comment DString[[params]Blueprint Type Delim >>, params]
+	{
+		[~]Get Comment DString[[params]Block Begin >>, params]
+		{
+			rest, body <- [~]Get Comment DString[[params]Block End >>, params]
+		}
+		{ lib <- Trim[~, "\r\n\t "] }
+	}
+	{ language <- Trim[~, "\r\n\t "] }
+	Parse Foreign Worker[tree, body, New Foreign Lib[language, lib], params]
+	{ 
+		out <- Null[rest, params, ~, 0]
+	}
+}
+
+Parse Global Vars[string,params,store:out]
+{
+	trimmed <- Left Trim[string, "\r\n\t "]
+	If[trimmed]
+	{
+		,,after <- [trimmed]Partition[[params]Assign >>]
+		{
+			varname <- Right Trim[~, "\r\n\t "]
+		} {} {
+			valstring <- [~]Partition["\n"] {} {} 
+			{
+				out <- Parse Global Vars[~,params,next store]
+			}{
+				valstring <- Val[after]
+				out <- Val[next store]
+			}
+			Val[valstring]
+			{
+				Print[["Parsing initial value: "]Append[valstring]]
+				value <- [Named Pipe or Literal[Trim[~, "\r\n\t "], params]]Value >>
+				next store <- [store]Vars <<[ [[store]Vars >>]Set[varname, value] ]
+			}
+		}{
+			Print[["Expected assignment operator in global var block, found "]Append[trimmed]]
+		}
+	}{
+		out <- store
+	}
+}
+
+Parse Globals[string,params,tree,lines:out]
+{
+	,after globals <- [string]Slice[[[params]Globals >>]Length]
+	[after globals]Partition[[params]Block Begin >>]
+	{
+		store <- Global Store[Trim[~, "\r\n\t "]]
+	} {} {
+		
+		[~]Partition[[params]Block End >>]
+		{
+			next tree <- [tree]Add Global Store[Parse Global Vars[~, params, store]]
+		} {} {
+			out <- Null[~,params,next tree,lines]
+		}{
+			Print["Error: Globals declaration missing block close symbol"]
+			out <- tree
+		}
+	} {
+		Print["Error: Globals declaration without block"]
+		out <- tree
+	}
+}
+
+
+Null[string,params,tree,lines:out]
+{
+	trimmed <- Comment Left Trim[string, " \n\r\t", params]
+	current line <- 0
+	If[[trimmed]Starts With[ [params]Blueprint >> ]]
+	{
+		out <- PBlueprint[trimmed, params, tree, current line]
+	}{
+		If[[trimmed]Starts With[ [params]Import >> ]]
+		{
+			out <- Parse Import[trimmed, params, tree, current line]
+		}{
+			If[[trimmed]Starts With[ [params]Foreign >> ]]
+			{
+				out <- Parse Foreign[trimmed, params, tree, current line]
+			}{
+				If[[trimmed]Starts With[[params]Globals >>]]
+				{
+					out <- Parse Globals[trimmed, params, tree, current line]
+				}{
+					If[trimmed]
+					{
+						out <- Worker Name[trimmed, params, tree, current line]
+					}{
+						out <- tree
+					}
+				}
+			}
+		}
+	}
+}
+
+Check Worker Literals@Parse Worker[worker,program:out]
+{
+	[(List(),List Leaf())]Find[=[Blueprint Of[[worker]Trees >>], ?]]
+	{
+		out <- [worker]Trees <<[ Map[[worker]Trees >>, Check Worker Literals[?, program]] ]
+	}{
+		out <- worker
+	}
+}
+
+Register Workers Compile[prog, worker, name:out]
+{
+	//Print[["Registering "]Append[name]]
+	If[[ Blueprint Of[[worker]Trees >>] ] = [Foreign Lib()]]
+	{ convention <- Val[[[worker]Trees >>]Language >>] }
+	{ convention <- "rhope" }
+	out <- [prog]Register Worker[name, convention, [[worker]Inputs >>]Length, [[worker]Outputs >>]Length]
+}
+
+Add Workers Compile[prog, worker, name:out]
+{
+	Print[["Transforming "]Append[name]]
+		If[[Blueprint Of[[worker]Trees >>]] = [Foreign Lib()]]
+		{
+			//TODO: Handle foreign func
+			final nworker <- [[[[[NWorker[[[worker]Trees >>]Language >>]
+			]Inputs <<[ [worker]Inputs >> ]
+			]Input Types <<[ [worker]Input Types >> ]
+			]Outputs <<[ [worker]Outputs >> ]
+			]Output Types <<[ [worker]Output Types >> ]
+			]Library <<[ [[worker]Trees >>]Name >> ]
+			
+		}{
+			assigned <- Fold[_Get Assigned Pipes[?], Dictionary[], [worker]Trees >>]
+			trees, nworker, refs <- Add List to Worker[[worker]Trees >>, [[NWorker["rhope"]]Uses[[worker]Uses Stores >>]]Outputs <<[ [worker]Outputs >> ], prog, [worker]Assigned <<[assigned], Dictionary[]]
+			{
+				final nworker <- Fold[Add Wires Helper[?, ?, ?, worker, refs], nworker, trees]
+			}
+			
+		}
+		out <- [prog]Bind Worker[name, final nworker]
+}
+
+Add Wires Helper[worker,node,unused,parse worker,assignments:out]
+{
+	out <- [node]Add Wires[worker, (), parse worker, assignments]
+}
+
+Add Blueprint Field[blueprint,field,unused:out]
+{
+	out <- [blueprint]Add Field[[field]Name >>, [field]Type >>]
+}
+
+Add Blueprint Compile[prog,def:out]
+{
+	out <- [prog]Bind Blueprint[[def]Name >>, Fold[Add Blueprint Field[?], NBlueprint[], [def]Fields >>]]
+}
+
+Tree to Program Native[parse tree,number types:out]
+{
+	registered <- Fold[Register Workers Compile[?], [Fold[Add Blueprint Compile[?], [[NProgram[]]Numtypes <<[number types]]Global Stores <<[[parse tree]Global Stores >>], [parse tree]Blueprints >>]]Register Builtins, [parse tree]Workers >>]
+	out <- Fold[Add Workers Compile[?], registered, [parse tree]Workers >>]
+	{ Print["Transformed AST to dataflow graph "] }
+}
+
+Needs Imports[needs import,not imported?,name:out]
+{
+	If[not imported?]
+	{
+		out <- [needs import]Append[name]
+	}{
+		out <- needs import
+	}
+}
+
+Do Import[tree,file name,unused,params:out]
+{
+	Print[["Parsing: "]Append[file name]]
+	file <- [File[file name]]Open["r"]
+	text <- String[[file]Read[[file]Length]]
+	after import <- Null[text, params, tree, 0]
+
+	out <- [after import]Imports <<[[[after import]Imports >>]Set[file name, No]]
+}
+
+Process Imports[parse tree,params:out]
+{
+	needs import <- Fold[Needs Imports[?], (), [parse tree]Imports >>]
+	If[[[needs import]Length] > [0]]
+	{
+		import tree <- Fold[Do Import[?, ?, ?, params], parse tree, needs import]
+		out <- Process Imports[import tree, params]
+	}{
+		out <- parse tree
+	}
+}
+
+Until End[text:out]
+{
+	line <- Get Input[]
+	If[[line] = ["End"]]
+	{
+		out <- [text]Append["\n"]
+	}{
+		out <- Until End[[[text]Append["\n"]]Append[line]]
+	}
+}
+
+Add If Store[stores,name,params:out]
+{
+	If[[name]Contains[[params]Global Separator >>]]
+	{
+		parts <- [name]Split[[params]Global Separator >>]
+		out <- [stores]Set[[parts]Index[0], Yes]
+	}{
+		out <- stores
+	}
+}
+
+Param Gather Stores[stores,node,params:out]
+{
+	out <- [node]Gather Stores[params, stores]
+}
+
+Gather Stores@Named Pipe Node[node,params,stores:out]
+{
+	out <- Fold[Add If Store[?, ?, params], stores, [node]Assignments >>]
+}
+
+Gather Stores@Global Node[node,params,stores:out]
+{
+	out <- [stores]Set[[node]Store >>, Yes]
+}
+
+Gather Stores@Worker Node[node,params,stores:out]
+{
+	//TODO: Handle blocks
+	store list <- Fold[Param Gather Stores[?, ?, params], stores, [node]Params >>]
+	out <- Fold[Add If Store[?, ?, params], store list, [node]Assignments >>]
+}
+
+Gather Stores@Field Node[node,params,stores:out]
+{
+	//TODO: Handle blocks
+	store list <- Fold[Param Gather Stores[?, ?, params], stores, [node]Params >>]
+	out <- Fold[Add If Store[?, ?, params], store list, [node]Assignments >>]
+}
+
+Gather Stores@Literal Node[node,params,stores:out]
+{
+	out <- Fold[Add If Store[?, ?, params], stores, [node]Assignments >>]
+}
+
+