repos/rhope: nworker.rhope comparison

comparison nworker.rhope @ 69:d0ce696786cc

Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.

author	Mike Pavone <pavone@retrodev.com>
date	Wed, 16 Jun 2010 04:36:08 +0000
parents	d4b44ae2e34a
children	6a1a7d5cc2d9

comparison

equal deleted inserted replaced

-:38d9cd036d49
+:d0ce696786cc
 	out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[variable] ]]Index[0]
 }
 _For Backend Subset[current,subset,type:out]
 {
-	Print["Calling For Backend on subset"]
-	{
 	[subset]For Backend
 	{
-		Print["Got output from for backend"]
 		out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[~] ]]Index[0]
-		{ Print["done _For Backend Subset with condition"] }
+	}{
-	}{
-		Print["none output from for backend"]
 		out <- current
-	}
 	}
 }
 Empty?@Condition Set[set:not empty,empty]
 {
 	}
 }
 For Backend@Condition Set[set:out,none]
 {
-	Print["For Backend"]
 	firstvar <- [[set]Variables >>]First
 	{
-		Print["At least one var"]
 		[[set]Variables >>]Next[~]
 		{
-			Print["at least two vars"]
 			vars <- _Fold[[set]Variables >>, ~, firstvar, ["_For Backend Var"]Set Input[3, [set]Condition Type >>]]
 		}{
-			Print["just one var"]
 			vars <- Val[firstvar]
 		}
 		out <- Fold[["_For Backend Subset"]Set Input[2, [set]Condition Type >>], vars, [set]Subsets >>]
-		{ Print["done For Backend, with vars"] }
+	}{
-	}{
-		Print["no vars"]
 		[[set]Subsets >>]First Non-empty Set
 		{
-			Print[["At least one non-empty subset: "]Append[~]]
 			firstsub <- [[[set]Subsets >>]Index[~]]For Backend
 			[[set]Subsets >>]Next[~]
 			{
-				Print["at least two subsets"]
 				out <- _Fold[[set]Subsets >>, ~, firstsub, ["_For Backend Subset"]Set Input[2, [set]Condition Type >>]]
-				{ Print["done with subsets, but no vars"] }
 			}{
 				out <- Val[firstsub]
-				{ Pretty Print[~, "1s:\t"] }
 			}
 		}{
-			Print["done with none"]
 			none <- Yes
 		}
 	}
 }
 	}
 }
 Infer Types@NWorker[worker,prog:out]
 {
-	Print[["Start inference: "]Append[[worker]Name >>]]
 	out <- [worker]Nodes <<[Fold[[["Infer Types Node"]Set Input[3, prog]]Set Input[4, worker], [worker]Nodes >>, [worker]Nodes >>]]
-	{ Print[["End inference: "]Append[[worker]Name >>]] }
 }
 Add Worker Call@NWorker[worker,tocall:out,node index]
 {
 	out, node index <- [worker]Add Node["call",tocall,[tocall]Inputs >>,[tocall]Outputs >>]
 	out, node index <- [worker]Add Node["setfield",fieldname,2,1]
 }
 Add Wire@NWorker[worker,from,output,to,input:out]
 {
-	Print[[[[[[[[["Add Wire@NWorker["]Append[from]]Append[","]]Append[output]]Append[","]]Append[to]]Append[","]]Append[input]]Append["]"]]
-	{
 	fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output]
-	{ Print["fromw"] }
 	tow <- [[[worker]Nodes >>]Index[to]]Wire To[from,output,input]
-	{ Print["tow"] }
 	nodes <- [[[worker]Nodes >>]Set[from, fromw]]Set[to, tow]
-	{ Print["nodes"] }
 	out <- [worker]Nodes <<[nodes]
-	{ Print["Add Wire@NWorker done"] }
-	}
 }
 Uses@NWorker[worker,uses:out]
 {
 	out <- [worker]Uses <<[uses]
 	out <- [set]Add Condition[Fold[["Collect Input Condition"]Set Input[0, worker], OrSet[], nodeinput]]
 }
 Collect Conditions@NWorker[worker,node:out]
 {
-	Print["Collect Conditions"]
-	{
 	out <- Fold[["Collect Condition"]Set Input[0, worker], AndSet[], [node]Wires To>>]
-	{ Print["done Collect Conditions"] }
-	}
 }
 Save Result[func,num,node index:out]
 {
-	Print["Save Result"]
 	out var <- [[["__result_"]Append[node index]]Append["_"]]Append[num]
-	Print[out var]
 	/*out <- [[func]Allocate Var[out var, "Any Type"]
 		]Move[Result[num], out var]
 	*/
 	out <- [func]Move[Result[num], out var]
 }
 	}{
 		If[[[node]Type >>] = ["setfield"]]
 		{
 			with call <- [func]Set Field Call[[node]Data >>, [inputs]Index[0], [inputs]Index[1]]
 		}{
-			Print[["Call: "]Append[[[node]Data >>]Name >>]]
-			{
 			[program]Method?[[[node]Data >>]Name >>]
 			{
-				Print["Method!"]
 				with call <- [func]Method Call[[[node]Data >>]Name >>, inputs]
-				{ Print["Method Call done"] }
 			}{
-				Print["Function!"]
+				with call <- [func]Call[[[node]Data >>]Name >>, inputs]
-				{
-					Pretty Print[inputs, ""]
-					{ with call <- [func]Call[[[node]Data >>]Name >>, inputs]}
-				}
 			}
-			}
 		}
 	}
 	out <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]]
 }
 Compile Node@NWorker[worker,program,func,nodes,current:out,out worker]
 {
-	Print[["Compile Node: "]Append[[node]Type >>]]
 	node index <- [nodes]Index[current]
 	node <- [[worker]Nodes >>]Index[node index]
 	conditions <- [worker]Collect Conditions[node]
 	[("call","getfield","setfield")]Find[[node]Type >>]
 	{
 		inputs <- [worker]Collect Inputs[node]
 		[conditions]For Backend
 		{
-			Print["Conditional execution, do if"]
 			stream <- [func]Instruction Stream
 			nfunc <- [func]Do If[~, nstream]
 		}{
-			Print["No conditions, full steam ahead"]
 			stream <- Val[func]
 			nfunc <- Val[nstream]
 		}
 		nstream <- Compile Call Node[node, program, stream, inputs, node index]
 	}{
 		If[[[node]Type >>] = ["output"]]
 		{
-			Print["Compiling output node"]
 			inputs <- [worker]Collect Inputs[node]
 			[conditions]For Backend
 			{
-				Print["has conditions"]
 				stream <- [func]Instruction Stream
 				nfunc <- [func]Do If[~, nstream]
 			}{
-				Print["no conditions"]
 				stream <- Val[func]
 				nfunc <- Val[nstream]
 			}
 			nstream <- [stream]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ]
 		}{
 FInputs[ifunc, input type, index, inputs:out]
 {
 	func <- [ifunc]Set Input Type[Make Basic Type[input type], index]
 	name <- [inputs]Index[index]
-	Print[["FInputs: "]Append[index]]
-	Pretty Print[input type, ""]
-	{
 	If[[[input type]Variant >>] = ["Naked"]]
 	{
 		naked <- [" naked"]Append[name]
 			}
 		}{
 			out <- Val[copied]
 		}
 	}
-	}
 }
 FParams[input:out]
 {
 	iname <- [input]Index[0]
 		{ out <- Val[iname] }
 	}
 }
 _Return Param[outputs, inputs, input types, index:out,none]
 {
-	Print[["_Return Param: "]Append[output]]
 	output <- [outputs]Index[index]
 	[inputs]Find[output]
 	{
 		If[[[input types]Index[~]]Mutable? >>]
 		{
 	}
 }
 Return Param[outputs, inputs, input types:out,none]
 {
-	Print["Return Param"]
 	,none <- [outputs]First
 	{ out,none <- _Return Param[outputs, inputs, input types, ~] }
 }
 	}
 }
 Compile Foreign Stub[worker,program,name:out]
 {
-	Print[["Compiling FFI stub for "]Append[name]]
 	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 >>]
 	{
 	{
 		out <- program
 	}{
 		If[[[worker]Library >>] = [""]]
 		{
-			Print[["Compiling: "]Append[name]]
-			{
 			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 >>]
 			res vars <- [worker]Result Vars
 			func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [worker]Outputs >>]
 				final func <- [worker]Compile Group[program,func,groups, ~]
 			}{
 				final func <- Val[func]
 			}
 			out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, worker], final func, res vars], [worker]Inputs >>]]
