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