repos/rhope: nworker.rhope annotate

annotate nworker.rhope @ 30:914ad38f9b59

Compiler now works for some simple programs

author	Mike Pavone <pavone@retrodev.com>
date	Mon, 28 Sep 2009 19:42:33 -0400
parents	e9272f7ebd26
children	df038cef648b

rev	line source
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	1 Import extendlib.rhope
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	2 Import cbackend.rhope
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	3
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	4
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	5 Blueprint Condition Set
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	6 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	7 Variables
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	8 Subsets
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	9 Condition Type
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	10 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	11
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	12 AndSet[:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	13 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	14 out <- [[[Build["Condition Set"]]Variables <<[New@Dictionary[]]]Subsets <<[New@Dictionary[]]]Condition Type <<["And"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	15 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	16
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	17 OrSet[:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	18 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	19 out <- [[[Build["Condition Set"]]Variables <<[New@Dictionary[]]]Subsets <<[New@Dictionary[]]]Condition Type <<["Or"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	20 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	21
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	22 To String@Condition Set[set:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	23 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	24 out <- [[[[[set]Condition Type >>
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	25 ]Append["Set:\n\tVariables:\n\t\t"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	26 ]Append[ Join[Keys[[set]Variables >>], "\n\t\t"] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	27 ]Append["\n\tSubsets:\n\t\t"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	28 ]Append[ Join[Keys[[set]Subsets >>], "\n\t\t"] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	29 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	30
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	31 Add Condition@Condition Set[set,cond:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	32 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	33 If[[Type Of[cond]] = ["Condition Set"]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	34 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	35 out <- [set]Subsets <<[ [[set]Subsets>>]Set[[cond]To String, cond] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	36 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	37 out <- [set]Variables <<[ [[set]Variables >>]Set[cond, Yes] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	38 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	39 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	40
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	41 =@Condition Set[set1,set2:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	42 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	43 ,out <- If[[[set1]Condition Type >>] = [[set2]Condition Type >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	44 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	45 ,out <- If[[[set1]Variables >>] = [[set2]Variables >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	46 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	47 out,out <- If[[[set1]Subsets >>] = [[set2]Subsets >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	48 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	49 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	50 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	51
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	52 _For Backend Var[current,junk,variable,type:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	53 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	54 out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[variable] ]]Index[0]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	55 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	56
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	57 _For Backend Subset[current,subset,type:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	58 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	59 Print["Calling For Backend on subset"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	60 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	61 [subset]For Backend
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	62 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	63 Print["Got output from for backend"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	64 out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[~] ]]Index[0]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	65 { Print["done _For Backend Subset with condition"] }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	66 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	67 Print["none output from for backend"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	68 out <- current
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	69 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	70 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	71 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	72
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	73 Empty?@Condition Set[set:not empty,empty]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	74 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	75 [[set]Variables >>]First
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	76 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	77 not empty <- Yes
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	78 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	79 ,empty <- [[set]Subsets >>]First Non-empty Set
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	80 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	81 not empty <- Yes
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	82 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	83 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	84 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	85
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	86 _First Non-empty Set[setlist,index:out,none]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	87 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	88 current <- [setlist]Index[index]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	89 [[current]Variables >>]First
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	90 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	91 out <- index
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	92 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	93 ,trynext <- [[current]Subsets >>]First Non-empty Set
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	94 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	95 out <- index
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	96 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	97 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	98 Val[trynext]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	99 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	100 ,none <- [setlist]Next[index]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	101 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	102 out,none <- _First Non-empty Set[setlist, ~]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	103 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	104 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	105 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	106
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	107 First Non-empty Set[setlist:index,none]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	108 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	109 ,none <- [setlist]First
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	110 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	111 index,none <- _First Non-empty Set[setlist,~]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	112 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	113 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	114
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	115 For Backend@Condition Set[set:out,none]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	116 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	117 Print["For Backend"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	118 firstvar <- [[set]Variables >>]First
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	119 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	120 Print["At least one var"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	121 [[set]Variables >>]Next[~]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	122 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	123 Print["at least two vars"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	124 vars <- _Fold[[set]Variables >>, ~, firstvar, ["_For Backend Var"]Set Input[3, [set]Condition Type >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	125 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	126 Print["just one var"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	127 vars <- Val[firstvar]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	128 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	129 out <- Fold[["_For Backend Subset"]Set Input[2, [set]Condition Type >>], vars, [set]Subsets >>]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	130 { Print["done For Backend, with vars"] }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	131 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	132 Print["no vars"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	133 [[set]Subsets >>]First Non-empty Set
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	134 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	135 Print[["At least one non-empty subset: "]Append[~]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	136 firstsub <- [[[set]Subsets >>]Index[~]]For Backend
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	137 [[set]Subsets >>]Next[~]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	138 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	139 Print["at least two subsets"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	140 out <- _Fold[[set]Subsets >>, ~, firstsub, ["_For Backend Subset"]Set Input[2, [set]Condition Type >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	141 { Print["done with subsets, but no vars"] }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	142 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	143 out <- Val[firstsub]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	144 { Pretty Print[~, "1s:\t"] }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	145 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	146 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	147 Print["done with none"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	148 none <- Yes
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	149 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	150 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	151 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	152
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	153 Set@Range[range,index,val:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	154 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	155 out <- [[()]Concatenate[range]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	156 ]Set[index,val]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	157 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	158
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	159 List of Lists[num:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	160 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	161 out <- Fold[["Append"]Set Input[1, ()],(), Range[0,num]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	162 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	163
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	164 Blueprint Worker Ref
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	165 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	166 Name
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	167 Convention
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	168 Inputs
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	169 Outputs
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	170 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	171
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	172 Worker Ref[name,convention,inputs,outputs:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	173 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	174 out <- [[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	175 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	176
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	177 Blueprint Node Ref
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	178 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	179 Index
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	180 IO Num
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	181 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	182
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	183 Node Ref[index,ionum:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	184 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	185 out <- [[Build["Node Ref"]]Index <<[index]]IO Num <<[ionum]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	186 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	187
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	188 =@Node Ref[left,right:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	189 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	190 ,out <- If[[[left]Index >>] = [[right]Index >>]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	191 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	192 out <- [[left]IO Num>>] = [[right]IO Num >>]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	193 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	194 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	195
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	196 Blueprint NWorker Node
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	197 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	198 Type
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	199 Data
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	200 Inputs
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	201 Outputs
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	202 Wires From
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	203 Wires To
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	204 Conditions
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	205 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	206
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	207 Wire To@NWorker Node[node,from,output,pre input:out]
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	208 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	209 input <- [pre input]+[1]
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	210 out <- [node]Wires To <<[
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	211 [[node]Wires To >>]Set[input,
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	212 [[[node]Wires To >>]Index[input]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	213 ]Append[Node Ref[from,output]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	214 ]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	215 ]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	216 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	217
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	218 Wire From@NWorker Node[node,to,input,output:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	219 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	220 out <- [node]Wires From <<[
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	221 [[node]Wires From >>]Set[output,
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	222 [[[node]Wires From >>]Index[output]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	223 ]Append[Node Ref[to,input]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	224 ]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	225 ]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	226 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	227
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	228 _Dependency[dlist,ref:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	229 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	230 [dlist]Find[ref]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	231 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	232 out <- dlist
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	233 }{
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	234 out <- [dlist]Append[ref]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	235 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	236 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	237
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	238 Dependencies@NWorker Node[node:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	239 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	240 out <- Fold[["Fold"]Set Input[0, "_Dependency"], (), [node]Wires To >>]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	241 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	242
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	243
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	244 NWorker Node[type,data,inputs,outputs:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	245 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	246 out <- [[[[[[[Build["NWorker Node"]
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	247 ]Type <<[type]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	248 ]Data <<[data]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	249 ]Inputs <<[inputs]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	250 ]Outputs <<[outputs]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	251 ]Wires From <<[List of Lists[outputs]]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	252 ]Wires To <<[List of Lists[[inputs]+[1]]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	253 ]Conditions <<[AndSet[]]
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	254 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	255
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	256 Blueprint NWorker
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	257 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	258 Convention
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	259 Nodes
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	260 Inputs
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	261 Outputs
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	262 Uses
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	263 NodeResults
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	264 Free Temps
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	265 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	266
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	267 NWorker[convention:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	268 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	269 out <- [[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	270 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	271
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	272 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	273 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	274 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	275 node index <- [[worker]Nodes >>]Length
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	276 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	277
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	278 Add Worker Call@NWorker[worker,tocall:out,node index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	279 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	280 out, node index <- [worker]Add Node["call",tocall,[tocall]Inputs >>,[tocall]Outputs >>]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	281 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	282
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	283 Add Constant@NWorker[worker,constant:out,node index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	284 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	285 out, node index <- [worker]Add Node["const",constant,0,1]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	286 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	287
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	288 Add Input@NWorker[worker,name,number:out,node index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	289 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	290 ,node index <- [worker]Add Node["input",number,0,1]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	291 { out <- [~]Inputs <<[[[~]Inputs >>]Set[number,name]] }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	292 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	293
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	294 Add Output@NWorker[worker,name,number:out,node index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	295 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	296 ,node index <- [worker]Add Node["output",number,1,0]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	297 { out <- [~]Outputs <<[[[~]Outputs >>]Set[number,name]] }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	298 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	299
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	300 Add Wire@NWorker[worker,from,output,to,input:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	301 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	302 Print[[[[[[[[["Add Wire@NWorker["]Append[from]]Append[","]]Append[output]]Append[","]]Append[to]]Append[","]]Append[input]]Append["]"]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	303 {
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	304 fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	305 { Print["fromw"] }
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	306 tow <- [[[worker]Nodes >>]Index[to]]Wire To[from,output,input]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	307 { Print["tow"] }
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	308 nodes <- [[[worker]Nodes >>]Set[from, fromw]]Set[to, tow]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	309 { Print["nodes"] }
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	310 out <- [worker]Nodes <<[nodes]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	311 { Print["Add Wire@NWorker done"] }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	312 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	313 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	314
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	315 Uses@NWorker[worker,uses:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	316 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	317 out <- [worker]Uses <<[uses]
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	318 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	319
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	320 _No Dependencies[list,node,index:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	321 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	322 [[node]Wires To>>]Index[1]
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	323 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	324 out <- Val[list]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	325 }{
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	326 [[[node]Wires To>>]Index[0]]First
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	327 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	328 out <- Val[list]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	329 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	330 out <- [list]Append[index]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	331 }
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	332 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	333 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	334
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	335 No Dependencies@NWorker[worker:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	336 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	337 out <- Fold["_No Dependencies", (), [worker]Nodes >>]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	338 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	339
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	340 _Collect Dests[candidates,wire:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	341 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	342 out <- [candidates]Set[[wire]Index >>, Yes]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	343 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	344
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	345 Collect Dests@NWorker[worker,candidates,node index:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	346 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	347 out <- Fold[["Fold"]Set Input[0, "_Collect Dests"], candidates, [[[worker]Nodes >>]Index[node index]]Wires From >>]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	348 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	349
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	350 Check Dependency@NWorker[worker,nodes,wires,wire index:met?]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	351 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	352 ref <- [wires]Index[wire index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	353 [nodes]Find[[ref]Index >>]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	354 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	355 [wires]Next[wire index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	356 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	357 met? <- [worker]Check Dependency[nodes,wires,~]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	358 }{
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	359 met? <- Yes
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	360 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	361 }{
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	362 met? <- No
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	363 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	364 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	365 _Check Dependencies@NWorker[worker,nodes,inputs,input index:met?]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	366 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	367 wires <- [inputs]Index[input index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	368 [wires]First
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	369 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	370 current met? <- [worker]Check Dependency[nodes, wires, ~]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	371 }{
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	372 current met? <- Yes
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	373 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	374 If[current met?]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	375 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	376 [inputs]Next[input index]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	377 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	378 met? <- [worker]_Check Dependencies[nodes,inputs,~]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	379 }{
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	380 met? <- Yes
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	381 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	382 }{
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	383 met? <- No
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	384 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	385 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	386
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	387 Check Dependencies@NWorker[worker,nodes,candidate:met?]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	388 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	389 inputs <- [[[worker]Nodes >>]Index[candidate]]Wires To >>
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	390 [inputs]First
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	391 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	392 met? <- [worker]_Check Dependencies[nodes, inputs, ~]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	393 }{
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	394 met? <- Yes
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	395 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	396 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	397
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	398 Dependants@NWorker[worker,direct nodes,nodes:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	399 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	400 candidates <- Keys[Fold[["Collect Dests"]Set Input[0,worker], (), direct nodes]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	401 out <- Filter[candidates, [["Check Dependencies"]Set Input[0, worker]]Set Input[1, nodes]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	402 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	403
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	404 _Dependency Groups@NWorker[worker,last,all,grouped:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	405 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	406 current <- [worker]Dependants[last,all]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	407 [current]First
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	408 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	409 out <- [worker]_Dependency Groups[current, [all]Concatenate[current], [grouped]Append[current]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	410 }{
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	411 out <- grouped
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	412 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	413 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	414 Dependency Groups@NWorker[worker:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	415 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	416 no deps <- [worker]No Dependencies
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	417 out <- [worker]_Dependency Groups[no deps, no deps, [()]Append[no deps]]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	418 }
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	419
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	420 Format Input@NWorker[worker,noderef:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	421 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	422 node <- [[worker]Nodes >>]Index[[noderef]Index >>]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	423 If[[[node]Type >>] = ["call"]]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	424 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	425 out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	426 }{
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	427 If[[[node]Type >>] = ["input"]]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	428 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	429 input name <- [[worker]Inputs >>]Index[ [node]Data >> ]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	430 out <- AddRef[input name]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	431 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	432 If[[[node]Type >>] = ["const"]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	433 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	434 out <- Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[[node]Data >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	435 }
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	436 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	437 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	438 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	439
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	440 Collect Input@NWorker[worker,nodeinput:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	441 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	442 inputchoices <- Map[nodeinput, ["Format Input"]Set Input[0, worker]]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	443
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	444 [inputchoices]First
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	445 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	446 first <- [inputchoices]Index[~]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	447 [inputchoices]Next[~]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	448 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	449 out <- _Fold[inputchoices, ~, first, "OrValue"]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	450 }{
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	451 out <- Val[first]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	452 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	453 }{
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	454 out <- No
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	455 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	456 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	457
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	458 Collect Inputs@NWorker[worker,node:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	459 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	460 out <- Map[Tail[[node]Wires To>>, 1], ["Collect Input"]Set Input[0, worker]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	461 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	462
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	463 Collect Input Condition@NWorker[worker,set,noderef:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	464 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	465 node <- [[worker]Nodes >>]Index[ [noderef]Index >> ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	466 If[[[node]Outputs >>] > [1]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	467 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	468 out <- [set]Add Condition[ [["__result_"]Append[[noderef]Index >>]]Append[["_"]Append[[noderef]IO Num >>]] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	469 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	470 out <- [set]Add Condition[[node]Conditions >>]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	471 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	472 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	473
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	474 Collect Condition@NWorker[worker,set,nodeinput:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	475 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	476 out <- [set]Add Condition[Fold[["Collect Input Condition"]Set Input[0, worker], OrSet[], nodeinput]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	477 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	478
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	479 Collect Conditions@NWorker[worker,node:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	480 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	481 Print["Collect Conditions"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	482 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	483 out <- Fold[["Collect Condition"]Set Input[0, worker], AndSet[], [node]Wires To>>]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	484 { Print["done Collect Conditions"] }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	485 }
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	486 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	487
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	488 Save Result[func,num,node index:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	489 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	490 Print["Save Result"]
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	491 out var <- [[["__result_"]Append[node index]]Append["_"]]Append[num]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	492 Print[out var]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	493 /*out <- [[func]Allocate Var[out var, "Any Type"]
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	494 ]Move[Result[num], out var]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	495 */
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	496 out <- [func]Move[Result[num], out var]
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	497 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	498
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	499 Compile Call Node[node,program,func,inputs,node index:out]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	500 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	501 [program]Method?[[[node]Data >>]Name >>]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	502 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	503 Print["Method!"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	504 with call <- [func]Method Call[[[node]Data >>]Name >>, inputs]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	505 { Print["Method Call done"] }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	506 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	507 Print["Function!"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	508 with call <- [func]Call[[[node]Data >>]Name >>, inputs]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	509 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	510 out <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	511 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	512
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	513 Compile Node@NWorker[worker,program,func,nodes,current:out,out worker]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	514 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	515 Print[["Compile Node: "]Append[[node]Type >>]]
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	516 node index <- [nodes]Index[current]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	517 node <- [[worker]Nodes >>]Index[node index]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	518 conditions <- [worker]Collect Conditions[node]
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	519 If[[[node]Type >>] = ["call"]]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	520 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	521 Print[["Call: "]Append[[[node]Data >>]Name >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	522
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	523 inputs <- [worker]Collect Inputs[node]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	524 [conditions]For Backend
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	525 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	526 Print["Conditional execution, do if"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	527 stream <- [func]Instruction Stream
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	528 nfunc <- [func]Do If[~, nstream]
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	529 }{
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	530 Print["No conditions, full steam ahead"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	531 stream <- Val[func]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	532 nfunc <- Val[nstream]
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	533 }
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	534 nstream <- Compile Call Node[node, program, stream, inputs, node index]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	535 }{
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	536 If[[[node]Type >>] = ["output"]]
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	537 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	538 inputs <- [worker]Collect Inputs[node]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	539 [conditions]For Backend
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	540 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	541 stream <- [func]Instruction Stream
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	542 nfunc <- [func]Do If[~, nstream]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	543 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	544 stream <- Val[func]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	545 nfunc <- Val[nstream]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	546 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	547 nstream <- [stream]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ]
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	548 }{
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	549 If[[[node]Type >>] = ["const"]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	550 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	551 //TODO: Handle list constants
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	552 nfunc <- [func]Register Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[[node]Data >>], [node]Data >>]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	553 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	554 nfunc <- Val[func]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	555 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	556
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	557 }
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	558 }
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	559 If[[[node]Outputs >>] = [0]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	560 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	561 nworker <- Val[worker]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	562 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	563 nworker <- [worker]Nodes <<[ [[worker]Nodes >>]Set[node index, [node]Conditions <<[conditions]] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	564 }
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	565 [nodes]Next[current]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	566 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	567 out,out worker <- [nworker]Compile Node[program,nfunc,nodes,~]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	568 }{
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	569 out <- Val[nfunc]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	570 out worker <- Val[nworker]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	571 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	572 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	573
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	574 Compile Group@NWorker[worker,program,func,groups,current:out,out worker]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	575 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	576 nodes <- [groups]Index[current]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	577 [nodes]First
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	578 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	579 nfunc,nworker <- [worker]Compile Node[program,func,nodes,~]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	580 }{
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	581 nfunc <- Val[func]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	582 nworker <- Val[worker]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	583 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	584 [groups]Next[current]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	585 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	586 out,out worker <- [nworker]Compile Group[program,nfunc,groups,~]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	587 }{
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	588 out <- Val[nfunc]
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	589 out worker <- Val[nworker]
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	590 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	591 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	592
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	593 Release Var@NWorker[worker,func,name:out]
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	594 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	595 //_result_index_ionum
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	596 parts <- [name]Split["_"]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	597 index <- <String@Whole Number[ [parts]Index[2] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	598 io num <- <String@Whole Number[ [parts]Index[3] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	599 node <- [[worker]Nodes >>]Index[index]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	600 do if <- If[[[node]Outputs >>] > [1]] {}
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	601 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	602 ,do if <- [[node]Conditions >>]Empty?
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	603 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	604 out <- [func]Release[name]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	605 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	606 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	607
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	608 Val[do if]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	609 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	610 stream <- [[func]Instruction Stream]Release[name]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	611 out <- [func]Do If[name, stream]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	612 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	613 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	614
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	615 Result Var[vars,io num,index:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	616 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	617 out <- [vars]Append[[[["__result_"]Append[index]]Append["_"]]Append[io num]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	618 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	619
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	620 Node Result Vars[vars,node,index:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	621 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	622 If[[[node]Type >>] = ["call"]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	623 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	624 out <- Fold[["Result Var"]Set Input[2, index], vars, Range[0, [node]Outputs >>]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	625 }{
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	626 out <- vars
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	627 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	628 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	629
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	630 Result Vars@NWorker[worker:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	631 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	632 out <- Fold["Node Result Vars", (), [worker]Nodes >>]
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	633 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	634
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	635 Compile Worker@NWorker[worker,program,name:out]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	636 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	637 Print[["Compiling: "]Append[name]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	638 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	639 ifunc <- [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	640
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	641 res vars <- [worker]Result Vars
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	642 func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [worker]Outputs >>]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	643
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	644 groups <- [worker]Dependency Groups
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	645 [groups]First
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	646 {
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	647 final func <- [worker]Compile Group[program,func,groups, ~]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	648 }{
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	649 final func <- Val[func]
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	650 }
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	651 out <- [program]Store Function[Fold[["Release Var"]Set Input[0, worker], final func, res vars]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	652 }
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	653 }
90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	654
2 73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	655 Test[:out]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	656 {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	657 ref+ <- Worker Ref["+","cdecl",2,1]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	658 ref* <- Worker Ref["*","cdecl",2,1]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	659 ,a <- [NWorker["cdecl"]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	660 ]Add Input["a", 0] {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	661 ,b <- [~]Add Input["b", 1] {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	662 ,c <- [~]Add Input["c", 2] {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	663 ,outref <- [~]Add Output["out", 0] {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	664 ,call+ <- [~]Add Worker Call[ref+] {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	665 ,call* <- [~]Add Worker Call[ref*] {
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	666 out <- [[[[[~]Add Wire[a,0,call+,0]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	667 ]Add Wire[b,0,call+,1]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	668 ]Add Wire[call+,0,call*,0]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	669 ]Add Wire[c,0,call*,1]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	670 ]Add Wire[call*,0,outref,0]
73e978d590c7 Adding WIP compiler code Mike Pavone <pavone@retrodev.com> parents: diff changeset	671 }}}}}}
19 90c20dc3f4e5 Initial work on compiling dataflow graphs to a backend Mike Pavone <pavone@retrodev.com> parents: 2 diff changeset	672 }
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	673
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	674 Test Graph to Backend[:out]
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	675 {
21 e9272f7ebd26 Limited compilation from dataflow graph to C backend Mike Pavone <pavone@retrodev.com> parents: 20 diff changeset	676 out <- [Test[]]Compile Worker[C Program[], "Test"]
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	677 }
b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	678
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	679 Blueprint NProgram
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	680 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	681 Blueprints
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	682 Workers
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	683 Worker Refs
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	684 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	685
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	686 NProgram[:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	687 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	688 out <- [[[Build["NProgram"]]Blueprints <<[New@Dictionary[]]]Workers <<[New@Dictionary[]]]Worker Refs <<[New@Dictionary[]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	689 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	690
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	691 Bind Worker@NProgram[prog,name,worker:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	692 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	693 out <- [prog]Workers << [ [[prog]Workers >>]Set[name, worker] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	694 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	695
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	696 Bind Blueprint@NProgram[prog,name,blueprint:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	697 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	698 out <- [prog]Blueprints << [ [[prog]Blueprints >>]Set[name, blueprint] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	699 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	700
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	701 _Compile Program[backend, worker, name:out]
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	702 {
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	703 out <- [worker]Compile Worker[backend, name]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	704 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	705
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	706 Compile Program@NProgram[prog, backend:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	707 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	708 out <- Fold["_Compile Program", backend, [prog]Workers >>]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	709 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	710
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	711 Register Worker@NProgram[prog, name, convention, inputs, outputs: out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	712 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	713 Print[["Register Worker "]Append[name]]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	714 out <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs]]]
20 b715532225c0 Differentiate between method and normal calls in dataflow graph compiler Mike Pavone <pavone@retrodev.com> parents: 19 diff changeset	715 }
30 914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	716
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	717 Register Builtins@NProgram[prog:out]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	718 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	719 out <- [[[[[[[[[prog]Register Worker["+", "cdecl", 2, 1]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	720 ]Register Worker["-", "cdecl", 2, 1]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	721 ]Register Worker["*", "cdecl", 2, 1]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	722 ]Register Worker["/", "cdecl", 2, 1]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	723 ]Register Worker["Print", "cdecl", 1, 1]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	724 ]Register Worker["Index", "cdecl", 2, 1]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	725 ]Register Worker["If", "cdecl", 1, 2]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	726 ]Register Worker["<", "cdecl", 2, 1]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	727 ]Register Worker["<String@Whole Number", "cdecl", 1, 1]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	728 }
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	729
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	730 Find Worker@NProgram[prog, name:out,notfound]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	731 {
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	732 Print[ ["Find Worker@NProgram: "]Append[name] ]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	733 out,notfound <- [[prog]Worker Refs >>]Index[name]
914ad38f9b59 Compiler now works for some simple programs Mike Pavone <pavone@retrodev.com> parents: 21 diff changeset	734 }

Mercurial > repos > rhope

annotate nworker.rhope @ 30:914ad38f9b59