-			}
 		}{
 			out <- Compile Foreign Stub[worker,[program]Link[[worker]Convention >>, [worker]Library >> ],name]
 		}
 	}
 }
 }
 Make Init[func,field:out]
 {
 	name <- [field]Index[0]
-	Print[["Field: "]Append[name]]
-	{ Print[["  Variant: "]Append[variant]] }
 	variant <- [[field]Index[1]]Variant >>
 	If[[variant] = ["Boxed"]]
 	{
 		out <- [func]Set Field Null["obj", name]
-		{ Print["done"] }
 	}{
 		out <- func
 	}
 }
 	}
 }
 Make Special@NBlueprint[bp,backend,func name,bp name,pop worker:out]
 {
-	Print[[["Make Special: "]Append[func name]]Append[bp name]]
 	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
-	Print[["Getters Setters: "]Append[name]]
 	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]
 	If[[[type]Variant >>] = ["Boxed"]]
 	{
 		getter <- [[start getter]Do AddRef[getref, "out"]]Release["obj"]
 	}{
 		getter <- [[start getter]Box[getref, "out", type]]Release["obj"]
-		{ Print["Got getter"] }
 	}
 	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]
 			,setref <- [[~]Do If[origref, stream]
 			]Write Field["obj", name]
 			{
 				setter <- [[~]Move["newval", setref]
 				]Move["obj", "out"]
-				{ Print["got setter"] }
 			}
 		}
 	}{
 		,setref <- [begin setter]Write Field["obj", name]
 		{
 			setter <- [[~]Unbox["newval", setref]
 			]Move["obj", "out"]
-			{ Print ["got setter"] }
 		}
 	}
 	out <- [[backend]Store Function[getter]]Store Function[setter]
 }
 Compile Blueprint@NBlueprint[bp,backend,name:out]
 {
-	Print[["Compiling blueprint: "]Append[name]]
 	//Rhope identifiers can't start with spaces, so we can use identifiers that start with spaces for special functions
 	init name <- [" init "]Append[name]
 	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]
