Mercurial > repos > rhope
annotate nworker.rhope @ 44:a7c79ac22efc
Beginning of basic type inference
| author | Mike Pavone <pavone@retrodev.com> |
|---|---|
| date | Sat, 31 Oct 2009 21:28:28 -0400 |
| parents | 709df3e82bb4 |
| children | 6202b866d72c |
| rev | line source |
|---|---|
| 2 | 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 | 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 | 153 Set@Range[range,index,val:out] |
| 154 { | |
| 155 out <- [[()]Concatenate[range] | |
| 156 ]Set[index,val] | |
| 157 } | |
| 158 | |
| 159 List of Lists[num:out] | |
| 160 { | |
| 161 out <- Fold[["Append"]Set Input[1, ()],(), Range[0,num]] | |
| 162 } | |
| 163 | |
| 164 Blueprint Worker Ref | |
| 165 { | |
| 166 Name | |
| 167 Convention | |
| 168 Inputs | |
| 169 Outputs | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
170 Is Method? |
| 2 | 171 } |
| 172 | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
173 Worker Ref[name,convention,inputs,outputs,ismethod?:out] |
| 2 | 174 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
175 out <- [[[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs]]Is Method ? <<[ismethod?] |
| 2 | 176 } |
| 177 | |
| 178 Blueprint Node Ref | |
| 179 { | |
| 180 Index | |
| 181 IO Num | |
| 182 } | |
| 183 | |
| 184 Node Ref[index,ionum:out] | |
| 185 { | |
| 186 out <- [[Build["Node Ref"]]Index <<[index]]IO Num <<[ionum] | |
| 187 } | |
| 188 | |
| 189 =@Node Ref[left,right:out] | |
| 190 { | |
| 191 ,out <- If[[[left]Index >>] = [[right]Index >>]] | |
| 192 { | |
| 193 out <- [[left]IO Num>>] = [[right]IO Num >>] | |
| 194 } | |
| 195 } | |
| 196 | |
| 197 Blueprint NWorker Node | |
| 198 { | |
| 199 Type | |
| 200 Data | |
| 201 Inputs | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
202 Input Types |
| 2 | 203 Outputs |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
204 Output Types |
| 2 | 205 Wires From |
| 206 Wires To | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
207 Conditions |
| 2 | 208 } |
| 209 | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
210 Wire To@NWorker Node[node,from,output,pre input:out] |
| 2 | 211 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
212 input <- [pre input]+[1] |
| 2 | 213 out <- [node]Wires To <<[ |
| 214 [[node]Wires To >>]Set[input, | |
| 215 [[[node]Wires To >>]Index[input] | |
| 216 ]Append[Node Ref[from,output]] | |
| 217 ] | |
| 218 ] | |
| 219 } | |
| 220 | |
| 221 Wire From@NWorker Node[node,to,input,output:out] | |
| 222 { | |
| 223 out <- [node]Wires From <<[ | |
| 224 [[node]Wires From >>]Set[output, | |
| 225 [[[node]Wires From >>]Index[output] | |
| 226 ]Append[Node Ref[to,input]] | |
| 227 ] | |
| 228 ] | |
| 229 } | |
| 230 | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
231 _Has Input Types@NWorker Node[node,input num:does,does not] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
232 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
233 does <- If[[input num] > [[node]Inputs >>]] {} |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
234 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
235 ,does not <- [[node]Input Types >>]Index[input num] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
236 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
237 count <- [~]Index[1] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
238 ,does not <- If[[count] = [[[[node]Wires To >>]Index[input num]]Length]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
239 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
240 does,does not <- [node]_Has Input Types[[input num]+[1]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
241 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
242 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
243 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
244 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
245 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
246 Has Input Types?@NWorker Node[node:does,does not] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
247 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
248 If[[[[node]Inputs >>]Length] > [0]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
249 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
250 does,does not <- _Has Input Types[node,0] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
251 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
252 does <- Yes |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
253 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
254 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
255 |
| 2 | 256 _Dependency[dlist,ref:out] |
| 257 { | |
| 258 [dlist]Find[ref] | |
| 259 { | |
| 260 out <- dlist | |
| 261 }{ | |
| 262 out <- [dlist]Append[ref] | |
| 263 } | |
| 264 } | |
| 265 | |
| 266 Dependencies@NWorker Node[node:out] | |
| 267 { | |
| 268 out <- Fold[["Fold"]Set Input[0, "_Dependency"], (), [node]Wires To >>] | |
| 269 } | |
| 270 | |
| 271 | |
| 272 NWorker Node[type,data,inputs,outputs:out] | |
| 273 { | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
274 out <- [[[[[[[[[Build["NWorker Node"] |
| 2 | 275 ]Type <<[type] |
| 276 ]Data <<[data] | |
| 277 ]Inputs <<[inputs] | |
| 278 ]Outputs <<[outputs] | |
| 279 ]Wires From <<[List of Lists[outputs]] | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
280 ]Wires To <<[List of Lists[[inputs]+[1]]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
281 ]Conditions <<[AndSet[]] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
282 ]Input Types <<[()] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
283 ]Output Types <<[()] |
| 2 | 284 } |
| 285 | |
| 286 Blueprint NWorker | |
| 287 { | |
| 288 Convention | |
| 289 Nodes | |
| 290 Inputs | |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
291 Input Types |
| 2 | 292 Outputs |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
293 Output Types |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
294 Uses |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
295 NodeResults |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
296 Free Temps |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
297 Name |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
298 Builtin? |
| 2 | 299 } |
| 300 | |
| 301 NWorker[convention:out] | |
| 302 { | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
303 out <- [[[[[[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]]Input Types <<[()]]Output Types <<[()]]Name <<["Anonymous"]]Builtin <<[No] |
| 2 | 304 } |
| 305 | |
| 306 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index] | |
| 307 { | |
| 308 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]] | |
| 309 node index <- [[worker]Nodes >>]Length | |
| 310 } | |
| 311 | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
312 Propagate Type[nodelist,dest,prog,worker,type:out] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
313 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
314 node <- [nodelist]Index[[dest]Index >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
315 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
316 [[node]Input Types >>]Index[[dest]IO Num >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
317 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
318 existing type <- [~]Index[0] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
319 new count <- [[~]Index[1]]+[1] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
320 If[[[existing type]Name >>] = [[type]Name >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
321 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
322 If[[[existing type]Variant >>] = [[type]Variant >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
323 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
324 If[[[existing type]Params >>] = [[type]Params >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
325 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
326 new type <- Val[existing type] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
327 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
328 new variant <- [existing type]Variant >> |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
329 new params <- () |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
330 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
331 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
332 new variant <- "Boxed" |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
333 If[[[existing type]Params >>] = [[type]Params >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
334 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
335 new params <- [existing type]Params >> |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
336 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
337 new params <- () |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
338 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
339 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
340 new type <- [[existing type]Set Variant[new variant]]Params <<[new params] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
341 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
342 new type <- Type Instance["Any Type"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
343 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
344 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
345 new type <- Val[type] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
346 new count <- 1 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
347 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
348 new node <- [node]Input Types <<[ [[node]Input Types >>]Set[[dest]IO Num >>, new type] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
349 out <- Infer Types Node[[nodelist]Set[[dest]Index >>, new node], new node, [dest]Index >>, prog, worker] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
350 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
351 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
352 Propagate Types[nodelist,dests,output num,prog,worker,source node:out] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
353 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
354 out <- Fold[[[["Propagate Type"]Set Input[2, prog]]Set Input[3, worker]]Set Input[4, [[source node]Output Types >>]Index[output num]], nodelist, dests] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
355 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
356 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
357 Infer Types Node[nodelist,node,index,prog,worker:out] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
358 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
359 If[[[node]Type >>] = ["const"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
360 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
361 //Temporary hack |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
362 If[[Type Of[[node]Data >>]] = ["Whole Number"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
363 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
364 outtype <- Type Instance["Whole Number"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
365 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
366 outtype <- Type Instance[Type Of[[node]Data >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
367 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
368 nextnode <- [node]Output Types <<[ [()]Append[outtype] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
369 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
370 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
371 If[[[node]Type >>] = ["input"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
372 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
373 nextnode <- [node]Output Types <<[ [()]Append[ [[worker]Input Types >>]Index[[node]Data >>] ] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
374 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
375 If[[[node]Type >>] = ["output"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
376 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
377 out <- nodelist |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
378 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
379 [node]Has Input Types? |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
380 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
381 If[[[node]Type >>] = ["setfield"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
382 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
383 nextnode <- [node]Output Types <<[ [()]Append[ [[[node]Input Types >>]Index[0]]Index[0] ] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
384 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
385 If[[[node]Type >>] = ["getfield"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
386 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
387 type <- [[[node]Input Types >>]Index[0]]Index[0] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
388 If[[[type]Name >>] = ["Any Type"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
389 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
390 outtype <- Val[type] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
391 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
392 outtype <- [prog]Find Field[[node]Data >>, type] {} |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
393 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
394 //TODO: Return errors rather than printing them |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
395 Print[ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
396 [[[[["Type " |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
397 ]Append[[type]Name >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
398 ]Append[" does not have a field named "] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
399 ]Append[[node]Data >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
400 ]Append[" in worker "] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
401 ]Append[worker name]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
402 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
403 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
404 nextnode <- [node]Output Types <<[ [()]Append[outtype] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
405 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
406 worker name <- [[node]Data >>]Name >> |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
407 [prog]Is Method?[worker name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
408 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
409 first arg type <- [[[node]Input Types >>]Index[0]]Index[0] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
410 If[[[first arg type]Name >>] = ["Any Type"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
411 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
412 outtypes <- Fold[["Append"]Set Input[1, Type Instance["Any Type"]], (), Range[0, [node]Inputs >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
413 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
414 worker def <- [prog]Find Method[worker name, first arg type] {} |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
415 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
416 //TODO: Return errors instead of printing them |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
417 Print[ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
418 [[[[["Type " |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
419 ]Append[[first arg type]Name >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
420 ]Append[" does not support method "] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
421 ]Append[worker name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
422 ]Append[" in worker "] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
423 ]Append[ [worker]Name >> ]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
424 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
425 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
426 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
427 worker def <- [prog]Find Worker Def[worker name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
428 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
429 outtypes <- [worker def]Output Types >> |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
430 nextnode <- [node]Output Types <<[ outtypes ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
431 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
432 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
433 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
434 out <- nodelist |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
435 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
436 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
437 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
438 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
439 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
440 Val[nextnode] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
441 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
442 nextlist <- [nodelist]Set[index, nextnode] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
443 out <- Fold[[[["Propagate Types"]Set Input[3, prog]]Set Input[4, worker]]Set Input[5, nextnode], nodelist, [nextnode]Wires From >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
444 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
445 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
446 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
447 Infer Types@NWorker[worker,prog:out] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
448 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
449 out <- [worker]Nodes <<[Fold[[["Infer Types Node"]Set Input[3, prog]]Set Input[4, worker], [worker]Nodes >>, [worker]Nodes >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
450 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
451 |
| 2 | 452 Add Worker Call@NWorker[worker,tocall:out,node index] |
| 453 { | |
| 454 out, node index <- [worker]Add Node["call",tocall,[tocall]Inputs >>,[tocall]Outputs >>] | |
| 455 } | |
| 456 | |
| 457 Add Constant@NWorker[worker,constant:out,node index] | |
| 458 { | |
| 459 out, node index <- [worker]Add Node["const",constant,0,1] | |
| 460 } | |
| 461 | |
| 462 Add Input@NWorker[worker,name,number:out,node index] | |
| 463 { | |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
464 out,node index <- [worker]Add Typed Input[name,number,Type Instance["Any Type"]] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
465 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
466 |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
467 Add Typed Input@NWorker[worker,name,number,type:out,node index] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
468 { |
| 2 | 469 ,node index <- [worker]Add Node["input",number,0,1] |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
470 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
471 out <- [[~]Inputs <<[[[~]Inputs >>]Set[number,name]] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
472 ]Input Types <<[[[~]Input Types >>]Set[number,type]] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
473 } |
| 2 | 474 } |
| 475 | |
| 476 Add Output@NWorker[worker,name,number:out,node index] | |
| 477 { | |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
478 out,node index <- [worker]Add Typed Output[name,number,Type Instance["Any Type"]] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
479 } |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
480 |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
481 Add Typed Output@NWorker[worker,name,number,type:out,node index] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
482 { |
| 2 | 483 ,node index <- [worker]Add Node["output",number,1,0] |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
484 { |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
485 out <- [[~]Outputs <<[[[~]Outputs >>]Set[number,name]] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
486 ]Output Types <<[[[~]Output Types >>]Set[number,type]] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
487 } |
| 2 | 488 } |
| 489 | |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
490 Add Object Get@NWorker[worker,fieldname:out,node index] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
491 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
492 out, node index <- [worker]Add Node["getfield",fieldname,1,1] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
493 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
494 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
495 Add Object Set@NWorker[worker,fieldname:out,node index] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
496 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
497 out, node index <- [worker]Add Node["setfield",fieldname,2,1] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
498 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
499 |
| 2 | 500 Add Wire@NWorker[worker,from,output,to,input:out] |
| 501 { | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
502 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
|
503 { |
| 2 | 504 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
|
505 { Print["fromw"] } |
| 2 | 506 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
|
507 { Print["tow"] } |
| 2 | 508 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
|
509 { Print["nodes"] } |
| 2 | 510 out <- [worker]Nodes <<[nodes] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
511 { Print["Add Wire@NWorker done"] } |
|
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 } |
|
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 Uses@NWorker[worker,uses:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
516 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
517 out <- [worker]Uses <<[uses] |
| 2 | 518 } |
| 519 | |
| 520 _No Dependencies[list,node,index:out] | |
| 521 { | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
522 [[node]Wires To>>]Index[1] |
| 2 | 523 { |
| 524 out <- Val[list] | |
| 525 }{ | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
526 [[[node]Wires To>>]Index[0]]First |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
527 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
528 out <- Val[list] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
529 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
530 out <- [list]Append[index] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
531 } |
| 2 | 532 } |
| 533 } | |
| 534 | |
| 535 No Dependencies@NWorker[worker:out] | |
| 536 { | |
| 537 out <- Fold["_No Dependencies", (), [worker]Nodes >>] | |
| 538 } | |
| 539 | |
| 540 _Collect Dests[candidates,wire:out] | |
| 541 { | |
| 542 out <- [candidates]Set[[wire]Index >>, Yes] | |
| 543 } | |
| 544 | |
| 545 Collect Dests@NWorker[worker,candidates,node index:out] | |
| 546 { | |
| 547 out <- Fold[["Fold"]Set Input[0, "_Collect Dests"], candidates, [[[worker]Nodes >>]Index[node index]]Wires From >>] | |
| 548 } | |
| 549 | |
| 550 Check Dependency@NWorker[worker,nodes,wires,wire index:met?] | |
| 551 { | |
| 552 ref <- [wires]Index[wire index] | |
| 553 [nodes]Find[[ref]Index >>] | |
| 554 { | |
| 555 [wires]Next[wire index] | |
| 556 { | |
| 557 met? <- [worker]Check Dependency[nodes,wires,~] | |
| 558 }{ | |
| 559 met? <- Yes | |
| 560 } | |
| 561 }{ | |
| 562 met? <- No | |
| 563 } | |
| 564 } | |
| 565 _Check Dependencies@NWorker[worker,nodes,inputs,input index:met?] | |
| 566 { | |
| 567 wires <- [inputs]Index[input index] | |
| 568 [wires]First | |
| 569 { | |
| 570 current met? <- [worker]Check Dependency[nodes, wires, ~] | |
| 571 }{ | |
| 572 current met? <- Yes | |
| 573 } | |
| 574 If[current met?] | |
| 575 { | |
| 576 [inputs]Next[input index] | |
| 577 { | |
| 578 met? <- [worker]_Check Dependencies[nodes,inputs,~] | |
| 579 }{ | |
| 580 met? <- Yes | |
| 581 } | |
| 582 }{ | |
| 583 met? <- No | |
| 584 } | |
| 585 } | |
| 586 | |
| 587 Check Dependencies@NWorker[worker,nodes,candidate:met?] | |
| 588 { | |
| 589 inputs <- [[[worker]Nodes >>]Index[candidate]]Wires To >> | |
| 590 [inputs]First | |
| 591 { | |
| 592 met? <- [worker]_Check Dependencies[nodes, inputs, ~] | |
| 593 }{ | |
| 594 met? <- Yes | |
| 595 } | |
| 596 } | |
| 597 | |
| 598 Dependants@NWorker[worker,direct nodes,nodes:out] | |
| 599 { | |
| 600 candidates <- Keys[Fold[["Collect Dests"]Set Input[0,worker], (), direct nodes]] | |
| 601 out <- Filter[candidates, [["Check Dependencies"]Set Input[0, worker]]Set Input[1, nodes]] | |
| 602 } | |
| 603 | |
| 604 _Dependency Groups@NWorker[worker,last,all,grouped:out] | |
| 605 { | |
| 606 current <- [worker]Dependants[last,all] | |
| 607 [current]First | |
| 608 { | |
| 609 out <- [worker]_Dependency Groups[current, [all]Concatenate[current], [grouped]Append[current]] | |
| 610 }{ | |
| 611 out <- grouped | |
| 612 } | |
| 613 } | |
| 614 Dependency Groups@NWorker[worker:out] | |
| 615 { | |
| 616 no deps <- [worker]No Dependencies | |
| 617 out <- [worker]_Dependency Groups[no deps, no deps, [()]Append[no deps]] | |
| 618 } | |
| 619 | |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
620 Format Input@NWorker[worker,noderef:out] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
621 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
622 node <- [[worker]Nodes >>]Index[[noderef]Index >>] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
623 [("call","getfield","setfield")]Find[[node]Type >>] |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
624 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
625 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
|
626 }{ |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
627 If[[[node]Type >>] = ["input"]] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
628 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
629 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
|
630 out <- AddRef[input name] |
|
30
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 If[[[node]Type >>] = ["const"]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
633 { |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
634 If[[Type Of[[node]Data >>]] = ["Type Instance"]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
635 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
636 //TODO: Support parametric types |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
637 datstring <- [[node]Data >>]Name >> |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
638 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
639 datstring <- [node]Data >> |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
640 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
641 out <- Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[datstring]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
642 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
643 } |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
644 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
645 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
646 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
647 |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
648 Collect Input@NWorker[worker,nodeinput:out] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
649 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
650 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
|
651 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
652 [inputchoices]First |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
653 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
654 first <- [inputchoices]Index[~] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
655 [inputchoices]Next[~] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
656 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
657 out <- _Fold[inputchoices, ~, first, "OrValue"] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
658 }{ |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
659 out <- Val[first] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
660 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
661 }{ |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
662 out <- No |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
663 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
664 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
665 |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
666 Collect Inputs@NWorker[worker,node:out] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
667 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
668 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
|
669 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
670 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
671 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
|
672 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
673 node <- [[worker]Nodes >>]Index[ [noderef]Index >> ] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
674 If[[[node]Outputs >>] > [1]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
675 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
676 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
|
677 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
678 out <- [set]Add Condition[[node]Conditions >>] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
679 } |
|
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 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
682 Collect Condition@NWorker[worker,set,nodeinput:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
683 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
684 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
|
685 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
686 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
687 Collect Conditions@NWorker[worker,node:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
688 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
689 Print["Collect Conditions"] |
|
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 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
|
692 { Print["done Collect Conditions"] } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
693 } |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
694 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
695 |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
696 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
|
697 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
698 Print["Save Result"] |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
699 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
|
700 Print[out var] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
701 /*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
|
702 ]Move[Result[num], out var] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
703 */ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
704 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
|
705 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
706 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
707 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
|
708 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
709 If[[[node]Type >>] = ["getfield"]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
710 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
711 with call <- [func]Get Field Call[[node]Data >>, [inputs]Index[0]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
712 }{ |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
713 If[[[node]Type >>] = ["setfield"]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
714 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
715 with call <- [func]Set Field Call[[node]Data >>, [inputs]Index[0], [inputs]Index[1]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
716 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
717 Print[["Call: "]Append[[[node]Data >>]Name >>]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
718 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
719 [program]Method?[[[node]Data >>]Name >>] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
720 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
721 Print["Method!"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
722 with call <- [func]Method Call[[[node]Data >>]Name >>, inputs] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
723 { Print["Method Call done"] } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
724 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
725 Print["Function!"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
726 with call <- [func]Call[[[node]Data >>]Name >>, inputs] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
727 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
728 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
729 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
730 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
731 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
|
732 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
733 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
734 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
|
735 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
736 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
|
737 node index <- [nodes]Index[current] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
738 node <- [[worker]Nodes >>]Index[node index] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
739 conditions <- [worker]Collect Conditions[node] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
740 [("call","getfield","setfield")]Find[[node]Type >>] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
741 { |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
742 inputs <- [worker]Collect Inputs[node] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
743 [conditions]For Backend |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
744 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
745 Print["Conditional execution, do if"] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
746 stream <- [func]Instruction Stream |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
747 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
|
748 }{ |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
749 Print["No conditions, full steam ahead"] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
750 stream <- Val[func] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
751 nfunc <- Val[nstream] |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
752 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
753 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
|
754 }{ |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
755 If[[[node]Type >>] = ["output"]] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
756 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
757 inputs <- [worker]Collect Inputs[node] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
758 [conditions]For Backend |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
759 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
760 stream <- [func]Instruction Stream |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
761 nfunc <- [func]Do If[~, nstream] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
762 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
763 stream <- Val[func] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
764 nfunc <- Val[nstream] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
765 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
766 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
|
767 }{ |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
768 If[[[node]Type >>] = ["const"]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
769 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
770 //TODO: Handle list constants |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
771 If[[Type Of[[node]Data >>]] = ["Type Instance"]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
772 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
773 //TODO: Support parametric types |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
774 datstring <- [[node]Data >>]Name >> |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
775 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
776 datstring <- [node]Data >> |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
777 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
778 nfunc <- [func]Register Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[datstring], [node]Data >>] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
779 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
780 nfunc <- Val[func] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
781 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
782 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
783 } |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
784 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
785 If[[[node]Outputs >>] = [0]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
786 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
787 nworker <- Val[worker] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
788 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
789 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
|
790 } |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
791 [nodes]Next[current] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
792 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
793 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
|
794 }{ |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
795 out <- Val[nfunc] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
796 out worker <- Val[nworker] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
797 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
798 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
799 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
800 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
|
801 { |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
802 nodes <- [groups]Index[current] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
803 [nodes]First |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
804 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
805 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
|
806 }{ |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
807 nfunc <- Val[func] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
808 nworker <- Val[worker] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
809 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
810 [groups]Next[current] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
811 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
812 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
|
813 }{ |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
814 out <- Val[nfunc] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
815 out worker <- Val[nworker] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
816 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
817 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
818 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
819 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
|
820 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
821 //_result_index_ionum |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
822 parts <- [name]Split["_"] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
823 index <- <String@Whole Number[ [parts]Index[2] ] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
824 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
|
825 node <- [[worker]Nodes >>]Index[index] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
826 do if <- If[[[node]Outputs >>] > [1]] {} |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
827 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
828 ,do if <- [[node]Conditions >>]Empty? |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
829 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
830 out <- [func]Release[name] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
831 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
832 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
833 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
834 Val[do if] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
835 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
836 stream <- [[func]Instruction Stream]Release[name] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
837 out <- [func]Do If[name, stream] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
838 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
839 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
840 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
841 Result Var[vars,io num,index:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
842 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
843 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
|
844 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
845 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
846 Node Result Vars[vars,node,index:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
847 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
848 [("call","getfield","setfield")]Find[[node]Type >>] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
849 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
850 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
|
851 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
852 out <- vars |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
853 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
854 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
855 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
856 Result Vars@NWorker[worker:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
857 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
858 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
|
859 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
860 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
861 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
|
862 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
863 If[[worker]Builtin? >>] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
864 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
865 out <- program |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
866 }{ |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
867 Print[["Compiling: "]Append[name]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
868 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
869 ifunc <- Fold["Set Output Type", Fold["Set Input Type", [program]Create Function[name,[worker]Inputs >>, [worker]Outputs >>, [worker]Convention >>], [worker]Input Types >>], [worker]Output Types >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
870 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
871 res vars <- [worker]Result Vars |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
872 func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [worker]Outputs >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
873 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
874 groups <- [worker]Dependency Groups |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
875 [groups]First |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
876 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
877 final func <- [worker]Compile Group[program,func,groups, ~] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
878 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
879 final func <- Val[func] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
880 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
881 out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, worker], final func, res vars], [worker]Inputs >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
882 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
883 } |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
884 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
885 |
| 2 | 886 Test[:out] |
| 887 { | |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
888 ref+ <- Worker Ref["+","rhope",2,1] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
889 ref* <- Worker Ref["*","rhope",2,1] |
|
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
890 ,a <- [NWorker["rhope"] |
| 2 | 891 ]Add Input["a", 0] { |
| 892 ,b <- [~]Add Input["b", 1] { | |
| 893 ,c <- [~]Add Input["c", 2] { | |
| 894 ,outref <- [~]Add Output["out", 0] { | |
| 895 ,call+ <- [~]Add Worker Call[ref+] { | |
| 896 ,call* <- [~]Add Worker Call[ref*] { | |
| 897 out <- [[[[[~]Add Wire[a,0,call+,0] | |
| 898 ]Add Wire[b,0,call+,1] | |
| 899 ]Add Wire[call+,0,call*,0] | |
| 900 ]Add Wire[c,0,call*,1] | |
| 901 ]Add Wire[call*,0,outref,0] | |
| 902 }}}}}} | |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
903 } |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
904 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
905 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
|
906 { |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
907 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
|
908 } |
|
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
909 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
910 Blueprint NBlueprint |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
911 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
912 Fields |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
913 Methods |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
914 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
915 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
916 NBlueprint[:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
917 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
918 out <- [[Build["NBlueprint"]]Fields <<[()]]Methods <<[New@Dictionary[]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
919 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
920 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
921 Add Field@NBlueprint[bp,name,type:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
922 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
923 out <- [bp]Fields <<[ [[bp]Fields >>]Append[ [[()]Append[name]]Append[type] ] ] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
924 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
925 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
926 Add Method@NBlueprint[bp,name:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
927 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
928 out <- [bp]Methods <<[ [[bp]Methods >>]Set[name, Yes] ] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
929 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
930 |
|
43
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
931 Understands Method@NBlueprint[bp,name:out] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
932 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
933 out <- [[bp]Methods >>]Index[name] {} |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
934 { out <- No } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
935 } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
936 |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
937 Get Field Type@NBlueprint[bp,name:out,notfound] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
938 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
939 ,notfound <- [[bp]Fields >>]Index[name] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
940 { out <- [~]Index[1] } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
941 } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
942 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
943 _Compile Blueprint Fields[type,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
944 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
945 name <- [field]Index[0] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
946 ftype <- [field]Index[1] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
947 out <- [type]Add Field[name,ftype] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
948 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
949 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
950 _Compile Blueprint Methods[type,junk,name:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
951 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
952 out <- [type]Add Method[name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
953 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
954 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
955 Make Init[func,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
956 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
957 name <- [field]Index[0] |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
958 Print[["Field: "]Append[name]] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
959 { Print[[" Variant: "]Append[variant]] } |
|
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
960 variant <- [[field]Index[1]]Variant >> |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
961 If[[variant] = ["Boxed"]] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
962 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
963 out <- [func]Set Field Null["obj", name] |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
964 { Print["done"] } |
|
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
965 }{ |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
966 out <- func |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
967 } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
968 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
969 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
970 Make Copy[func,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
971 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
972 name <- [field]Index[0] |
|
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
973 variant <- [[field]Index[1]]Variant >> |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
974 If[[variant] = ["Boxed"]] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
975 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
976 got <- [func]Read Field["obj", name] {} |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
977 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
978 stream <- [[got]Instruction Stream |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
979 ]AddRef No Dest[~] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
980 out <- [got]Do If[~, stream] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
981 } |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
982 }{ |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
983 out <- func |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
984 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
985 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
986 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
987 Make Cleanup[func,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
988 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
989 name <- [field]Index[0] |
|
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
990 variant <- [[field]Index[1]]Variant >> |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
991 If[[variant] = ["Boxed"]] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
992 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
993 got <- [func]Read Field["obj", name] {} |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
994 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
995 stream <- [[got]Instruction Stream |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
996 ]Release[~] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
997 out <- [got]Do If[~, stream] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
998 } |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
999 }{ |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1000 out <- func |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1001 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1002 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1003 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1004 Make Special@NBlueprint[bp,backend,func name,bp name,pop worker:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1005 { |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1006 Print[[["Make Special: "]Append[func name]]Append[bp name]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1007 func <- [[backend]Create Function[func name,("obj"),(),"cdecl"] |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1008 ]Set Input Type[Type Instance[bp name], 0] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1009 out <- [backend]Store Function[Fold[pop worker, func, [bp]Fields >>]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1010 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1011 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1012 Getters Setters[backend,field,type name:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1013 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1014 //TODO: Throw an exception or something if we read a field that is empty |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1015 Print[["Getters Setters: "]Append[name]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1016 name <- [field]Index[0] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1017 type <- [field]Index[1] |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1018 mytype <- Type Instance[type name] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1019 start getter,getref <- [[[[backend]Create Function[ [[[name]Append[" >>"]]Append["@"]]Append[type name], ("obj"), ("out"), "rhope"] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1020 ]Set Input Type[mytype, 0] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1021 ]Set Output Type[[type]Set Variant["Boxed"], 0] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1022 ]Read Field["obj", name] |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1023 If[[[type]Variant >>] = ["Boxed"]] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1024 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1025 getter <- [[start getter]Do AddRef[getref, "out"]]Release["obj"] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1026 }{ |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1027 getter <- [[start getter]Box[getref, "out", type]]Release["obj"] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1028 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1029 |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1030 begin setter <- [[[[[backend]Create Function[ [[[name]Append[" <<"]]Append["@"]]Append[type name], ("obj","newval"), ("out"), "rhope"] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1031 ]Set Input Type[mytype, 0] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1032 ]Set Input Type[[type]Set Variant["Boxed"], 1] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1033 ]Set Output Type[mytype, 0] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1034 ]Copy["obj"] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1035 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1036 If[[[type]Variant >>] = ["Boxed"]] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1037 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1038 ,origref <- [begin setter]Read Field["obj", name] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1039 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1040 stream <- [[~]Instruction Stream |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1041 ]Release[origref] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1042 ,setref <- [[~]Do If[origref, stream] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1043 ]Write Field["obj", name] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1044 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1045 setter <- [[~]Move["newval", setref] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1046 ]Move["obj", "out"] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1047 { Print["got setter"] } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1048 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1049 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1050 }{ |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1051 ,setref <- [begin setter]Write Field["obj", name] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1052 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1053 setter <- [[~]Unbox["newval", setref] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1054 ]Move["obj", "out"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1055 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1056 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1057 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1058 out <- [[backend]Store Function[getter]]Store Function[setter] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1059 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1060 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1061 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1062 Compile Blueprint@NBlueprint[bp,backend,name:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1063 { |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1064 Print[["Compiling blueprint: "]Append[name]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1065 //Rhope identifiers can't start with spaces, so we can use identifiers that start with spaces for special functions |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1066 init name <- [" init "]Append[name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1067 copy name <- [" copy "]Append[name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1068 cleanup name <- [" cleanup "]Append[name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1069 type <- [[[Fold["_Compile Blueprint Methods", Fold["_Compile Blueprint Fields", [backend]Create Type[name], [bp]Fields >>], [bp]Methods >>] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1070 ]Init <<[init name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1071 ]Copy <<[copy name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1072 ]Cleanup <<[cleanup name] |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1073 { Print["Created type on backend"] } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1074 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1075 out <- [backend]Register Type[type] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1076 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1077 |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1078 Compile Special@NBlueprint[bp,backend,name:out] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1079 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1080 init name <- [" init "]Append[name] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1081 copy name <- [" copy "]Append[name] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1082 cleanup name <- [" cleanup "]Append[name] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1083 got specials <- [bp]Make Special[ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1084 [bp]Make Special[ |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1085 [bp]Make Special[backend, init name, name, "Make Init"], |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1086 copy name, name, "Make Copy"], |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1087 cleanup name, name, "Make Cleanup"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1088 out <- Fold[["Getters Setters"]Set Input[2, name], got specials, [bp]Fields >>] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1089 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1090 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1091 Blueprint NProgram |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1092 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1093 Blueprints |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1094 Workers |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1095 Worker Refs |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1096 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1097 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1098 NProgram[:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1099 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1100 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
|
1101 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1102 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1103 Bind Worker@NProgram[prog,name,worker:out] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1104 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1105 after bind <- [prog]Workers << [ [[prog]Workers >>]Set[name, [worker]Name <<[name]] ] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1106 parts <- [name]Split["@"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1107 [parts]Index[1] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1108 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1109 out <- [after bind]Blueprints <<[ [[after bind]Blueprints >>]Set[~, [[[after bind]Blueprints >>]Index[~]]Add Method[[parts]Index[0]] ] ] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1110 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1111 out <- Val[after bind] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1112 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1113 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1114 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1115 Bind Blueprint@NProgram[prog,name,blueprint:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1116 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1117 Print[["Bind blueprint: "]Append[name]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1118 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
|
1119 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1120 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1121 _Compile Program BP[backend, blueprint, name:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1122 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1123 out <- [blueprint]Compile Blueprint[backend, name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1124 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1125 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1126 _Compile Program BP Special[backend, blueprint, name:out] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1127 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1128 out <- [blueprint]Compile Special[backend, name] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1129 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1130 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1131 _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
|
1132 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1133 out <- [worker]Compile Worker[backend, name] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1134 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1135 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1136 Compile Program@NProgram[prog, backend:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1137 { |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1138 out <- Fold["_Compile Program", Fold["_Compile Program BP Special", Fold["_Compile Program BP", backend, [prog]Blueprints >>], [prog]Blueprints >>], [prog]Workers >>] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1139 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1140 |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1141 Register Method@NProgram[prog, name, convention, inputs, outputs: out] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1142 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1143 out <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs, Yes]]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1144 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1145 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1146 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
|
1147 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1148 Print[["Register Worker "]Append[name]] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1149 after reg <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs, No]]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1150 parts <- [name]Split["@"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1151 [parts]Index[1] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1152 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1153 out <- [after reg]Register Method[[parts]Index[0], convention, inputs, outputs] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1154 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1155 out <- Val[after reg] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1156 } |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1157 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1158 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1159 Register Builtins@NProgram[prog:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1160 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1161 registered <- [[[[[[[[[[[prog]Register Worker["+@Int32", "rhope", 2, 1] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1162 ]Register Worker["-@Int32", "rhope", 2, 1] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1163 ]Register Worker["*@Int32", "rhope", 2, 1] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1164 ]Register Worker["/@Int32", "rhope", 2, 1] |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1165 ]Register Worker["LShift@Int32", "rhope", 2, 1] |
|
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1166 ]Register Worker["RShift@Int32", "rhope", 2, 1] |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
1167 ]Register Worker["Print", "rhope", 1, 1] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1168 ]Register Worker["If@Boolean", "rhope", 1, 2] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1169 ]Register Worker["<@Int32", "rhope", 2, 1] |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
36
diff
changeset
|
1170 ]Register Worker[">@Int32", "rhope", 2, 1] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1171 ]Register Worker["Build", "rhope", 1, 1] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1172 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1173 out <- [[[[[[[[[[[[[registered]Bind Blueprint["Int32", NBlueprint[]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1174 ]Bind Worker["+@Int32", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1175 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1176 ]Inputs <<[("left","right")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1177 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1178 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1179 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1180 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1181 ]Bind Worker["-@Int32", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1182 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1183 ]Inputs <<[("left","right")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1184 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1185 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1186 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1187 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1188 ]Bind Worker["*@Int32", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1189 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1190 ]Inputs <<[("left","right")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1191 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1192 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1193 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1194 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1195 ]Bind Worker["/@Int32", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1196 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1197 ]Inputs <<[("left","right")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1198 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1199 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1200 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1201 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1202 ]Bind Worker["LShift@Int32", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1203 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1204 ]Inputs <<[("left","right")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1205 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1206 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1207 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1208 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1209 ]Bind Worker["RShift@Int32", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1210 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1211 ]Inputs <<[("left","right")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1212 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1213 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1214 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1215 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1216 ]Bind Worker["<@Int32", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1217 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1218 ]Inputs <<[("left","right")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1219 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1220 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1221 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1222 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1223 ]Bind Worker[">@Int32", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1224 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1225 ]Inputs <<[("left","right")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1226 ]Input Types <<[ [[()]Append[Type Instance["Int32"]]]Type Instance["Int32"] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1227 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1228 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1229 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1230 ]Bind Blueprint["Boolean", NBlueprint[]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1231 ]Bind Worker["If@Boolean", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1232 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1233 ]Inputs <<[("condition")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1234 ]Input Types <<[ [()]Append[Type Instance["Boolean"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1235 ]Outputs <<[("isyes","isno")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1236 ]Output types <<[ [[()]Append[Type Instance["Boolean"]]]Append[Type Instance["Boolean"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1237 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1238 ]Bind Worker["Print", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1239 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1240 ]Inputs <<[("value")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1241 ]Input Types <<[ [()]Append[Type Instance["Any Type"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1242 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1243 ]Output types <<[ [()]Append[Type Instance["Int32"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1244 ]Builin? <<[Yes]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1245 ]Bind Worker["Build", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1246 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1247 ]Inputs <<[("type")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1248 ]Input Types <<[ [()]Append[Type Instance["Blueprint"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1249 ]Outputs <<[("out")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1250 ]Output types <<[ [()]Append[Type Instance["Any Type"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1251 ]Builin? <<[Yes]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1252 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1253 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1254 Find Worker@NProgram[prog, name:out,notfound] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1255 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1256 Print[ ["Find Worker@NProgram: "]Append[name] ] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1257 out,notfound <- [[prog]Worker Refs >>]Index[name] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1258 } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1259 |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1260 Find Worker Def@NProgram[prog,name:out,notfound] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1261 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1262 out,notfound <- [[prog]Workers >>]Index[name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1263 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1264 |
|
43
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1265 Find Method@NProgram[prog, name, type:out,notfound] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1266 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1267 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1268 ,notfound <- If[[bp]Understands Method[name]] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1269 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1270 out <- [[prog]Workers >>]Index[[[name]Append["@"]]Append[[type]Name >>]] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1271 } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1272 } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1273 |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1274 Find Field@NProgram[prog, name, type:fieldtype,notfound] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1275 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1276 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1277 fieldtype,notfound <- [bp]Get Field Type[name] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1278 } |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1279 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1280 Implicit Conversion@NProgram[prog, fromtype, totype:func,notfound] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1281 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1282 notfound <- No |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1283 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1284 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1285 Is Method?@NProgram[prog,name:is,is not] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1286 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1287 ,is not <- [[prog]Worker Refs>>]Index[name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1288 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1289 is,is not <- If[[~]Is Method? >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1290 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1291 } |