Mercurial > repos > rhope

changeset 167:690ed78ead8a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Some type inference fixes and make method calls into regular calls when first arg type is known at compile time
author Mike Pavone <pavone@retrodev.com>
date Mon, 04 Apr 2011 01:41:19 -0400
parents 1bfc19076f1b
children d2b941f82d74
files nworker_c.rhope
diffstat 1 files changed, 135 insertions(+), 82 deletions(-) [+]
line wrap: on
line diff
--- a/nworker_c.rhope	Thu Mar 10 04:16:38 2011 +0000
+++ b/nworker_c.rhope	Mon Apr 04 01:41:19 2011 -0400
@@ -223,12 +223,13 @@
 
 _Has Input Types@NWorker Node[node,input num:does,does not]
 {
-	does <- If[[input num] > [[node]Inputs >>]] {}
+	does <- If[[input num] >= [[node]Inputs >>]] {}
 	{
 		,does not <- [[node]Input Types >>]Index[input num]
 		{
+			Print[[[[[["Input: "]Append[String[input num]]]Append[", count: "]]Append[String[count]]]Append[", wires: "]]Append[String[[[[node]Wires To >>]Index[ [input num]+[1] ]]Length]]]
 			count <- [~]Index[1]
-			,does not <- If[[count] = [[[[node]Wires To >>]Index[input num]]Length]]
+			,does not <- If[[count] = [[[[node]Wires To >>]Index[[input num]+[1]]]Length]]
 			{
 				does,does not <- [node]_Has Input Types[[input num]+[1]]
 			}
@@ -241,6 +242,8 @@
 	If[[[node]Inputs >>] > [0]]
 	{
 		does,does not <- _Has Input Types[node,0]
+		{ Print["does have input types"] }
+		{ Print["does not have input types"] }
 	}{
 		does <- Yes
 	}
@@ -323,53 +326,76 @@
 
 Propagate Type[nodelist,dest,prog,worker,type:out]
 {
-	node <- [nodelist]Index[[dest]Index >>]
-	
-	[[node]Input Types >>]Index[[dest]IO Num >>]
+	If[[[dest]IO Num >>] >= [0]]
 	{
-		existing type <- [~]Index[0]
-		new count <- [[~]Index[1]]+[1]
-		If[[[existing type]Name >>] = [[type]Name >>]]
-		{
-			If[[[existing type]Variant >>] = [[type]Variant >>]]
+		Print[[[["Propagate Type, Index: "]Append[String[[dest]Index >>]]]Append[" io num: "]]Append[String[[dest]IO Num >>]]]
+		node <- [nodelist]Index[[dest]Index >>]
+	
+		[[node]Input Types >>]Index[[dest]IO Num >>]
+		{	
+			Print[["Existing type: "]Append[[existing type]Name >>]]
+			existing type <- [~]Index[0]
+			new count <- [[~]Index[1]]+[1]
+			If[[[existing type]Name >>] = [[type]Name >>]]
 			{
-				If[[[existing type]Params >>] = [[type]Params >>]]
+				If[[[existing type]Variant >>] = [[type]Variant >>]]
 				{
-					new type <- Val[existing type]
+					If[[[existing type]Params >>] = [[type]Params >>]]
+					{
+						new type <- Val[existing type]
+					}{
+						new variant <- [existing type]Variant >>
+						new params <- ()
+					}
 				}{
-					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 variant <- "Boxed"
-				If[[[existing type]Params >>] = [[type]Params >>]]
-				{
-					new params <- [existing type]Params >>
-				}{
-					new params <- ()
-				}
+				new type <- Type Instance["Any Type"]
 			}
-			new type <- [[existing type]Set Variant[new variant]]Params <<[new params]
 		}{
-			new type <- Type Instance["Any Type"]
+			Print["No existing type info for this input"]
+			new type <- Val[type]
+			new count <- 1
 		}
+		Print[[[["new type: "]Append[[new type]Name >>]]Append[", new count: "]]Append[String[new count]]]
+		new node <- [node]Input Types <<[  		
+			[ [node]Input Types >> ]Set[ [dest]IO Num >>, [[()]Append[new type]]Append[new count] ]
+		]
+		{ Print["got new node"] }
+		out <- Infer Types Node[[nodelist]Set[[dest]Index >>, new node], new node, [dest]Index >>, prog, worker]
 	}{
-		new type <- Val[type]
-		new count <- 1
+		out <- nodelist
 	}
-	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[?, ?, prog, worker, [[source node]Output Types >>]Index[output num]], nodelist, dests]
+	[[source node]Output Types >>]Index[output num]
+	{
+		out <- Fold[Propagate Type[?, ?, prog, worker, ~], nodelist, dests]
+	}{
+		Print[["Output type is missing for output #"]Append[String[output num]]]
+		out <- nodelist
+	}
 }
 
 Infer Types Node[nodelist,node,index,prog,worker:out]
 {
+	If[[[node]Type >>]=["call"]]
+	{
+		extra <- [", worker: "]Append[[[node]Data >>]Name >>]
+	}{
+		extra <- ""
+	}
+	Print[[[[["Infer Types Node: "]Append[String[index]]]Append[", type: "]]Append[[node]Type >>]]Append[extra]]
 	If[[[node]Type >>] = ["const"]]
 	{
 		const type <- Blueprint Of[[node]Data >>]
@@ -384,76 +410,95 @@
 		nextnode <- [node]Output Types <<[ [()]Append[Type Instance[outtype]] ]
 		
 	}{
-		If[[[node]Type >>] = ["input"]]
+		If[[[node]Type >>] = ["setglobal"]]
 		{
-			nextnode <- [node]Output Types <<[ [()]Append[ [[worker]Input Types >>]Index[[node]Data >>] ] ]
+			out <- nodelist
 		}{
-			If[[[node]Type >>] = ["output"]]
+			If[[[node]Type >>] = ["input"]]
 			{
-				out <- nodelist
-
+				nextnode <- [node]Output Types <<[ [()]Append[ [[worker]Input Types >>]Index[[node]Data >>] ] ]
 			}{
-				If[[[node]Type >>] = ["getglobal"]]
+				If[[[node]Type >>] = ["output"]]
 				{
-					nextnode <- [node]Output Types <<[ [()]Append[Type Instance["Any Type"]] ]
+					out <- nodelist
+
 				}{
-					[node]Has Input Types?
+					If[[[node]Type >>] = ["getglobal"]]
 					{
-						If[[[node]Type >>] = ["setfield"]]
+						nextnode <- [node]Output Types <<[ [()]Append[Type Instance["Any Type"]] ]
+					}{
+						[node]Has Input Types?
 						{
-							nextnode <- [node]Output Types <<[ [()]Append[ [[[node]Input Types >>]Index[0]]Index[0] ] ]
-						}{
-							If[[[node]Type >>] = ["getfield"]]
+							If[[[node]Type >>] = ["setfield"]]
 							{
-								type <- [[[node]Input Types >>]Index[0]]Index[0]
-								If[[[type]Name >>] = ["Any Type"]]
+								nextnode <- [node]Output Types <<[ [()]Append[ [[[node]Input Types >>]Index[0]]Index[0] ] ]
+							}{
+								If[[[node]Type >>] = ["getfield"]]
 								{
-									outtype <- Val[type]
-								}{
-									outtype <- [prog]Find Field[[node]Data >>, type] {}
+									type <- [[[node]Input Types >>]Index[0]]Index[0]
+									If[[[type]Name >>] = ["Any 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[?, Type Instance["Any Type"]], (), Range[0, [node]Inputs >>]]
+										outtype <- Val[type]
 									}{
-										worker def <- [prog]Find Method[worker name, first arg type] {}
+										outtype <- [prog]Find Field[[node]Data >>, type] {}
 										{
-											//TODO: Return errors instead of printing them
+											//TODO: Return errors rather than printing them
 											Print[
 												[[[[["Type "
-												]Append[[first arg type]Name >>]
-												]Append[" does not support method "]
-												]Append[worker name]
+												]Append[[type]Name >>]
+												]Append[" does not have a field named "]
+												]Append[[node]Data >>]
 												]Append[" in worker "]
-												]Append[ [worker]Name >> ]]
+												]Append[worker name]]
 										}
 									}
+									nextnode <- [node]Output Types <<[ [()]Append[outtype] ]
 								}{
-									worker def <- [prog]Find Worker Def[worker name]
+									worker name <- [[node]Data >>]Name >>
+									[prog]Is Method?[worker name]
+									{
+										Print[[["Infer Types: "]Append[worker name]]Append[" is a method"]]
+										first arg type <- [[[node]Input Types >>]Index[0]]Index[0]
+										If[[[first arg type]Name >>] = ["Any Type"]]
+										{
+											Print["No type info for first arg"]
+											outtypes <- Fold[Append[?, Type Instance["Any Type"]], (), Range[0, [node]Inputs >>]]
+											Print[["outtypes length: "]Append[String[Length[outtypes]]]]
+											nextnode <- [node]Output Types <<[ outtypes ]
+										}{
+											worker def <- [prog]Find Method[worker name, first arg type]
+											{
+												new worker name <- [[worker name]Append["@"]]Append[[first arg type]Name >>]
+												new ref <- [prog]Find Worker[new worker name] {} {
+													Print[["Could not find worker ref for "]Append[new worker name]]
+												}
+												nextnode <- [[node]Output Types <<[outtypes]
+													]Data <<[new ref]
+												Print[["New worker name:"]Append[new worker name]]
+											}{
+												//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 >> ]]
+											}
+										}
+									}{
+										Print[[["Infer Types: "]Append[worker name]]Append[" is not a method"]]
+										worker def <- [prog]Find Worker Def[worker name] {}
+										{ Print["Error, could not find worker def"] }
+										nextnode <- [node]Output Types <<[ outtypes ]
+									}
+									outtypes <- [worker def]Output Types >>
 								}
-								outtypes <- [worker def]Output Types >>
-								nextnode <- [node]Output Types <<[ outtypes ]
 							}
+						}{
+							Print["Skipping node because input type info not present"]
+							out <- nodelist
 						}
-					}{
-						out <- nodelist
 					}
 				}
 			}
@@ -463,7 +508,8 @@
 	Val[nextnode]
 	{
 		nextlist <- [nodelist]Set[index, nextnode]
-		out <- Fold[Propagate Types[?, ?, ?, prog, worker, nextnode], nodelist, [nextnode]Wires From >>]
+		{ Print["Calling Propagate types on descdendants of this node"] }
+		out <- Fold[Propagate Types[?, ?, ?, prog, worker, nextnode], nextlist, [nextnode]Wires From >>]
 	}
 }
 
@@ -1318,6 +1364,7 @@
 Add Method@NBlueprint[bp,name:out]
 {
 	out <- [bp]Methods <<[ [[bp]Methods >>]Set[name, Yes] ]
+
 }
 
 Understands Method@NBlueprint[bp,name:out]
@@ -1326,10 +1373,15 @@
 	{ out <- No }
 }
 
+Eq Field Name[field,name:out]
+{
+	out <- [[field]Index[0]]=[name]
+}
+
 Get Field Type@NBlueprint[bp,name:out,notfound]
 {
-	,notfound <- [[bp]Fields >>]Index[name]
-	{ out <- [~]Index[1] }
+	,not found <- [[bp]Fields >>]Find[Eq Field Name[?, name]]
+	{ out <- [[[bp]Fields >>]Index[~]]Index[1] }
 }
 
 _Compile Blueprint Fields[type,field:out]
@@ -1561,10 +1613,11 @@
 {
 	[[prog]Worker Refs >>]Index[name]
 	{
-		ref <- [[[[~]Inputs <<[ Max[[~]Inputs >>, inputs] ]
+		ref <- [[[[[~]Inputs <<[ Max[[~]Inputs >>, inputs] ]
 		]Min Inputs <<[ Min[[~]Min Inputs >>, inputs] ]
 		]Outputs <<[ Max[[~]Outputs >>, outputs] ]
 		]Min Outputs <<[ Min[[~]Min Outputs >>, outputs] ]
+		]Is Method? <<[Yes]
 	}{
 		ref <- Worker Ref[name, convention, inputs, outputs, Yes]
 	}