-	{ Print["Created type on backend"] }
 	out <- [backend]Register Type[type]
 }
 Compile Special@NBlueprint[bp,backend,name:out]
 	}
 }
 Bind Blueprint@NProgram[prog,name,blueprint:out]
 {
-	Print[["Bind blueprint: "]Append[name]]
 	out <- [prog]Blueprints << [ [[prog]Blueprints >>]Set[name, blueprint] ]
 }
 _Compile Program BP[backend, blueprint, name:out]
 {
 	out <- [blueprint]Compile Special[backend, name]
 }
 _Compile Program[backend, worker, name:out]
 {
-	Print["_Compile Program"]
 	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 >>]]]
-	{ Print["All blueprints added"] }
 	workers with infer <- SMap[[prog]Workers >>, ["Infer Types"]Set Input[1, prog]]
-	{ Print["Type inference complete"] }
 	out <- Fold["_Compile Program", backend with bps,  workers with infer]
 }
 Register Method@NProgram[prog, name, convention, inputs, outputs: out]
 {
 	out <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs, Yes]]]
 }
 Register Worker@NProgram[prog, name, convention, inputs, outputs: out]
 {
-	Print[["Register Worker "]Append[name]]
 	after reg <- [prog]Worker Refs <<[
 		[ [prog]Worker Refs >> ]Set[name,
 			Worker Ref[name, convention, inputs, outputs, No]
 		]
 	]
 		]Builtin? <<[Yes]]
 }
 Find Worker@NProgram[prog, name:out,notfound]
 {
-	Print[ ["Find Worker@NProgram: "]Append[name] ]
 	out,notfound <- [[prog]Worker Refs >>]Index[name]
 }
 Find Worker Def@NProgram[prog,name:out,notfound]
 {

Mercurial > repos > rhope

comparison nworker.rhope @ 69:d0ce696786cc