Mercurial > repos > rhope
annotate nworker.rhope @ 66:d4b44ae2e34a
New variant of C backend works now
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Sun, 06 Jun 2010 20:29:10 -0400 |
parents | 689fb73e7612 |
children | d0ce696786cc |
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 |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
3 Import number.rhope |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
4 Import boolean.rhope |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
5 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
6 Blueprint Condition Set |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
7 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
8 Variables |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
9 Subsets |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
10 Condition Type |
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
13 AndSet[:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
14 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
15 out <- [[[Build["Condition Set"]]Variables <<[Dictionary[]]]Subsets <<[Dictionary[]]]Condition Type <<["And"] |
30
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
18 OrSet[:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
19 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
20 out <- [[[Build["Condition Set"]]Variables <<[Dictionary[]]]Subsets <<[Dictionary[]]]Condition Type <<["Or"] |
30
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
23 To String@Condition Set[set:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
24 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
25 out <- [[[[[set]Condition Type >> |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
26 ]Append["Set:\n\tVariables:\n\t\t"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
27 ]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
|
28 ]Append["\n\tSubsets:\n\t\t"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
29 ]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
|
30 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
31 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
32 Add Condition@Condition Set[set,cond:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
33 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
34 If[[Type Of[cond]] = ["Condition Set"]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
35 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
36 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
|
37 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
38 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
|
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
42 =@Condition Set[set1,set2:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
43 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
44 ,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
|
45 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
46 ,out <- If[[[set1]Variables >>] = [[set2]Variables >>]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
47 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
48 out,out <- If[[[set1]Subsets >>] = [[set2]Subsets >>]] |
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
53 _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
|
54 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
55 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
|
56 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
57 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
58 _For Backend Subset[current,subset,type:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
59 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
60 Print["Calling For Backend on subset"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
61 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
62 [subset]For Backend |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
63 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
64 Print["Got output from for backend"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
65 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
|
66 { Print["done _For Backend Subset with condition"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
67 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
68 Print["none output from for backend"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
69 out <- current |
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
74 Empty?@Condition Set[set:not empty,empty] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
75 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
76 [[set]Variables >>]First |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
77 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
78 not empty <- Yes |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
79 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
80 ,empty <- [[set]Subsets >>]First Non-empty Set |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
81 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
82 not empty <- Yes |
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
87 _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
|
88 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
89 current <- [setlist]Index[index] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
90 [[current]Variables >>]First |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
91 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
92 out <- index |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
93 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
94 ,trynext <- [[current]Subsets >>]First Non-empty Set |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
95 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
96 out <- index |
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 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
99 Val[trynext] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
100 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
101 ,none <- [setlist]Next[index] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
102 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
103 out,none <- _First Non-empty Set[setlist, ~] |
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
108 First Non-empty Set[setlist:index,none] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
109 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
110 ,none <- [setlist]First |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
111 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
112 index,none <- _First Non-empty Set[setlist,~] |
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 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
116 For Backend@Condition Set[set:out,none] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
117 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
118 Print["For Backend"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
119 firstvar <- [[set]Variables >>]First |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
120 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
121 Print["At least one var"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
122 [[set]Variables >>]Next[~] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
123 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
124 Print["at least two vars"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
125 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
|
126 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
127 Print["just one var"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
128 vars <- Val[firstvar] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
129 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
130 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
|
131 { Print["done For Backend, with vars"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
132 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
133 Print["no vars"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
134 [[set]Subsets >>]First Non-empty Set |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
135 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
136 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
|
137 firstsub <- [[[set]Subsets >>]Index[~]]For Backend |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
138 [[set]Subsets >>]Next[~] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
139 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
140 Print["at least two subsets"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
141 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
|
142 { Print["done with subsets, but no vars"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
143 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
144 out <- Val[firstsub] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
145 { Pretty Print[~, "1s:\t"] } |
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 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
148 Print["done with none"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
149 none <- Yes |
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 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
153 |
2 | 154 Set@Range[range,index,val:out] |
155 { | |
156 out <- [[()]Concatenate[range] | |
157 ]Set[index,val] | |
158 } | |
159 | |
160 List of Lists[num:out] | |
161 { | |
162 out <- Fold[["Append"]Set Input[1, ()],(), Range[0,num]] | |
163 } | |
164 | |
165 Blueprint Worker Ref | |
166 { | |
167 Name | |
168 Convention | |
169 Inputs | |
170 Outputs | |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
171 Is Method? |
2 | 172 } |
173 | |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
174 Worker Ref[name,convention,inputs,outputs,ismethod?:out] |
2 | 175 { |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
176 out <- [[[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs]]Is Method? <<[ismethod?] |
2 | 177 } |
178 | |
179 Blueprint Node Ref | |
180 { | |
181 Index | |
182 IO Num | |
183 } | |
184 | |
185 Node Ref[index,ionum:out] | |
186 { | |
187 out <- [[Build["Node Ref"]]Index <<[index]]IO Num <<[ionum] | |
188 } | |
189 | |
190 =@Node Ref[left,right:out] | |
191 { | |
192 ,out <- If[[[left]Index >>] = [[right]Index >>]] | |
193 { | |
194 out <- [[left]IO Num>>] = [[right]IO Num >>] | |
195 } | |
196 } | |
197 | |
198 Blueprint NWorker Node | |
199 { | |
200 Type | |
201 Data | |
202 Inputs | |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
203 Input Types |
2 | 204 Outputs |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
205 Output Types |
2 | 206 Wires From |
207 Wires To | |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
208 Conditions |
2 | 209 } |
210 | |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
211 Wire To@NWorker Node[node,from,output,pre input:out] |
2 | 212 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
213 input <- [pre input]+[1] |
2 | 214 out <- [node]Wires To <<[ |
215 [[node]Wires To >>]Set[input, | |
216 [[[node]Wires To >>]Index[input] | |
217 ]Append[Node Ref[from,output]] | |
218 ] | |
219 ] | |
220 } | |
221 | |
222 Wire From@NWorker Node[node,to,input,output:out] | |
223 { | |
224 out <- [node]Wires From <<[ | |
225 [[node]Wires From >>]Set[output, | |
226 [[[node]Wires From >>]Index[output] | |
227 ]Append[Node Ref[to,input]] | |
228 ] | |
229 ] | |
230 } | |
231 | |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
232 _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
|
233 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
234 does <- If[[input num] > [[node]Inputs >>]] {} |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
235 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
236 ,does not <- [[node]Input Types >>]Index[input num] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
237 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
238 count <- [~]Index[1] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
239 ,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
|
240 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
241 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
|
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 |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
247 Has Input Types?@NWorker Node[node:does,does not] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
248 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
249 If[[[[node]Inputs >>]Length] > [0]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
250 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
251 does,does not <- _Has Input Types[node,0] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
252 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
253 does <- Yes |
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 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
256 |
2 | 257 _Dependency[dlist,ref:out] |
258 { | |
259 [dlist]Find[ref] | |
260 { | |
261 out <- dlist | |
262 }{ | |
263 out <- [dlist]Append[ref] | |
264 } | |
265 } | |
266 | |
267 Dependencies@NWorker Node[node:out] | |
268 { | |
269 out <- Fold[["Fold"]Set Input[0, "_Dependency"], (), [node]Wires To >>] | |
270 } | |
271 | |
272 | |
273 NWorker Node[type,data,inputs,outputs:out] | |
274 { | |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
275 out <- [[[[[[[[[Build["NWorker Node"] |
2 | 276 ]Type <<[type] |
277 ]Data <<[data] | |
278 ]Inputs <<[inputs] | |
279 ]Outputs <<[outputs] | |
280 ]Wires From <<[List of Lists[outputs]] | |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
281 ]Wires To <<[List of Lists[[inputs]+[1]]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
282 ]Conditions <<[AndSet[]] |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
283 ]Input Types <<[()] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
284 ]Output Types <<[()] |
2 | 285 } |
286 | |
287 Blueprint NWorker | |
288 { | |
289 Convention | |
290 Nodes | |
291 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
|
292 Input Types |
2 | 293 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
|
294 Output Types |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
295 Uses |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
296 NodeResults |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
297 Free Temps |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
298 Name |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
299 Builtin? |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
300 Library |
2 | 301 } |
302 | |
303 NWorker[convention:out] | |
304 { | |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
305 out <- [[[[[[[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]]Input Types <<[()]]Output Types <<[()]]Name <<["Anonymous"]]Builtin? <<[No]]Library << [""] |
2 | 306 } |
307 | |
308 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index] | |
309 { | |
310 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]] | |
311 node index <- [[worker]Nodes >>]Length | |
312 } | |
313 | |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
314 Propagate Type[nodelist,dest,prog,worker,type:out] |
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 <- [nodelist]Index[[dest]Index >>] |
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 [[node]Input Types >>]Index[[dest]IO Num >>] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
319 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
320 existing type <- [~]Index[0] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
321 new count <- [[~]Index[1]]+[1] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
322 If[[[existing type]Name >>] = [[type]Name >>]] |
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]Variant >>] = [[type]Variant >>]] |
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 If[[[existing type]Params >>] = [[type]Params >>]] |
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 type <- Val[existing type] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
329 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
330 new variant <- [existing type]Variant >> |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
331 new params <- () |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
332 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
333 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
334 new variant <- "Boxed" |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
335 If[[[existing type]Params >>] = [[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 <- [existing type]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 new params <- () |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
340 } |
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 <- [[existing type]Set Variant[new variant]]Params <<[new params] |
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 new type <- Type Instance["Any Type"] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
345 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
346 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
347 new type <- Val[type] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
348 new count <- 1 |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
349 } |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
350 new node <- [node]Input Types <<[ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
351 [ [node]Input Types >> ]Set[ [dest]IO Num >>, [[()]Append[new type]]Append[new count] ] |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
352 ] |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
353 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
|
354 } |
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 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
|
357 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
358 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
|
359 } |
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 Infer Types Node[nodelist,node,index,prog,worker:out] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
362 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
363 If[[[node]Type >>] = ["const"]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
364 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
365 //Temporary hack |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
366 If[[Type Of[[node]Data >>]] = ["Whole Number"]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
367 { |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
368 outtype <- Type Instance["Int32"] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
369 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
370 If[[Type Of[[node]Data >>]] = ["Type Instance"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
371 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
372 outtype <- Type Instance["Blueprint"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
373 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
374 If[[Type Of[[node]Data >>]] = ["Machine Integer"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
375 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
376 If[[[node]Data >>]Signed? >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
377 { base <- "Int" } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
378 { base <- "UInt" } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
379 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
380 outtype <- Type Instance[[base]Append[ [[node]Data >>]Size >> ]] |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
381 }{ |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
382 outtype <- Type Instance[Type Of[[node]Data >>]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
383 } |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
384 } |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
385 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
386 nextnode <- [node]Output Types <<[ [()]Append[outtype] ] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
387 |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
388 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
389 If[[[node]Type >>] = ["input"]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
390 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
391 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
|
392 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
393 If[[[node]Type >>] = ["output"]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
394 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
395 out <- nodelist |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
396 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
397 [node]Has Input Types? |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
398 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
399 If[[[node]Type >>] = ["setfield"]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
400 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
401 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
|
402 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
403 If[[[node]Type >>] = ["getfield"]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
404 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
405 type <- [[[node]Input Types >>]Index[0]]Index[0] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
406 If[[[type]Name >>] = ["Any Type"]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
407 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
408 outtype <- Val[type] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
409 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
410 outtype <- [prog]Find Field[[node]Data >>, 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 //TODO: Return errors rather than printing them |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
413 Print[ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
414 [[[[["Type " |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
415 ]Append[[type]Name >>] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
416 ]Append[" does not have a field named "] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
417 ]Append[[node]Data >>] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
418 ]Append[" in worker "] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
419 ]Append[worker name]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
420 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
421 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
422 nextnode <- [node]Output Types <<[ [()]Append[outtype] ] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
423 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
424 worker name <- [[node]Data >>]Name >> |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
425 [prog]Is Method?[worker name] |
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 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
|
428 If[[[first arg type]Name >>] = ["Any Type"]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
429 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
430 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
|
431 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
432 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
|
433 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
434 //TODO: Return errors instead of printing them |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
435 Print[ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
436 [[[[["Type " |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
437 ]Append[[first arg type]Name >>] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
438 ]Append[" does not support method "] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
439 ]Append[worker name] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
440 ]Append[" in worker "] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
441 ]Append[ [worker]Name >> ]] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
442 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
443 } |
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 worker def <- [prog]Find Worker Def[worker name] |
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 outtypes <- [worker def]Output Types >> |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
448 nextnode <- [node]Output Types <<[ outtypes ] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
449 } |
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 }{ |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
452 out <- nodelist |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
453 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
454 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
455 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
456 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
457 |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
458 Val[nextnode] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
459 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
460 nextlist <- [nodelist]Set[index, nextnode] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
461 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
|
462 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
463 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
464 |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
465 Infer Types@NWorker[worker,prog:out] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
466 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
467 Print[["Start inference: "]Append[[worker]Name >>]] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
468 out <- [worker]Nodes <<[Fold[[["Infer Types Node"]Set Input[3, prog]]Set Input[4, worker], [worker]Nodes >>, [worker]Nodes >>]] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
469 { Print[["End inference: "]Append[[worker]Name >>]] } |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
470 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
471 |
2 | 472 Add Worker Call@NWorker[worker,tocall:out,node index] |
473 { | |
474 out, node index <- [worker]Add Node["call",tocall,[tocall]Inputs >>,[tocall]Outputs >>] | |
475 } | |
476 | |
477 Add Constant@NWorker[worker,constant:out,node index] | |
478 { | |
479 out, node index <- [worker]Add Node["const",constant,0,1] | |
480 } | |
481 | |
482 Add Input@NWorker[worker,name,number:out,node index] | |
483 { | |
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 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
|
485 } |
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 |
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 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
|
488 { |
2 | 489 ,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
|
490 { |
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
|
491 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
|
492 ]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
|
493 } |
2 | 494 } |
495 | |
496 Add Output@NWorker[worker,name,number:out,node index] | |
497 { | |
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
|
498 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
|
499 } |
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
|
500 |
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
|
501 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
|
502 { |
2 | 503 ,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
|
504 { |
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
|
505 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
|
506 ]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
|
507 } |
2 | 508 } |
509 | |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
510 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
|
511 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
512 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
|
513 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
514 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
515 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
|
516 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
517 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
|
518 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
519 |
2 | 520 Add Wire@NWorker[worker,from,output,to,input:out] |
521 { | |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
522 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
|
523 { |
2 | 524 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
|
525 { Print["fromw"] } |
2 | 526 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
|
527 { Print["tow"] } |
2 | 528 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
|
529 { Print["nodes"] } |
2 | 530 out <- [worker]Nodes <<[nodes] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
531 { Print["Add Wire@NWorker done"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
532 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
533 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
534 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
535 Uses@NWorker[worker,uses:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
536 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
537 out <- [worker]Uses <<[uses] |
2 | 538 } |
539 | |
540 _No Dependencies[list,node,index:out] | |
541 { | |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
542 [[node]Wires To>>]Index[1] |
2 | 543 { |
544 out <- Val[list] | |
545 }{ | |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
546 [[[node]Wires To>>]Index[0]]First |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
547 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
548 out <- Val[list] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
549 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
550 out <- [list]Append[index] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
551 } |
2 | 552 } |
553 } | |
554 | |
555 No Dependencies@NWorker[worker:out] | |
556 { | |
557 out <- Fold["_No Dependencies", (), [worker]Nodes >>] | |
558 } | |
559 | |
560 _Collect Dests[candidates,wire:out] | |
561 { | |
562 out <- [candidates]Set[[wire]Index >>, Yes] | |
563 } | |
564 | |
565 Collect Dests@NWorker[worker,candidates,node index:out] | |
566 { | |
567 out <- Fold[["Fold"]Set Input[0, "_Collect Dests"], candidates, [[[worker]Nodes >>]Index[node index]]Wires From >>] | |
568 } | |
569 | |
570 Check Dependency@NWorker[worker,nodes,wires,wire index:met?] | |
571 { | |
572 ref <- [wires]Index[wire index] | |
573 [nodes]Find[[ref]Index >>] | |
574 { | |
575 [wires]Next[wire index] | |
576 { | |
577 met? <- [worker]Check Dependency[nodes,wires,~] | |
578 }{ | |
579 met? <- Yes | |
580 } | |
581 }{ | |
582 met? <- No | |
583 } | |
584 } | |
585 _Check Dependencies@NWorker[worker,nodes,inputs,input index:met?] | |
586 { | |
587 wires <- [inputs]Index[input index] | |
588 [wires]First | |
589 { | |
590 current met? <- [worker]Check Dependency[nodes, wires, ~] | |
591 }{ | |
592 current met? <- Yes | |
593 } | |
594 If[current met?] | |
595 { | |
596 [inputs]Next[input index] | |
597 { | |
598 met? <- [worker]_Check Dependencies[nodes,inputs,~] | |
599 }{ | |
600 met? <- Yes | |
601 } | |
602 }{ | |
603 met? <- No | |
604 } | |
605 } | |
606 | |
607 Check Dependencies@NWorker[worker,nodes,candidate:met?] | |
608 { | |
609 inputs <- [[[worker]Nodes >>]Index[candidate]]Wires To >> | |
610 [inputs]First | |
611 { | |
612 met? <- [worker]_Check Dependencies[nodes, inputs, ~] | |
613 }{ | |
614 met? <- Yes | |
615 } | |
616 } | |
617 | |
618 Dependants@NWorker[worker,direct nodes,nodes:out] | |
619 { | |
620 candidates <- Keys[Fold[["Collect Dests"]Set Input[0,worker], (), direct nodes]] | |
621 out <- Filter[candidates, [["Check Dependencies"]Set Input[0, worker]]Set Input[1, nodes]] | |
622 } | |
623 | |
624 _Dependency Groups@NWorker[worker,last,all,grouped:out] | |
625 { | |
626 current <- [worker]Dependants[last,all] | |
627 [current]First | |
628 { | |
629 out <- [worker]_Dependency Groups[current, [all]Concatenate[current], [grouped]Append[current]] | |
630 }{ | |
631 out <- grouped | |
632 } | |
633 } | |
634 Dependency Groups@NWorker[worker:out] | |
635 { | |
636 no deps <- [worker]No Dependencies | |
637 out <- [worker]_Dependency Groups[no deps, no deps, [()]Append[no deps]] | |
638 } | |
639 | |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
640 Format Input@NWorker[worker,noderef:out] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
641 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
642 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
|
643 [("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
|
644 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
645 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
|
646 }{ |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
647 If[[[node]Type >>] = ["input"]] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
648 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
649 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
|
650 out <- AddRef[input name] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
651 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
652 If[[[node]Type >>] = ["const"]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
653 { |
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
|
654 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
|
655 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
656 //TODO: Support parametric types |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
657 datstring <- [[node]Data >>]Name >> |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
658 }{ |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
659 If[[Type Of[[node]Data >>]] = ["Machine Integer"]] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
660 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
661 If[[[node]Data >>]Signed? >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
662 { s <- "i" } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
663 { s <- "u" } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
664 datstring <- [[[[node]Data >>]Value >>]Append[s]]Append[[[node]Data >>]Size >>] |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
665 }{ |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
666 datstring <- [node]Data >> |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
667 } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
668 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
669 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
|
670 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
671 } |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
672 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
673 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
674 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
675 |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
676 Collect Input@NWorker[worker,nodeinput:out] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
677 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
678 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
|
679 |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
680 [inputchoices]First |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
681 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
682 first <- [inputchoices]Index[~] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
683 [inputchoices]Next[~] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
684 { |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
685 out <- _Fold[inputchoices, ~, first, "OrValue"] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
686 }{ |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
687 out <- Val[first] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
688 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
689 }{ |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
690 out <- No |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
691 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
692 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
693 |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
694 Collect Inputs@NWorker[worker,node:out] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
695 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
696 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
|
697 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
698 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
699 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
|
700 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
701 node <- [[worker]Nodes >>]Index[ [noderef]Index >> ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
702 If[[[node]Outputs >>] > [1]] |
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 <- [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
|
705 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
706 out <- [set]Add Condition[[node]Conditions >>] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
707 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
708 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
709 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
710 Collect Condition@NWorker[worker,set,nodeinput:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
711 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
712 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
|
713 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
714 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
715 Collect Conditions@NWorker[worker,node:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
716 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
717 Print["Collect Conditions"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
718 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
719 out <- 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
|
720 { Print["done Collect Conditions"] } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
721 } |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
722 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
723 |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
724 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
|
725 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
726 Print["Save Result"] |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
727 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
|
728 Print[out var] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
729 /*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
|
730 ]Move[Result[num], out var] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
731 */ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
732 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
|
733 } |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
734 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
735 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
|
736 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
737 If[[[node]Type >>] = ["getfield"]] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
738 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
739 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
|
740 }{ |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
741 If[[[node]Type >>] = ["setfield"]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
742 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
743 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
|
744 }{ |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
745 Print[["Call: "]Append[[[node]Data >>]Name >>]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
746 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
747 [program]Method?[[[node]Data >>]Name >>] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
748 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
749 Print["Method!"] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
750 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
|
751 { Print["Method Call done"] } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
752 }{ |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
753 Print["Function!"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
754 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
755 Pretty Print[inputs, ""] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
756 { with call <- [func]Call[[[node]Data >>]Name >>, inputs]} |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
757 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
758 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
759 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
760 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
761 } |
30
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 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
|
764 } |
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 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
|
767 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
768 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
|
769 node index <- [nodes]Index[current] |
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
770 node <- [[worker]Nodes >>]Index[node index] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
771 conditions <- [worker]Collect Conditions[node] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
772 [("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
|
773 { |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
774 inputs <- [worker]Collect Inputs[node] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
775 [conditions]For Backend |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
776 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
777 Print["Conditional execution, do if"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
778 stream <- [func]Instruction Stream |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
779 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
|
780 }{ |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
781 Print["No conditions, full steam ahead"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
782 stream <- Val[func] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
783 nfunc <- Val[nstream] |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
784 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
785 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
|
786 }{ |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
787 If[[[node]Type >>] = ["output"]] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
788 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
789 Print["Compiling output node"] |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
790 inputs <- [worker]Collect Inputs[node] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
791 [conditions]For Backend |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
792 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
793 Print["has conditions"] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
794 stream <- [func]Instruction Stream |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
795 nfunc <- [func]Do If[~, nstream] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
796 }{ |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
797 Print["no conditions"] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
798 stream <- Val[func] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
799 nfunc <- Val[nstream] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
800 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
801 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
|
802 }{ |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
803 If[[[node]Type >>] = ["const"]] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
804 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
805 //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
|
806 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
|
807 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
808 //TODO: Support parametric types |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
809 datstring <- [[node]Data >>]Name >> |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
810 }{ |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
811 If[[Type Of[[node]Data >>]] = ["Machine Integer"]] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
812 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
813 If[[[node]Data >>]Signed? >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
814 { s <- "i" } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
815 { s <- "u" } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
816 datstring <- [[[[node]Data >>]Value >>]Append[s]]Append[[[node]Data >>]Size >>] |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
817 }{ |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
818 datstring <- [node]Data >> |
50
689fb73e7612
Add support for various integer literals and add support for raw pointers to objects and raw pointers to arrays in the FFI
Mike Pavone <pavone@retrodev.com>
parents:
49
diff
changeset
|
819 } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
820 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
821 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
|
822 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
823 nfunc <- Val[func] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
824 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
825 |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
826 } |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
827 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
828 If[[[node]Outputs >>] = [0]] |
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 nworker <- Val[worker] |
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 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
|
833 } |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
834 [nodes]Next[current] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
835 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
836 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
|
837 }{ |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
838 out <- Val[nfunc] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
839 out worker <- Val[nworker] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
840 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
841 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
842 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
843 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
|
844 { |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
845 nodes <- [groups]Index[current] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
846 [nodes]First |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
847 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
848 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
|
849 }{ |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
850 nfunc <- Val[func] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
851 nworker <- Val[worker] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
852 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
853 [groups]Next[current] |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
854 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
855 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
|
856 }{ |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
857 out <- Val[nfunc] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
858 out worker <- Val[nworker] |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
859 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
860 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
861 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
862 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
|
863 { |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
864 //_result_index_ionum |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
865 parts <- [name]Split["_"] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
866 index <- <String@Whole Number[ [parts]Index[2] ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
867 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
|
868 node <- [[worker]Nodes >>]Index[index] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
869 do if <- If[[[node]Outputs >>] > [1]] {} |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
870 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
871 ,do if <- [[node]Conditions >>]Empty? |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
872 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
873 out <- [func]Release[name] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
874 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
875 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
876 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
877 Val[do if] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
878 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
879 stream <- [[func]Instruction Stream]Release[name] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
880 out <- [func]Do If[name, stream] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
881 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
882 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
883 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
884 Result Var[vars,io num,index:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
885 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
886 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
|
887 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
888 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
889 Node Result Vars[vars,node,index:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
890 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
891 [("call","getfield","setfield")]Find[[node]Type >>] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
892 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
893 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
|
894 }{ |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
895 out <- vars |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
896 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
897 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
898 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
899 Result Vars@NWorker[worker:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
900 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
901 out <- Fold["Node Result Vars", (), [worker]Nodes >>] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
902 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
903 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
904 Make Basic Type[type:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
905 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
906 out <- [Type Instance[[type]Name >>]]Params <<[ [type]Params >> ] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
907 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
908 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
909 FInputs[ifunc, input type, index, inputs:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
910 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
911 func <- [ifunc]Set Input Type[Make Basic Type[input type], index] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
912 name <- [inputs]Index[index] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
913 Print[["FInputs: "]Append[index]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
914 Pretty Print[input type, ""] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
915 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
916 If[[[input type]Variant >>] = ["Naked"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
917 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
918 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
919 naked <- [" naked"]Append[name] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
920 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
921 out <- [[[func]Allocate Var[naked, input type] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
922 ]Unbox[name, naked] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
923 ]Release[name] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
924 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
925 If[[input type]Mutable? >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
926 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
927 name <- [inputs]Index[index] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
928 copied <- [func]Copy[name, name] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
929 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
930 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
931 copied <- Val[func] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
932 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
933 If[[[input type]Variant >>] = ["Raw Pointer"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
934 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
935 raw <- [" raw"]Append[name] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
936 If[[[input type]Name >>]=["Array"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
937 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
938 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
939 out <- [[copied]Allocate Var[raw, input type] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
940 ]Array Raw Pointer[name, raw] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
941 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
942 out <- [[copied]Allocate Var[raw, input type] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
943 ]Get Raw Pointer[name, raw] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
944 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
945 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
946 out <- Val[copied] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
947 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
948 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
949 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
950 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
951 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
952 FParams[input:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
953 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
954 iname <- [input]Index[0] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
955 type <- [input]Index[1] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
956 If[[[type]Variant >>] = ["Naked"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
957 { out <- [" naked"]Append[iname] } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
958 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
959 If[[[type]Variant >>] = ["Raw Pointer"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
960 { out <- [" raw"]Append[iname] } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
961 { out <- Val[iname] } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
962 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
963 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
964 _Return Param[outputs, inputs, input types, index:out,none] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
965 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
966 Print[["_Return Param: "]Append[output]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
967 output <- [outputs]Index[index] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
968 [inputs]Find[output] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
969 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
970 If[[[input types]Index[~]]Mutable? >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
971 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
972 ,none <- [outputs]Next[index] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
973 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
974 out,none <- _Return Param[outputs, inputs, input types, ~] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
975 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
976 } { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
977 out <- index |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
978 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
979 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
980 out <- index |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
981 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
982 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
983 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
984 Return Param[outputs, inputs, input types:out,none] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
985 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
986 Print["Return Param"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
987 ,none <- [outputs]First |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
988 { out,none <- _Return Param[outputs, inputs, input types, ~] } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
989 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
990 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
991 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
992 Save Foreign Result[func, output, index, output types, inputs, input types:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
993 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
994 type <- [output types]Index[index] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
995 If[[[type]Variant >>] = ["Naked"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
996 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
997 out <- [func]Box[[" naked"]Append[output], output, type] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
998 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
999 [inputs]Find[output] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1000 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1001 If[[[input types]Index[~]]Mutable? >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1002 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1003 out <- [func]Move[output, Output[output]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1004 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1005 out <- func |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1006 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1007 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1008 out <- func |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1009 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1010 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1011 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1012 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1013 Compile Foreign Stub[worker,program,name:out] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1014 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1015 Print[["Compiling FFI stub for "]Append[name]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1016 ifunc <- [[program]Create Function[name, [worker]Inputs >>, [worker]Outputs >>, "rhope"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1017 ]Output Types <<[Map[[worker]Output Types >>, "Make Basic Type"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1018 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1019 rp num <- Return Param[[worker]Outputs >>, [worker]Inputs >>, [worker]Input Types >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1020 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1021 rbase <- [[worker]Outputs >>]Index[rp num] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1022 If[[[[[worker]Output Types >>]Index[rp num]]Variant >>] = ["Naked"]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1023 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1024 rparam <- [" naked"]Append[rbase] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1025 rfunc <- [ifunc]Allocate Var[rparam, [[worker]Output Types >>]Index[rp num]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1026 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1027 rparam <- Val[rbase] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1028 rfunc <- Val[ifunc] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1029 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1030 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1031 rparam <- "" |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1032 rfunc <- Val[ifunc] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1033 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1034 |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1035 Fold[["FInputs"]Set Input[3, [worker]Inputs >>], rfunc, [worker]Input Types >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1036 { [~]Call Foreign[name, [worker]Convention >>, Map[Zip[[worker]Inputs >>, [worker]Input Types >>], "FParams"], rparam] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1037 { Fold[[[["Save Foreign Result"]Set Input[3, [worker]Output Types >>]]Set Input[4, [worker]Inputs >>]]Set Input[5, [worker]Input Types >>], ~, [worker]Outputs >>] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1038 { out <- [program]Store Function[~] }}} |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1039 } |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
1040 |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
1041 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
|
1042 { |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1043 If[[worker]Builtin? >>] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1044 { |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1045 out <- program |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1046 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1047 If[[[worker]Library >>] = [""]] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1048 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1049 Print[["Compiling: "]Append[name]] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1050 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1051 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 >>] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1052 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1053 res vars <- [worker]Result Vars |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1054 func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, res vars], res vars], [worker]Outputs >>] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1055 |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1056 groups <- [worker]Dependency Groups |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1057 [groups]First |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1058 { |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1059 final func <- [worker]Compile Group[program,func,groups, ~] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1060 }{ |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1061 final func <- Val[func] |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1062 } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1063 out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, worker], final func, res vars], [worker]Inputs >>]] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1064 } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1065 }{ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1066 out <- Compile Foreign Stub[worker,[program]Link[[worker]Convention >>, [worker]Library >> ],name] |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1067 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1068 } |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
1069 } |
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
1070 |
2 | 1071 Test[:out] |
1072 { | |
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
1073 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
|
1074 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
|
1075 ,a <- [NWorker["rhope"] |
2 | 1076 ]Add Input["a", 0] { |
1077 ,b <- [~]Add Input["b", 1] { | |
1078 ,c <- [~]Add Input["c", 2] { | |
1079 ,outref <- [~]Add Output["out", 0] { | |
1080 ,call+ <- [~]Add Worker Call[ref+] { | |
1081 ,call* <- [~]Add Worker Call[ref*] { | |
1082 out <- [[[[[~]Add Wire[a,0,call+,0] | |
1083 ]Add Wire[b,0,call+,1] | |
1084 ]Add Wire[call+,0,call*,0] | |
1085 ]Add Wire[c,0,call*,1] | |
1086 ]Add Wire[call*,0,outref,0] | |
1087 }}}}}} | |
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
1088 } |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1089 |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
1090 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
|
1091 { |
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
1092 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
|
1093 } |
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1094 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1095 Blueprint NBlueprint |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1096 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1097 Fields |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1098 Methods |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1099 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1100 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1101 NBlueprint[:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1102 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1103 out <- [[Build["NBlueprint"]]Fields <<[()]]Methods <<[Dictionary[]] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1104 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1105 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1106 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
|
1107 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1108 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
|
1109 } |
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 Add Method@NBlueprint[bp,name:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1112 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1113 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
|
1114 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1115 |
43
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1116 Understands Method@NBlueprint[bp,name:out] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1117 { |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1118 out <- [[bp]Methods >>]Index[name] {} |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1119 { out <- No } |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1120 } |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1121 |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1122 Get Field Type@NBlueprint[bp,name:out,notfound] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1123 { |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1124 ,notfound <- [[bp]Fields >>]Index[name] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1125 { out <- [~]Index[1] } |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1126 } |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1127 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1128 _Compile Blueprint Fields[type,field:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1129 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1130 name <- [field]Index[0] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1131 ftype <- [field]Index[1] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1132 out <- [type]Add Field[name,ftype] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1133 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1134 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1135 _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
|
1136 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1137 out <- [type]Add Method[name] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1138 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1139 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1140 Make Init[func,field:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1141 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1142 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
|
1143 Print[["Field: "]Append[name]] |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1144 { 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
|
1145 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
|
1146 If[[variant] = ["Boxed"]] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1147 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1148 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
|
1149 { Print["done"] } |
40
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1150 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1151 out <- func |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1152 } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1153 } |
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 Make Copy[func,field:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1156 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1157 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
|
1158 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
|
1159 If[[variant] = ["Boxed"]] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1160 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1161 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
|
1162 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1163 stream <- [[got]Instruction Stream |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1164 ]AddRef No Dest[~] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1165 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
|
1166 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1167 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1168 out <- func |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1169 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1170 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1171 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1172 Make Cleanup[func,field:out] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1173 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1174 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
|
1175 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
|
1176 If[[variant] = ["Boxed"]] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1177 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1178 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
|
1179 { |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1180 stream <- [[got]Instruction Stream |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1181 ]Release[~] |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1182 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
|
1183 } |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1184 }{ |
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1185 out <- func |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1186 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1187 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1188 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1189 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
|
1190 { |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1191 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
|
1192 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
|
1193 ]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
|
1194 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
|
1195 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1196 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1197 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
|
1198 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1199 //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
|
1200 Print[["Getters Setters: "]Append[name]] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1201 name <- [field]Index[0] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1202 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
|
1203 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
|
1204 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
|
1205 ]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
|
1206 ]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
|
1207 ]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
|
1208 If[[[type]Variant >>] = ["Boxed"]] |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1209 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1210 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
|
1211 }{ |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1212 getter <- [[start getter]Box[getref, "out", type]]Release["obj"] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1213 { Print["Got getter"] } |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1214 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1215 |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1216 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
|
1217 ]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
|
1218 ]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
|
1219 ]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
|
1220 ]Copy["obj"] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1221 |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1222 If[[[type]Variant >>] = ["Boxed"]] |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1223 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1224 ,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
|
1225 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1226 stream <- [[~]Instruction Stream |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1227 ]Release[origref] |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1228 ,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
|
1229 ]Write Field["obj", name] |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1230 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1231 setter <- [[~]Move["newval", setref] |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1232 ]Move["obj", "out"] |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1233 { Print["got setter"] } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1234 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1235 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1236 }{ |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1237 ,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
|
1238 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1239 setter <- [[~]Unbox["newval", setref] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1240 ]Move["obj", "out"] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1241 { Print ["got setter"] } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1242 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1243 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1244 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1245 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
|
1246 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1247 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1248 |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1249 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
|
1250 { |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1251 Print[["Compiling blueprint: "]Append[name]] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1252 //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
|
1253 init name <- [" init "]Append[name] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1254 copy name <- [" copy "]Append[name] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1255 cleanup name <- [" cleanup "]Append[name] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1256 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
|
1257 ]Init <<[init name] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1258 ]Copy <<[copy name] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1259 ]Cleanup <<[cleanup name] |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1260 { Print["Created type on backend"] } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1261 |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1262 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
|
1263 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1264 |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1265 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
|
1266 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1267 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
|
1268 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
|
1269 cleanup name <- [" cleanup "]Append[name] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1270 got specials <- [bp]Make Special[ |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1271 [bp]Make Special[ |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1272 [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
|
1273 copy name, name, "Make Copy"], |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1274 cleanup name, name, "Make Cleanup"] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1275 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
|
1276 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1277 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1278 Blueprint NProgram |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1279 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1280 Blueprints |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1281 Workers |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1282 Worker Refs |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1283 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1284 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1285 NProgram[:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1286 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1287 out <- [[[Build["NProgram"]]Blueprints <<[Dictionary[]]]Workers <<[Dictionary[]]]Worker Refs <<[Dictionary[]] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1288 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1289 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1290 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
|
1291 { |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1292 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
|
1293 parts <- [name]Split["@"] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1294 [parts]Index[1] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1295 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1296 orig bp <- [[after bind]Blueprints >>]Index[~] {} |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1297 { orig bp <- NBlueprint[] } |
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1298 out <- [after bind]Blueprints <<[ [[after bind]Blueprints >>]Set[~, [orig bp]Add Method[[parts]Index[0]] ] ] |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1299 }{ |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1300 out <- Val[after bind] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1301 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1302 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1303 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1304 Bind Blueprint@NProgram[prog,name,blueprint:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1305 { |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1306 Print[["Bind blueprint: "]Append[name]] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1307 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
|
1308 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1309 |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1310 _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
|
1311 { |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1312 out <- [blueprint]Compile Blueprint[backend, name] |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1313 } |
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1314 |
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1315 _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
|
1316 { |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1317 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
|
1318 } |
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1319 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1320 _Compile Program[backend, worker, name:out] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1321 { |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1322 Print["_Compile Program"] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1323 out <- [worker]Compile Worker[backend, name] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1324 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1325 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1326 Compile Program@NProgram[prog, backend:out] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1327 { |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1328 backend with bps <- Generate Boolean Methods[Generate Number Methods[Fold["_Compile Program BP Special", Fold["_Compile Program BP", backend, [prog]Blueprints >>], [prog]Blueprints >>]]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1329 { Print["All blueprints added"] } |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1330 workers with infer <- SMap[[prog]Workers >>, ["Infer Types"]Set Input[1, prog]] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1331 { Print["Type inference complete"] } |
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1332 out <- Fold["_Compile Program", backend with bps, workers with infer] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1333 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1334 |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1335 Register Method@NProgram[prog, name, convention, inputs, outputs: out] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1336 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1337 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
|
1338 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1339 |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1340 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
|
1341 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1342 Print[["Register Worker "]Append[name]] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1343 after reg <- [prog]Worker Refs <<[ |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1344 [ [prog]Worker Refs >> ]Set[name, |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1345 Worker Ref[name, convention, inputs, outputs, No] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1346 ] |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1347 ] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1348 parts <- [name]Split["@"] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1349 [parts]Index[1] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1350 { |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1351 out <- [after reg]Register Method@NProgram[[parts]Index[0], convention, inputs, outputs] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1352 }{ |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1353 out <- Val[after reg] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1354 } |
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1355 } |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1356 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1357 Register Builtins@NProgram[prog:out] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1358 { |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1359 registered <- [[[[[prog]Register Worker["Print", "rhope", 1, 1] |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1360 ]Register Worker["If@Boolean", "rhope", 1, 2] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1361 ]Register Worker["Build", "rhope", 1, 1] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1362 ]Register Worker["Blueprint Of", "rhope", 1, 1] |
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1363 ]Register Number Methods |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1364 |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1365 out <- [[[[registered]Bind Worker["If@Boolean", |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1366 [[[[[NWorker["rhope"] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1367 ]Inputs <<[("condition")] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1368 ]Input Types <<[ [()]Append[Type Instance["Boolean"]] ] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1369 ]Outputs <<[("isyes","isno")] |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1370 ]Output Types <<[ [[()]Append[Type Instance["Boolean"]]]Append[Type Instance["Boolean"]] ] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1371 ]Builtin? <<[Yes]] |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1372 ]Bind Worker["Print", |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1373 [[[[[NWorker["rhope"] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1374 ]Inputs <<[("value")] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1375 ]Input Types <<[ [()]Append[Type Instance["Any Type"]] ] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1376 ]Outputs <<[("out")] |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1377 ]Output Types <<[ [()]Append[Type Instance["Int32"]] ] |
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1378 ]Builtin? <<[Yes]] |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1379 ]Bind Worker["Build", |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1380 [[[[[NWorker["rhope"] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1381 ]Inputs <<[("type")] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1382 ]Input Types <<[ [()]Append[Type Instance["Blueprint"]] ] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1383 ]Outputs <<[("out")] |
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
44
diff
changeset
|
1384 ]Output Types <<[ [()]Append[Type Instance["Any Type"]] ] |
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1385 ]Builtin? <<[Yes]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1386 ]Bind Worker["Blueprint Of", |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1387 [[[[[NWorker["rhope"] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1388 ]Inputs <<[("object")] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1389 ]Input Types <<[ [()]Append[Type Instance["Any Type"]]] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1390 ]Outputs <<[("type")] |
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1391 ]Output Types <<[ [()]Append[Type Instance["Blueprint"]]] |
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1392 ]Builtin? <<[Yes]] |
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1393 } |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1394 |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1395 Find Worker@NProgram[prog, name:out,notfound] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1396 { |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1397 Print[ ["Find Worker@NProgram: "]Append[name] ] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1398 out,notfound <- [[prog]Worker Refs >>]Index[name] |
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1399 } |
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1400 |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1401 Find Worker Def@NProgram[prog,name:out,notfound] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1402 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1403 out,notfound <- [[prog]Workers >>]Index[name] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1404 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1405 |
43
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1406 Find Method@NProgram[prog, name, type:out,notfound] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1407 { |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1408 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1409 ,notfound <- If[[bp]Understands Method[name]] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1410 { |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1411 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
|
1412 } |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1413 } |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1414 |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1415 Find Field@NProgram[prog, name, type:fieldtype,notfound] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1416 { |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1417 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1418 fieldtype,notfound <- [bp]Get Field Type[name] |
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1419 } |
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1420 |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1421 Implicit Conversion@NProgram[prog, fromtype, totype:func,notfound] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1422 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1423 notfound <- No |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1424 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1425 |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1426 Is Method?@NProgram[prog,name:is,is not] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1427 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1428 ,is not <- [[prog]Worker Refs>>]Index[name] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1429 { |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1430 is,is not <- If[[~]Is Method? >>] |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1431 } |
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1432 } |