Mercurial > repos > rhope
annotate nworker.rhope @ 105:43cc42df26cc
Various compiler improvements
| author | Mike Pavone <pavone@retrodev.com> |
|---|---|
| date | Tue, 24 Aug 2010 23:22:17 -0400 |
| parents | 7428aa5d6ade |
| children |
| rev | line source |
|---|---|
| 2 | 1 Import extendlib.rhope |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
2 Import cbackend.rhope |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
3 Import number.rhope |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
4 Import boolean.rhope |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
5 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
6 Blueprint Condition Set |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
7 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
8 Variables |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
9 Subsets |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
10 Condition Type |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
11 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
12 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
13 AndSet[:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
14 { |
|
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
15 out <- [[[Build["Condition Set"]]Variables <<[Dictionary[]]]Subsets <<[Dictionary[]]]Condition Type <<["And"] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
16 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
17 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
18 OrSet[:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
19 { |
|
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
20 out <- [[[Build["Condition Set"]]Variables <<[Dictionary[]]]Subsets <<[Dictionary[]]]Condition Type <<["Or"] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
21 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
22 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
23 To String@Condition Set[set:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
24 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
25 out <- [[[[[set]Condition Type >> |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
26 ]Append["Set:\n\tVariables:\n\t\t"] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
27 ]Append[ Join[Keys[[set]Variables >>], "\n\t\t"] ] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
28 ]Append["\n\tSubsets:\n\t\t"] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
29 ]Append[ Join[Keys[[set]Subsets >>], "\n\t\t"] ] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
30 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
31 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
32 Add Condition@Condition Set[set,cond:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
33 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
34 If[[Type Of[cond]] = ["Condition Set"]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
35 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
36 out <- [set]Subsets <<[ [[set]Subsets>>]Set[[cond]To String, cond] ] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
37 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
38 out <- [set]Variables <<[ [[set]Variables >>]Set[cond, Yes] ] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
39 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
40 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
41 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
42 =@Condition Set[set1,set2:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
43 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
44 ,out <- If[[[set1]Condition Type >>] = [[set2]Condition Type >>]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
45 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
46 ,out <- If[[[set1]Variables >>] = [[set2]Variables >>]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
47 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
48 out,out <- If[[[set1]Subsets >>] = [[set2]Subsets >>]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
49 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
50 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
51 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
52 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
53 _For Backend Var[current,junk,variable,type:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
54 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
55 out <- [[<String@Worker[[type]Append["Cond"]]]Do[ [[()]Append[current]]Append[variable] ]]Index[0] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
56 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
57 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
58 _For Backend Subset[current,subset,type:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
59 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
60 [subset]For Backend |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
61 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
62 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
|
63 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
64 out <- current |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
65 } |
|
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 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
68 Empty?@Condition Set[set:not empty,empty] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
69 { |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
70 Print["Empty?@Condition Set"] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
71 [[set]Variables >>]First |
|
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 not empty <- Yes |
|
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 ,empty <- [[set]Subsets >>]First Non-empty Set |
|
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 } |
|
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 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
82 _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
|
83 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
84 current <- [setlist]Index[index] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
85 [[current]Variables >>]First |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
86 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
87 out <- index |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
88 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
89 ,trynext <- [[current]Subsets >>]First Non-empty Set |
|
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 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
94 Val[trynext] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
95 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
96 ,none <- [setlist]Next[index] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
97 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
98 out,none <- _First Non-empty Set[setlist, ~] |
|
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 } |
|
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 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
103 First Non-empty Set[setlist:index,none] |
|
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 ,none <- [setlist]First |
|
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 index,none <- _First Non-empty Set[setlist,~] |
|
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 } |
|
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 For Backend@Condition Set[set:out,none] |
|
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 firstvar <- [[set]Variables >>]First |
|
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 [[set]Variables >>]Next[~] |
|
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 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
|
118 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
119 vars <- Val[firstvar] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
120 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
121 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
|
122 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
123 [[set]Subsets >>]First Non-empty Set |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
124 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
125 firstsub <- [[[set]Subsets >>]Index[~]]For Backend |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
126 [[set]Subsets >>]Next[~] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
127 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
128 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
|
129 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
130 out <- Val[firstsub] |
|
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 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
133 none <- Yes |
|
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 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
136 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
137 |
| 2 | 138 Set@Range[range,index,val:out] |
| 139 { | |
| 140 out <- [[()]Concatenate[range] | |
| 141 ]Set[index,val] | |
| 142 } | |
| 143 | |
| 144 List of Lists[num:out] | |
| 145 { | |
| 146 out <- Fold[["Append"]Set Input[1, ()],(), Range[0,num]] | |
| 147 } | |
| 148 | |
| 149 Blueprint Worker Ref | |
| 150 { | |
| 151 Name | |
| 152 Convention | |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
153 Inputs |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
154 Min Inputs |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
155 Outputs |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
156 Min Outputs |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
157 Is Method? |
| 2 | 158 } |
| 159 | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
160 Worker Ref[name,convention,inputs,outputs,ismethod?:out] |
| 2 | 161 { |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
162 out <- [[[[[[[Build["Worker Ref"]]Name <<[name]]Convention <<[convention]]Inputs <<[inputs]]Outputs <<[outputs]]Is Method? <<[ismethod?]]Min Inputs <<[inputs]]Min Outputs <<[outputs] |
| 2 | 163 } |
| 164 | |
| 165 Blueprint Node Ref | |
| 166 { | |
| 167 Index | |
| 168 IO Num | |
| 169 } | |
| 170 | |
| 171 Node Ref[index,ionum:out] | |
| 172 { | |
| 173 out <- [[Build["Node Ref"]]Index <<[index]]IO Num <<[ionum] | |
| 174 } | |
| 175 | |
| 176 =@Node Ref[left,right:out] | |
| 177 { | |
| 178 ,out <- If[[[left]Index >>] = [[right]Index >>]] | |
| 179 { | |
| 180 out <- [[left]IO Num>>] = [[right]IO Num >>] | |
| 181 } | |
| 182 } | |
| 183 | |
| 184 Blueprint NWorker Node | |
| 185 { | |
| 186 Type | |
| 187 Data | |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
188 Inputs |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
189 Min Inputs |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
190 Input Types |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
191 Outputs |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
192 Min Outputs |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
193 Output Types |
| 2 | 194 Wires From |
| 195 Wires To | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
196 Conditions |
| 2 | 197 } |
| 198 | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
199 Wire To@NWorker Node[node,from,output,pre input:out] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
200 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
201 existing cons <- [[node]Wires To >>]Index[input] {} |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
202 { existing cons <- () } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
203 input <- [pre input]+[1] |
| 2 | 204 out <- [node]Wires To <<[ |
| 205 [[node]Wires To >>]Set[input, | |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
206 [existing cons]Append[Node Ref[from,output]] |
| 2 | 207 ] |
| 208 ] | |
| 209 } | |
| 210 | |
| 211 Wire From@NWorker Node[node,to,input,output:out] | |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
212 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
213 existing cons <- [[node]Wires From >>]Index[output] {} |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
214 { exist cons <- () } |
| 2 | 215 out <- [node]Wires From <<[ |
| 216 [[node]Wires From >>]Set[output, | |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
217 [existing cons]Append[Node Ref[to,input]] |
| 2 | 218 ] |
| 219 ] | |
| 220 } | |
| 221 | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
222 _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
|
223 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
224 does <- If[[input num] > [[node]Inputs >>]] {} |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
225 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
226 ,does not <- [[node]Input Types >>]Index[input num] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
227 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
228 count <- [~]Index[1] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
229 ,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
|
230 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
231 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
|
232 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
233 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
234 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
235 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
236 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
237 Has Input Types?@NWorker Node[node:does,does not] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
238 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
239 If[[[[node]Inputs >>]Length] > [0]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
240 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
241 does,does not <- _Has Input Types[node,0] |
|
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 does <- Yes |
|
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 |
| 2 | 247 _Dependency[dlist,ref:out] |
| 248 { | |
| 249 [dlist]Find[ref] | |
| 250 { | |
| 251 out <- dlist | |
| 252 }{ | |
| 253 out <- [dlist]Append[ref] | |
| 254 } | |
| 255 } | |
| 256 | |
| 257 Dependencies@NWorker Node[node:out] | |
| 258 { | |
| 259 out <- Fold[["Fold"]Set Input[0, "_Dependency"], (), [node]Wires To >>] | |
| 260 } | |
| 261 | |
| 262 | |
| 263 NWorker Node[type,data,inputs,outputs:out] | |
| 264 { | |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
265 out <- [[[[[[[[[[[Build["NWorker Node"] |
| 2 | 266 ]Type <<[type] |
| 267 ]Data <<[data] | |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
268 ]Inputs <<[inputs] |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
269 ]Min Inputs <<[inputs] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
270 ]Outputs <<[outputs] |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
271 ]Min Outputs <<[outputs] |
| 2 | 272 ]Wires From <<[List of Lists[outputs]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
273 ]Wires To <<[List of Lists[[inputs]+[1]]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
274 ]Conditions <<[AndSet[]] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
275 ]Input Types <<[()] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
276 ]Output Types <<[()] |
| 2 | 277 } |
| 278 | |
| 279 Blueprint NWorker | |
| 280 { | |
| 281 Convention | |
| 282 Nodes | |
| 283 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
|
284 Input Types |
| 2 | 285 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
|
286 Output Types |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
287 Uses |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
288 NodeResults |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
289 Free Temps |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
290 Name |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
291 Builtin? |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
292 Library |
| 2 | 293 } |
| 294 | |
| 295 NWorker[convention:out] | |
| 296 { | |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
297 out <- [[[[[[[[[Build["NWorker"]]Convention <<[convention]]Nodes <<[()]]Inputs <<[()]]Outputs <<[()]]Input Types <<[()]]Output Types <<[()]]Name <<["Anonymous"]]Builtin? <<[No]]Library << [""] |
| 2 | 298 } |
| 299 | |
| 300 Add Node@NWorker[worker,type,data,inputs,outputs:out,node index] | |
| 301 { | |
| 302 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[NWorker Node[type,data,inputs,outputs]]] | |
| 303 node index <- [[worker]Nodes >>]Length | |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
304 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
305 |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
306 Add Full Node@NWorker[worker,type,data,inputs,min inputs,outputs,min outputs:out,node index] |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
307 { |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
308 out <- [worker]Nodes <<[[[worker]Nodes >>]Append[ |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
309 [[[NWorker Node[type,data,inputs,outputs] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
310 ]Min Inputs <<[min inputs] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
311 ]Min Outputs <<[min outputs] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
312 ]Wires To <<[List of Lists[[min inputs]+[1]]] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
313 ]] |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
314 node index <- [[worker]Nodes >>]Length |
| 2 | 315 } |
| 316 | |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
317 Propagate Type[nodelist,dest,prog,worker,type:out] |
|
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 node <- [nodelist]Index[[dest]Index >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
320 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
321 [[node]Input Types >>]Index[[dest]IO Num >>] |
|
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 existing type <- [~]Index[0] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
324 new count <- [[~]Index[1]]+[1] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
325 If[[[existing type]Name >>] = [[type]Name >>]] |
|
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 If[[[existing type]Variant >>] = [[type]Variant >>]] |
|
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 If[[[existing type]Params >>] = [[type]Params >>]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
330 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
331 new type <- Val[existing type] |
|
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 <- [existing type]Variant >> |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
334 new 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 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
337 new variant <- "Boxed" |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
338 If[[[existing type]Params >>] = [[type]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 new params <- [existing type]Params >> |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
341 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
342 new params <- () |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
343 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
344 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
345 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
|
346 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
347 new type <- Type Instance["Any Type"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
348 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
349 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
350 new type <- Val[type] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
351 new count <- 1 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
352 } |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
353 new node <- [node]Input Types <<[ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
354 [ [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
|
355 ] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
356 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
|
357 } |
|
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 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
|
360 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
361 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
|
362 } |
|
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 Infer Types Node[nodelist,node,index,prog,worker:out] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
365 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
366 If[[[node]Type >>] = ["const"]] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
367 { |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
368 const type <- Type Of[[node]Data >>] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
369 //Temporary hack |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
370 If[[const type] = ["Whole Number"]] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
371 { |
|
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
|
372 outtype <- Type Instance["Int32"] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
373 }{ |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
374 If[[const type] = ["Type Instance"]] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
375 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
376 outtype <- Type Instance["Blueprint"] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
377 }{ |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
378 If[[const type] = ["Machine Integer"]] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
379 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
380 If[[[node]Data >>]Signed? >>] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
381 { base <- "Int" } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
382 { base <- "UInt" } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
383 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
384 outtype <- Type Instance[[base]Append[ [[node]Data >>]Size >> ]] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
385 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
386 If[[const type] = ["Worker Literal"]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
387 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
388 outtype <- Type Instance["Worker"] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
389 }{ |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
390 outtype <- Type Instance[const type] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
391 } |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
392 } |
|
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
|
393 } |
|
44
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 nextnode <- [node]Output Types <<[ [()]Append[outtype] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
396 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
397 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
398 If[[[node]Type >>] = ["input"]] |
|
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 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
|
401 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
402 If[[[node]Type >>] = ["output"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
403 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
404 out <- nodelist |
|
73
6a1a7d5cc2d9
Add some error checking, cleanup output and add a bad test file
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
405 |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
406 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
407 [node]Has Input Types? |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
408 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
409 If[[[node]Type >>] = ["setfield"]] |
|
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 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
|
412 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
413 If[[[node]Type >>] = ["getfield"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
414 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
415 type <- [[[node]Input Types >>]Index[0]]Index[0] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
416 If[[[type]Name >>] = ["Any Type"]] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
417 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
418 outtype <- Val[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 outtype <- [prog]Find Field[[node]Data >>, type] {} |
|
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 //TODO: Return errors rather than printing them |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
423 Print[ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
424 [[[[["Type " |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
425 ]Append[[type]Name >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
426 ]Append[" does not have a field named "] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
427 ]Append[[node]Data >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
428 ]Append[" in worker "] |
|
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 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
431 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
432 nextnode <- [node]Output Types <<[ [()]Append[outtype] ] |
|
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 worker name <- [[node]Data >>]Name >> |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
435 [prog]Is Method?[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 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
|
438 If[[[first arg type]Name >>] = ["Any Type"]] |
|
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 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
|
441 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
442 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
|
443 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
444 //TODO: Return errors instead of printing them |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
445 Print[ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
446 [[[[["Type " |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
447 ]Append[[first arg type]Name >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
448 ]Append[" does not support method "] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
449 ]Append[worker name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
450 ]Append[" in worker "] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
451 ]Append[ [worker]Name >> ]] |
|
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 worker def <- [prog]Find Worker Def[worker name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
456 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
457 outtypes <- [worker def]Output Types >> |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
458 nextnode <- [node]Output Types <<[ outtypes ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
459 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
460 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
461 }{ |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
462 out <- nodelist |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
463 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
464 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
465 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
466 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
467 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
468 Val[nextnode] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
469 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
470 nextlist <- [nodelist]Set[index, nextnode] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
471 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
|
472 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
473 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
474 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
475 Infer Types@NWorker[worker,prog:out] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
476 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
477 out <- [worker]Nodes <<[Fold[[["Infer Types Node"]Set Input[3, prog]]Set Input[4, worker], [worker]Nodes >>, [worker]Nodes >>]] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
478 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
479 |
| 2 | 480 Add Worker Call@NWorker[worker,tocall:out,node index] |
| 481 { | |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
482 out, node index <- [worker]Add Full Node["call",tocall,[tocall]Inputs >>, [tocall]Min Inputs >>,[tocall]Outputs >>, [tocall]Min Outputs >>] |
| 2 | 483 } |
| 484 | |
| 485 Add Constant@NWorker[worker,constant:out,node index] | |
| 486 { | |
| 487 out, node index <- [worker]Add Node["const",constant,0,1] | |
| 488 } | |
| 489 | |
| 490 Add Input@NWorker[worker,name,number:out,node index] | |
| 491 { | |
|
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
|
492 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
|
493 } |
|
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 |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
495 Add Anon Input@NWorker[worker,number:out] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
496 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
497 If[[number]>[Length[[worker]Inputs >>]]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
498 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
499 prepped <- [worker]Add Anon Input[[number]-[1]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
500 }{ |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
501 prepped <- Val[worker] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
502 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
503 out <- out <- [[prepped]Inputs <<[[[prepped]Inputs >>]Set[number,[" unnamed"]Append[number]]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
504 ]Input Types <<[[[prepped]Input Types >>]Set[number,Type Instance["Any Type"]]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
505 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
506 |
|
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
|
507 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
|
508 { |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
509 If[[number]>[Length[[worker]Inputs >>]]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
510 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
511 prepped <- [worker]Add Anon Input[[number]-[1]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
512 }{ |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
513 prepped <- Val[worker] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
514 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
515 ,node index <- [prepped]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
|
516 { |
|
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
|
517 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
|
518 ]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
|
519 } |
| 2 | 520 } |
| 521 | |
| 522 Add Output@NWorker[worker,name,number:out,node index] | |
| 523 { | |
|
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
|
524 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
|
525 } |
|
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
|
526 |
|
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
|
527 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
|
528 { |
| 2 | 529 ,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
|
530 { |
|
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
|
531 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
|
532 ]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
|
533 } |
| 2 | 534 } |
| 535 | |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
536 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
|
537 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
538 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
|
539 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
540 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
541 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
|
542 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
543 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
|
544 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
545 |
| 2 | 546 Add Wire@NWorker[worker,from,output,to,input:out] |
| 547 { | |
| 548 fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output] | |
| 549 tow <- [[[worker]Nodes >>]Index[to]]Wire To[from,output,input] | |
| 550 nodes <- [[[worker]Nodes >>]Set[from, fromw]]Set[to, tow] | |
| 551 out <- [worker]Nodes <<[nodes] | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
552 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
553 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
554 Uses@NWorker[worker,uses:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
555 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
556 out <- [worker]Uses <<[uses] |
| 2 | 557 } |
| 558 | |
| 559 _No Dependencies[list,node,index:out] | |
| 560 { | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
561 [[node]Wires To>>]Index[1] |
| 2 | 562 { |
| 563 out <- Val[list] | |
| 564 }{ | |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
565 [[[node]Wires To>>]Index[0]]First |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
566 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
567 out <- Val[list] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
568 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
569 out <- [list]Append[index] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
570 } |
| 2 | 571 } |
| 572 } | |
| 573 | |
| 574 No Dependencies@NWorker[worker:out] | |
| 575 { | |
| 576 out <- Fold["_No Dependencies", (), [worker]Nodes >>] | |
| 577 } | |
| 578 | |
| 579 _Collect Dests[candidates,wire:out] | |
| 580 { | |
| 581 out <- [candidates]Set[[wire]Index >>, Yes] | |
| 582 } | |
| 583 | |
| 584 Collect Dests@NWorker[worker,candidates,node index:out] | |
| 585 { | |
| 586 out <- Fold[["Fold"]Set Input[0, "_Collect Dests"], candidates, [[[worker]Nodes >>]Index[node index]]Wires From >>] | |
| 587 } | |
| 588 | |
| 589 Check Dependency@NWorker[worker,nodes,wires,wire index:met?] | |
| 590 { | |
| 591 ref <- [wires]Index[wire index] | |
| 592 [nodes]Find[[ref]Index >>] | |
| 593 { | |
| 594 [wires]Next[wire index] | |
| 595 { | |
| 596 met? <- [worker]Check Dependency[nodes,wires,~] | |
| 597 }{ | |
| 598 met? <- Yes | |
| 599 } | |
| 600 }{ | |
| 601 met? <- No | |
| 602 } | |
| 603 } | |
| 604 _Check Dependencies@NWorker[worker,nodes,inputs,input index:met?] | |
| 605 { | |
| 606 wires <- [inputs]Index[input index] | |
| 607 [wires]First | |
| 608 { | |
| 609 current met? <- [worker]Check Dependency[nodes, wires, ~] | |
| 610 }{ | |
| 611 current met? <- Yes | |
| 612 } | |
| 613 If[current met?] | |
| 614 { | |
| 615 [inputs]Next[input index] | |
| 616 { | |
| 617 met? <- [worker]_Check Dependencies[nodes,inputs,~] | |
| 618 }{ | |
| 619 met? <- Yes | |
| 620 } | |
| 621 }{ | |
| 622 met? <- No | |
| 623 } | |
| 624 } | |
| 625 | |
| 626 Check Dependencies@NWorker[worker,nodes,candidate:met?] | |
| 627 { | |
| 628 inputs <- [[[worker]Nodes >>]Index[candidate]]Wires To >> | |
| 629 [inputs]First | |
| 630 { | |
| 631 met? <- [worker]_Check Dependencies[nodes, inputs, ~] | |
| 632 }{ | |
| 633 met? <- Yes | |
| 634 } | |
| 635 } | |
| 636 | |
| 637 Dependants@NWorker[worker,direct nodes,nodes:out] | |
| 638 { | |
| 639 candidates <- Keys[Fold[["Collect Dests"]Set Input[0,worker], (), direct nodes]] | |
| 640 out <- Filter[candidates, [["Check Dependencies"]Set Input[0, worker]]Set Input[1, nodes]] | |
| 641 } | |
| 642 | |
| 643 _Dependency Groups@NWorker[worker,last,all,grouped:out] | |
| 644 { | |
| 645 current <- [worker]Dependants[last,all] | |
| 646 [current]First | |
| 647 { | |
| 648 out <- [worker]_Dependency Groups[current, [all]Concatenate[current], [grouped]Append[current]] | |
| 649 }{ | |
| 650 out <- grouped | |
| 651 } | |
| 652 } | |
| 653 Dependency Groups@NWorker[worker:out] | |
| 654 { | |
| 655 no deps <- [worker]No Dependencies | |
| 656 out <- [worker]_Dependency Groups[no deps, no deps, [()]Append[no deps]] | |
| 657 } | |
| 658 | |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
659 Const Name[val,node index,worker name:out] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
660 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
661 If[[Type Of[val]] = ["Type Instance"]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
662 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
663 //TODO: Support parametric types |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
664 datstring <- [val]Name >> |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
665 }{ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
666 If[[Type Of[val]] = ["Machine Integer"]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
667 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
668 If[[val]Signed? >>] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
669 { s <- "i" } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
670 { s <- "u" } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
671 datstring <- [[[val]Value >>]Append[s]]Append[[val]Size >>] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
672 }{ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
673 If[[Type Of[val]] = ["Worker Literal"]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
674 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
675 If[[[[val]Args >>]Length] > [0]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
676 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
677 datstring <- [[["Arg "]Append[node index]]Append[" "]]Append[worker name] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
678 }{ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
679 datstring <- [val]Name >> |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
680 } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
681 }{ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
682 If[[Type Of[val]] = ["List"]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
683 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
684 If[[[val]Length] > [0]] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
685 { |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
686 datstring <- [[["Arg "]Append[node index]]Append[" "]]Append[worker name] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
687 }{ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
688 datstring <- "Empty" |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
689 } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
690 }{ |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
691 datstring <- val |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
692 } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
693 } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
694 } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
695 } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
696 out <- [[Type Of[val]]Append["_"]]Append[datstring] |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
697 } |
|
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
698 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
699 Format Input@NWorker[worker,noderef:out] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
700 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
701 node <- [[worker]Nodes >>]Index[[noderef]Index >>] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
702 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
703 [("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
|
704 { |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
705 maybe addref <- [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
706 }{ |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
707 conditions <- [node]Conditions >> |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
708 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
709 If[[[node]Type >>] = ["input"]] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
710 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
711 input name <- [[worker]Inputs >>]Index[ [node]Data >> ] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
712 [conditions]For Backend |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
713 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
714 out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
715 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
716 out <- AddRef[input name] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
717 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
718 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
719 If[[[node]Type >>] = ["const"]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
720 { |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
721 [conditions]For Backend |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
722 { |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
723 out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
724 }{ |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
725 out <- Constant[Const Name[[node]Data >>, [noderef]Index >>, [worker]Name >>]] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
726 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
727 } |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
728 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
729 } |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
730 |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
731 Val[maybe addref] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
732 { |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
733 If[[Length[[[node]Wires From >>]Index[[noderef]IO Num >>]]] > [1]] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
734 { |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
735 out <- AddRef[maybe addref] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
736 }{ |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
737 out <- Val[maybe addref] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
738 } |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
739 } |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
740 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
741 |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
742 Collect Input@NWorker[worker,nodeinput:out] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
743 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
744 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
|
745 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
746 [inputchoices]First |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
747 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
748 first <- [inputchoices]Index[~] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
749 [inputchoices]Next[~] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
750 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
751 out <- _Fold[inputchoices, ~, first, "OrValue"] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
752 }{ |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
753 out <- Val[first] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
754 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
755 }{ |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
756 out <- "Missing" |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
757 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
758 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
759 |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
760 Collect Inputs@NWorker[worker,node:out] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
761 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
762 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
|
763 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
764 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
765 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
|
766 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
767 node <- [[worker]Nodes >>]Index[ [noderef]Index >> ] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
768 If[[[node]Outputs >>] > [1]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
769 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
770 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
|
771 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
772 out <- [set]Add Condition[[node]Conditions >>] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
773 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
774 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
775 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
776 Collect Condition@NWorker[worker,set,nodeinput:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
777 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
778 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
|
779 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
780 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
781 Collect Conditions@NWorker[worker,node:out] |
|
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 out <- Fold[["Collect Condition"]Set Input[0, worker], AndSet[], [node]Wires To>>] |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
784 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
785 |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
786 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
|
787 { |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
788 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
|
789 /*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
|
790 ]Move[Result[num], out var] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
791 */ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
792 out <- [func]Move[Result[num], out var] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
793 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
794 |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
795 Save Maybe Result[func,num,node index:out] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
796 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
797 out var <- [[["__result_"]Append[node index]]Append["_"]]Append[num] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
798 out <- [func]Move[Check Result[num], out var] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
799 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
800 |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
801 Max Used Output[node,cur:out] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
802 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
803 If[[cur] < [0]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
804 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
805 out <- cur |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
806 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
807 [[[node]Wires From >>]Index[cur]]Index[0] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
808 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
809 out <- cur |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
810 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
811 out <- Max Used Output[node, [cur]-[1]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
812 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
813 } |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
814 } |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
815 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
816 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
|
817 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
818 If[[[node]Type >>] = ["getfield"]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
819 { |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
820 with call <- [func]Get Field Call[[node]Data >>, [inputs]Index[0]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
821 save outs <- [node]Outputs >> |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
822 out <- Val[after save] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
823 }{ |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
824 If[[[node]Type >>] = ["setfield"]] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
825 { |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
826 with call <- [func]Set Field Call[[node]Data >>, [inputs]Index[0], [inputs]Index[1]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
827 save outs <- [node]Outputs >> |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
828 out <- Val[after save] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
829 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
830 [program]Method?[[[node]Data >>]Name >>] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
831 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
832 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
|
833 }{ |
|
69
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
66
diff
changeset
|
834 with call <- [func]Call[[[node]Data >>]Name >>, inputs] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
835 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
836 first unused <- [Max Used Output[node, [[node]Outputs >>]-[1]]]+[1] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
837 If[[first unused] > [[node]Min Outputs >>]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
838 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
839 save outs <- [node]Min Outputs >> |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
840 after maybe <- Fold[["Save Maybe Result"]Set Input[2, node index], after save, Range[save outs, first unused]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
841 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
842 save outs <- Val[first unused] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
843 after maybe <- Val[after save] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
844 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
845 If[[first unused] < [[node]Outputs >>]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
846 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
847 out <- [after maybe]Discard Outputs[first unused] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
848 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
849 out <- Val[after maybe] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
850 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
851 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
852 } |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
853 after save <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, save outs]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
854 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
855 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
856 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
|
857 { |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
858 node index <- [nodes]Index[current] |
|
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
859 node <- [[worker]Nodes >>]Index[node index] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
860 conditions <- [node]Conditions >> |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
861 [("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
|
862 { |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
863 inputs <- [worker]Collect Inputs[node] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
864 [conditions]For Backend |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
865 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
866 stream <- [func]Instruction Stream |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
867 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
|
868 }{ |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
869 stream <- Val[func] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
870 nfunc <- Val[nstream] |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
871 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
872 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
|
873 }{ |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
874 If[[[node]Type >>] = ["output"]] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
875 { |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
876 inputs <- [worker]Collect Inputs[node] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
877 [conditions]For Backend |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
878 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
879 stream <- [func]Instruction Stream |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
880 nfunc <- [func]Do If[~, nstream] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
881 }{ |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
882 stream <- Val[func] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
883 nfunc <- Val[nstream] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
884 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
885 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
|
886 }{ |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
887 If[[[node]Type >>] = ["const"]] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
888 { |
|
91
bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
Mike Pavone <pavone@retrodev.com>
parents:
89
diff
changeset
|
889 constname <- Const Name[[node]Data >>, node index, [worker]Name >>] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
890 withconst <- [func]Register Constant[constname, [node]Data >>] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
891 [conditions]For Backend |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
892 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
893 stream <- [[withconst]Instruction Stream |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
894 ]Move[Strip Addref[Constant[constname]], [[["__result_"]Append[node index]]Append["_"]]Append[0]] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
895 nfunc <- [withconst]Do If[~, stream] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
896 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
897 nfunc <- Val[withconst] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
898 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
899 }{ |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
900 [conditions]For Backend |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
901 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
902 input name <- [[worker]Inputs >>]Index[ [node]Data >> ] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
903 stream <- [[func]Instruction Stream |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
904 ]Move[input name, [[["__result_"]Append[node index]]Append["_"]]Append[0]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
905 nfunc <- [func]Do If[~, stream] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
906 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
907 nfunc <- Val[func] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
908 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
909 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
910 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
911 } |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
912 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
913 [nodes]Next[current] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
914 { |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
915 out,out worker <- [worker]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
|
916 }{ |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
917 out <- Val[nfunc] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
918 out worker <- Val[worker] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
919 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
920 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
921 |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
922 Save Node Conditions@NWorker[worker,node index:out] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
923 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
924 node <- [[worker]Nodes >>]Index[node index] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
925 conditions <- [worker]Collect Conditions[node] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
926 out <- [worker]Nodes <<[ [[worker]Nodes >>]Set[node index, [node]Conditions <<[conditions]] ] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
927 |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
928 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
929 |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
930 Save Group Conditions@NWorker[worker, groups,current:out] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
931 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
932 nodes <- [groups]Index[current] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
933 nworker <- Fold["Save Node Conditions", worker, nodes] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
934 |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
935 [groups]Next[current] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
936 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
937 out <- [nworker]Save Group Conditions[groups,~] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
938 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
939 out <- Val[nworker] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
940 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
941 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
942 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
943 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
|
944 { |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
945 nodes <- [groups]Index[current] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
946 [nodes]First |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
947 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
948 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
|
949 }{ |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
950 nfunc <- Val[func] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
951 nworker <- Val[worker] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
952 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
953 [groups]Next[current] |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
954 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
955 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
|
956 }{ |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
957 out <- Val[nfunc] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
958 out worker <- Val[nworker] |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
959 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
960 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
961 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
962 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
|
963 { |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
964 //__result_index_ionum |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
965 parts <- [name]Split["_"] |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
966 index <- <String@Whole Number[ [parts]Index[3] ] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
967 io num <- <String@Whole Number[ [parts]Index[4] ] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
968 node <- [[worker]Nodes >>]Index[index] |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
969 dests <- [[node]Wires From >>]Index[io num] {} |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
970 { |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
971 Print["oops"] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
972 { Pretty Print[node, ""] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
973 { Pretty Print[parts, ""]}} } |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
974 ,normal <- If[[[dests]Length] = [1]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
975 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
976 dest ionum <- [[dests]Index[0]]IO Num >> |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
977 If[[[[dests]Index[0]]IO Num >>]=[-1]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
978 { |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
979 normal <- Yes |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
980 }{ |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
981 dest index <- [[dests]Index[0]]Index >> |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
982 dest node <- [[worker]Nodes >>]Index[dest index] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
983 |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
984 [[dest node]Conditions >>]For Backend |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
985 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
986 out <- [func]Do If[AndCond[NotCond[~], name], [[func]Instruction Stream]Release[name]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
987 }{ |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
988 out <- func |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
989 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
990 } |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
991 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
992 |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
993 Val[normal] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
994 { |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
995 do if <- If[[[node]Outputs >>] > [1]] {} |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
996 { |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
997 do if <- [[node]Conditions >>]Empty? {} |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
998 { |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
999 out <- [func]Release[name] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1000 } |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1001 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1002 |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1003 Val[do if] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1004 { |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1005 stream <- [[func]Instruction Stream]Release[name] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1006 out <- [func]Do If[name, stream] |
|
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1007 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1008 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1009 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1010 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1011 Result Var[vars,io num,index:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1012 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1013 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
|
1014 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1015 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1016 Node Result Vars[vars,node,index:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1017 { |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1018 [("call","getfield","setfield")]Find[[node]Type >>] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1019 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1020 If[[[node]Type >>]=["call"]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1021 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1022 save outs <- [Max Used Output[node, [[node]Outputs >>]-[1]]]+[1] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1023 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1024 save outs <- [node]Outputs >> |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1025 } |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1026 out <- Fold[["Result Var"]Set Input[2, index], vars, Range[0, save outs]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1027 }{ |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1028 out <- vars |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1029 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1030 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1031 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1032 Result Vars@NWorker[worker:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1033 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1034 out <- Fold["Node Result Vars", (), [worker]Nodes >>] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1035 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1036 |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1037 _No Release[vars,node,index,worker:out] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1038 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1039 [("const","input")]Find[[node]Type >>] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1040 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1041 [[node]Conditions >>]For Backend |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1042 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1043 out <- Result Var[vars, 0, index] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1044 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1045 out <- vars |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1046 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1047 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1048 out <- vars |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1049 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1050 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1051 |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1052 No Release Results@NWorker[worker:out] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1053 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1054 out <- Fold[["_No Release"]Set Input[3, worker], (), [worker]Nodes >>] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1055 } |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1056 |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1057 Make Basic Type[type:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1058 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1059 out <- [Type Instance[[type]Name >>]]Params <<[ [type]Params >> ] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1060 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1061 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1062 FInputs[ifunc, input type, index, inputs:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1063 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1064 func <- [ifunc]Set Input Type[Make Basic Type[input type], index] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1065 name <- [inputs]Index[index] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1066 If[[[input type]Variant >>] = ["Naked"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1067 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1068 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1069 naked <- [" naked"]Append[name] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1070 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1071 out <- [[[func]Allocate Var[naked, input type] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1072 ]Unbox[name, naked] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1073 ]Release[name] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1074 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1075 If[[input type]Mutable? >>] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1076 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1077 name <- [inputs]Index[index] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1078 copied <- [func]Copy[name, name] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1079 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1080 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1081 copied <- Val[func] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1082 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1083 If[[[input type]Variant >>] = ["Raw Pointer"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1084 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1085 raw <- [" raw"]Append[name] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1086 If[[[input type]Name >>]=["Array"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1087 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1088 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1089 out <- [[copied]Allocate Var[raw, input type] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1090 ]Array Raw Pointer[name, raw] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1091 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1092 out <- [[copied]Allocate Var[raw, input type] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1093 ]Get Raw Pointer[name, raw] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1094 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1095 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1096 out <- Val[copied] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1097 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1098 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1099 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1100 |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1101 Release Raw Inputs[func,input type,index,inputs,outputs:out] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1102 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1103 If[[[input type]Variant >>] = ["Raw Pointer"]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1104 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1105 name <- [inputs]Index[index] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1106 If[[input type]Mutable? >>] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1107 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1108 [outputs]Find[[inputs]Index[index]] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1109 { |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1110 out <- func |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1111 }{ |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1112 out <- [func]Release[name] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1113 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1114 }{ |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1115 out <- [func]Release[name] |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1116 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1117 }{ |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1118 out <- func |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1119 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1120 } |
|
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1121 |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1122 FParams[input:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1123 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1124 iname <- [input]Index[0] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1125 type <- [input]Index[1] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1126 If[[[type]Variant >>] = ["Naked"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1127 { out <- [" naked"]Append[iname] } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1128 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1129 If[[[type]Variant >>] = ["Raw Pointer"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1130 { out <- [" raw"]Append[iname] } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1131 { out <- Val[iname] } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1132 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1133 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1134 _Return Param[outputs, inputs, input types, index:out,none] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1135 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1136 output <- [outputs]Index[index] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1137 [inputs]Find[output] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1138 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1139 If[[[input types]Index[~]]Mutable? >>] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1140 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1141 ,none <- [outputs]Next[index] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1142 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1143 out,none <- _Return Param[outputs, inputs, input types, ~] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1144 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1145 } { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1146 out <- index |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1147 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1148 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1149 out <- index |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1150 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1151 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1152 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1153 Return Param[outputs, inputs, input types:out,none] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1154 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1155 ,none <- [outputs]First |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1156 { out,none <- _Return Param[outputs, inputs, input types, ~] } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1157 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1158 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1159 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1160 Save Foreign Result[func, output, index, output types, inputs, input types:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1161 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1162 type <- [output types]Index[index] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1163 If[[[type]Variant >>] = ["Naked"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1164 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1165 out <- [func]Box[[" naked"]Append[output], output, type] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1166 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1167 [inputs]Find[output] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1168 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1169 If[[[input types]Index[~]]Mutable? >>] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1170 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1171 out <- [func]Move[output, Output[output]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1172 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1173 out <- func |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1174 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1175 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1176 out <- func |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1177 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1178 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1179 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1180 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1181 Compile Foreign Stub[worker,program,name:out] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1182 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1183 ifunc <- [[program]Create Function[name, [worker]Inputs >>, [worker]Outputs >>, "rhope"] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1184 ]Output Types <<[Map[[worker]Output Types >>, "Make Basic Type"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1185 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1186 rp num <- Return Param[[worker]Outputs >>, [worker]Inputs >>, [worker]Input Types >>] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1187 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1188 rbase <- [[worker]Outputs >>]Index[rp num] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1189 If[[[[[worker]Output Types >>]Index[rp num]]Variant >>] = ["Naked"]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1190 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1191 rparam <- [" naked"]Append[rbase] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1192 rfunc <- [ifunc]Allocate Var[rparam, [[worker]Output Types >>]Index[rp num]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1193 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1194 rparam <- Val[rbase] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1195 rfunc <- Val[ifunc] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1196 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1197 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1198 rparam <- "" |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1199 rfunc <- Val[ifunc] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1200 } |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1201 |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1202 Fold[["FInputs"]Set Input[3, [worker]Inputs >>], rfunc, [worker]Input Types >>] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1203 { [~]Call Foreign[name, [worker]Convention >>, Map[Zip[[worker]Inputs >>, [worker]Input Types >>], "FParams"], rparam] |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1204 { Fold[[["Release Raw Inputs"]Set Input[3, [worker]Inputs >>]]Set Input[4, [worker]Outputs >>], ~, [worker]Input Types >>] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1205 { Fold[[[["Save Foreign Result"]Set Input[3, [worker]Output Types >>]]Set Input[4, [worker]Inputs >>]]Set Input[5, [worker]Input Types >>], ~, [worker]Outputs >>] |
|
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
103
diff
changeset
|
1206 { out <- [program]Store Function[~] }}}} |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1207 } |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
1208 |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
1209 Compile Worker@NWorker[worker,program,name:out] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1210 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1211 If[[worker]Builtin? >>] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1212 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1213 out <- program |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1214 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1215 If[[[worker]Library >>] = [""]] |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1216 { |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1217 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
|
1218 |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1219 |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1220 |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1221 groups <- [worker]Dependency Groups |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1222 [groups]First |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1223 { |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1224 with conds <- [worker]Save Group Conditions[groups, ~] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1225 final func <- [with conds]Compile Group[program,func,groups, ~] |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1226 }{ |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1227 final func <- Val[func] |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1228 } |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1229 res vars <- [worker]Result Vars |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1230 init vars <- Concatenate[res vars, [with conds]No Release Results] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1231 |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1232 func <- Fold["Set Null", Fold["Set Null", Fold[["Allocate Var"]Set Input[2, "Any Type"], ifunc, init vars], init vars], [worker]Outputs >>] |
|
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
91
diff
changeset
|
1233 out <- [program]Store Function[Fold["Release", Fold[["Release Var"]Set Input[0, with conds], final func, res vars], [worker]Inputs >>]] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1234 }{ |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1235 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
|
1236 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1237 } |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
1238 } |
|
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
1239 |
| 2 | 1240 Test[:out] |
| 1241 { | |
|
34
df038cef648b
More work on supporting user defined types in the C backend
Mike Pavone <pavone@retrodev.com>
parents:
30
diff
changeset
|
1242 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
|
1243 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
|
1244 ,a <- [NWorker["rhope"] |
| 2 | 1245 ]Add Input["a", 0] { |
| 1246 ,b <- [~]Add Input["b", 1] { | |
| 1247 ,c <- [~]Add Input["c", 2] { | |
| 1248 ,outref <- [~]Add Output["out", 0] { | |
| 1249 ,call+ <- [~]Add Worker Call[ref+] { | |
| 1250 ,call* <- [~]Add Worker Call[ref*] { | |
| 1251 out <- [[[[[~]Add Wire[a,0,call+,0] | |
| 1252 ]Add Wire[b,0,call+,1] | |
| 1253 ]Add Wire[call+,0,call*,0] | |
| 1254 ]Add Wire[c,0,call*,1] | |
| 1255 ]Add Wire[call*,0,outref,0] | |
| 1256 }}}}}} | |
|
19
90c20dc3f4e5
Initial work on compiling dataflow graphs to a backend
Mike Pavone <pavone@retrodev.com>
parents:
2
diff
changeset
|
1257 } |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1258 |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
1259 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
|
1260 { |
|
21
e9272f7ebd26
Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents:
20
diff
changeset
|
1261 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
|
1262 } |
|
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1263 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1264 Blueprint NBlueprint |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1265 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1266 Fields |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1267 Methods |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1268 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1269 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1270 NBlueprint[:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1271 { |
|
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
|
1272 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
|
1273 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1274 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1275 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
|
1276 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1277 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
|
1278 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1279 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1280 Add Method@NBlueprint[bp,name:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1281 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1282 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
|
1283 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1284 |
|
43
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1285 Understands Method@NBlueprint[bp,name:out] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1286 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1287 out <- [[bp]Methods >>]Index[name] {} |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1288 { out <- No } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1289 } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1290 |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1291 Get Field Type@NBlueprint[bp,name:out,notfound] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1292 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1293 ,notfound <- [[bp]Fields >>]Index[name] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1294 { out <- [~]Index[1] } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1295 } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1296 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1297 _Compile Blueprint Fields[type,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1298 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1299 name <- [field]Index[0] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1300 ftype <- [field]Index[1] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1301 out <- [type]Add Field[name,ftype] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1302 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1303 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1304 _Compile Blueprint Methods[type,junk,name:out] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1305 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1306 If[[[name]=["Call"]] And [[[type]Name >>] = ["Worker"]]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1307 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1308 out <- type |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1309 }{ |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1310 out <- [type]Add Method[name] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1311 } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1312 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1313 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1314 Make Init[func,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1315 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1316 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
|
1317 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
|
1318 If[[variant] = ["Boxed"]] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1319 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1320 out <- [func]Set Field Null["obj", name] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1321 }{ |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1322 out <- func |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1323 } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1324 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1325 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1326 Make Copy[func,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1327 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1328 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
|
1329 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
|
1330 If[[variant] = ["Boxed"]] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1331 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1332 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
|
1333 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1334 stream <- [[got]Instruction Stream |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1335 ]AddRef No Dest[~] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1336 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
|
1337 } |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1338 }{ |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1339 out <- func |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1340 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1341 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1342 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1343 Make Cleanup[func,field:out] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1344 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1345 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
|
1346 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
|
1347 If[[variant] = ["Boxed"]] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1348 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1349 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
|
1350 { |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1351 stream <- [[got]Instruction Stream |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1352 ]Release[~] |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1353 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
|
1354 } |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1355 }{ |
|
789a146a48e1
Started adding support for naked values in user defined objects
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1356 out <- func |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1357 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1358 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1359 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1360 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
|
1361 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1362 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
|
1363 ]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
|
1364 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
|
1365 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1366 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1367 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
|
1368 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1369 //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
|
1370 name <- [field]Index[0] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1371 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
|
1372 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
|
1373 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
|
1374 ]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
|
1375 ]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
|
1376 ]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
|
1377 If[[[type]Variant >>] = ["Boxed"]] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1378 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1379 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
|
1380 }{ |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1381 getter <- [[start getter]Box[getref, "out", type]]Release["obj"] |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1382 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1383 |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1384 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
|
1385 ]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
|
1386 ]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
|
1387 ]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
|
1388 ]Copy["obj"] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1389 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1390 If[[[type]Variant >>] = ["Boxed"]] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1391 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1392 ,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
|
1393 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1394 stream <- [[~]Instruction Stream |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1395 ]Release[origref] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1396 ,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
|
1397 ]Write Field["obj", name] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1398 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1399 setter <- [[~]Move["newval", setref] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1400 ]Move["obj", "out"] |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1401 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1402 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1403 }{ |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1404 ,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
|
1405 { |
|
89
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1406 setter <- [[[~]Unbox["newval", setref] |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1407 ]Release["newval"] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1408 ]Move["obj", "out"] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1409 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1410 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1411 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1412 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
|
1413 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1414 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1415 |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1416 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
|
1417 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1418 //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
|
1419 init name <- [" init "]Append[name] |
|
103
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1420 [("Array","Boxed Array","Worker")]Find[name] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1421 { |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1422 [("internalarraynaked","internalarrayboxed","internalworker")]Index[~] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1423 { |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1424 copy name <- [~]Append["copy"] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1425 cleanup name <- [~]Append["cleanup"] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1426 } |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1427 }{ |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1428 copy name <- [" copy "]Append[name] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1429 cleanup name <- [" cleanup "]Append[name] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1430 } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1431 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
|
1432 ]Init <<[init name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1433 ]Copy <<[copy name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1434 ]Cleanup <<[cleanup name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1435 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1436 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
|
1437 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1438 |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1439 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
|
1440 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1441 init name <- [" init "]Append[name] |
|
103
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1442 [("Array","Boxed Array","Worker")]Find[name] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1443 { |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1444 after copyclean <- Val[backend] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1445 }{ |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1446 copy name <- [" copy "]Append[name] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1447 cleanup name <- [" cleanup "]Append[name] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1448 after copyclean <- [bp]Make Special[ |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1449 [bp]Make Special[backend, copy name, name, "Make Copy"], |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1450 cleanup name, name, "Make Cleanup"] |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1451 } |
|
7428aa5d6ade
Compiler compiled by compiler sort of working
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1452 out <- Fold[["Getters Setters"]Set Input[2, name], [bp]Make Special[after copyclean, init name, name, "Make Init"], [bp]Fields >>] |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1453 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1454 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1455 Blueprint NProgram |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1456 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1457 Blueprints |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1458 Workers |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1459 Worker Refs |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1460 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1461 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1462 NProgram[:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1463 { |
|
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
|
1464 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
|
1465 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1466 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1467 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
|
1468 { |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1469 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
|
1470 parts <- [name]Split["@"] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1471 [parts]Index[1] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1472 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1473 orig bp <- [[after bind]Blueprints >>]Index[~] {} |
|
49
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1474 { orig bp <- NBlueprint[] } |
|
3e20ed8959c4
Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents:
48
diff
changeset
|
1475 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
|
1476 }{ |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1477 out <- Val[after bind] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1478 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1479 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1480 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1481 Bind Blueprint@NProgram[prog,name,blueprint:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1482 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1483 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
|
1484 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1485 |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1486 _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
|
1487 { |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1488 out <- [blueprint]Compile Blueprint[backend, name] |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1489 } |
|
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1490 |
|
42
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1491 _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
|
1492 { |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1493 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
|
1494 } |
|
aabda74c7a88
Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents:
40
diff
changeset
|
1495 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1496 _Compile Program[backend, worker, name:out] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1497 { |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1498 out <- [worker]Compile Worker[backend, name] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1499 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1500 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1501 Compile Program@NProgram[prog, backend:out] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1502 { |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1503 backend with bps <- Generate Boolean Methods[Generate Number Methods[Fold["_Compile Program BP Special", Fold["_Compile Program BP", backend, [prog]Blueprints >>], [prog]Blueprints >>]]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1504 workers with infer <- SMap[[prog]Workers >>, ["Infer Types"]Set Input[1, prog]] |
|
48
a24eb366195c
Fixed some bugs introduced in previous commit and moved definition of integer methods out of runtime and into the compiler
Mike Pavone <pavone@retrodev.com>
parents:
47
diff
changeset
|
1505 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
|
1506 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1507 |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1508 Register Method@NProgram[prog, name, convention, inputs, outputs: out] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1509 { |
|
89
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1510 [[prog]Worker Refs >>]Index[name] |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1511 { |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1512 ref <- [[[[~]Inputs <<[ Max[[~]Inputs >>, inputs] ] |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1513 ]Min Inputs <<[ Min[[~]Min Inputs >>, inputs] ] |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1514 ]Outputs <<[ Max[[~]Outputs >>, outputs] ] |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1515 ]Min Outputs <<[ Min[[~]Min Outputs >>, outputs] ] |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1516 }{ |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1517 ref <- Worker Ref[name, convention, inputs, outputs, Yes] |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1518 } |
|
5a195ee08eac
Fix memory leak and bug that was preventing First@Dictionary from working properly
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1519 out <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, ref]] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1520 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1521 |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1522 Register Worker@NProgram[prog, name, convention, inputs, outputs: out] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1523 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1524 [[prog]Worker Refs >>]Index[name] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1525 { |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1526 ref <- [[[[~]Inputs <<[ Max[[~]Inputs >>, inputs] ] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1527 ]Min Inputs <<[ Min[[~]Min Inputs >>, inputs] ] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1528 ]Outputs <<[ Max[[~]Outputs >>, outputs] ] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1529 ]Min Outputs <<[ Min[[~]Min Outputs >>, outputs] ] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1530 }{ |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1531 ref <- Worker Ref[name, convention, inputs, outputs, No] |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1532 } |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1533 after reg <- [prog]Worker Refs <<[ |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1534 [ [prog]Worker Refs >> ]Set[name, ref] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1535 ] |
|
75
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1536 |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1537 parts <- [name]Split["@"] |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1538 [parts]Index[1] |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1539 { |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1540 out <- [after reg]Register Method@NProgram[[parts]Index[0], convention, inputs, outputs] |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1541 }{ |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1542 out <- Val[after reg] |
|
0083b2f7b3c7
Partially working implementation of List. Modified build scripts to allow use of other compilers. Fixed some bugs involving method implementations on different types returning different numbers of outputs. Added Fold to the 'builtins' in the comipler.
Mike Pavone <pavone@retrodev.com>
parents:
74
diff
changeset
|
1543 } |
|
20
b715532225c0
Differentiate between method and normal calls in dataflow graph compiler
Mike Pavone <pavone@retrodev.com>
parents:
19
diff
changeset
|
1544 } |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1545 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1546 Register Builtins@NProgram[prog:out] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1547 { |
|
87
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1548 registered <- [[[[[[[[prog]Register Worker["Print", "rhope", 1, 1] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1549 ]Register Worker["If@Boolean", "rhope", 1, 2] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1550 ]Register Worker["Build", "rhope", 1, 1] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1551 ]Register Worker["Blueprint Of", "rhope", 1, 1] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1552 ]Register Worker["Call@Worker", "rhope", 1, 2] //We're using 2 because we need to assume that the outputs are conditional |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1553 ]Register Worker["ID", "rhope", 1, 1] |
|
87
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1554 ]Register Worker["Blueprint From ID", "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
|
1555 ]Register Number Methods |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1556 |
|
87
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1557 out <- [[[[[[[registered]Bind Worker["If@Boolean", |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1558 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1559 ]Inputs <<[("condition")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1560 ]Input Types <<[ [()]Append[Type Instance["Boolean"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1561 ]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
|
1562 ]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
|
1563 ]Builtin? <<[Yes]] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1564 ]Bind Worker["Print", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1565 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1566 ]Inputs <<[("value")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1567 ]Input Types <<[ [()]Append[Type Instance["Any Type"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1568 ]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
|
1569 ]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
|
1570 ]Builtin? <<[Yes]] |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1571 ]Bind Worker["Build", |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1572 [[[[[NWorker["rhope"] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1573 ]Inputs <<[("type")] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1574 ]Input Types <<[ [()]Append[Type Instance["Blueprint"]] ] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1575 ]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
|
1576 ]Output Types <<[ [()]Append[Type Instance["Any Type"]] ] |
|
66
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1577 ]Builtin? <<[Yes]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1578 ]Bind Worker["Blueprint Of", |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1579 [[[[[NWorker["rhope"] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1580 ]Inputs <<[("object")] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1581 ]Input Types <<[ [()]Append[Type Instance["Any Type"]]] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1582 ]Outputs <<[("type")] |
|
d4b44ae2e34a
New variant of C backend works now
Mike Pavone <pavone@retrodev.com>
parents:
50
diff
changeset
|
1583 ]Output Types <<[ [()]Append[Type Instance["Blueprint"]]] |
|
82
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1584 ]Builtin? <<[Yes]] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1585 ]Bind Worker["Call@Worker", |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1586 [[[[[NWorker["rhope"] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1587 ]Inputs <<[("worker")] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1588 ]Input Types <<[ [()]Append[Type Instance["Worker"]] ] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1589 ]Outputs <<[("ret1","ret2")] |
|
2e2e55fc12f9
Fix bug with conditionally assigning a literal or input to a named pipe
Mike Pavone <pavone@retrodev.com>
parents:
75
diff
changeset
|
1590 ]Output Types <<[ [[()]Append[Type Instance["Any Type"]]]Append[Type Instance["Any Type"]] ] |
|
74
a844c623c7df
Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents:
73
diff
changeset
|
1591 ]Builtin? << [Yes]] |
|
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1592 ]Bind Worker["ID", |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1593 [[[[[NWorker["rhope"] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1594 ]Inputs <<[("bp")] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1595 ]Input Types <<[ [()]Append[Type Instance["Blueprint"]]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1596 ]Outputs <<[("id")] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1597 ]Output Types <<[ [()]Append[Type Instance["UInt32"]]] |
|
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
82
diff
changeset
|
1598 ]Builtin? << [Yes]] |
|
87
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1599 ]Bind Worker["Blueprint From ID", |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1600 [[[[[NWorker["rhope"] |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1601 ]Inputs <<[("id")] |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1602 ]Input Types <<[ [()]Append[Type Instance["UInt32"]]] |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1603 ]Outputs <<[("bp","none")] |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1604 ]Output Types <<[ [[()]Append[Type Instance["Blueprint"]]]Append[Type Instance["Any Type"]]] |
|
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1605 ]Builtin? << [Yes]] |
|
30
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1606 } |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1607 |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1608 Find Worker@NProgram[prog, name:out,notfound] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1609 { |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1610 out,notfound <- [[prog]Worker Refs >>]Index[name] |
|
914ad38f9b59
Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents:
21
diff
changeset
|
1611 } |
|
36
495dddadd058
User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents:
34
diff
changeset
|
1612 |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1613 Find Worker Def@NProgram[prog,name:out,notfound] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1614 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1615 out,notfound <- [[prog]Workers >>]Index[name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1616 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1617 |
|
43
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1618 Find Method@NProgram[prog, name, type:out,notfound] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1619 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1620 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1621 ,notfound <- If[[bp]Understands Method[name]] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1622 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1623 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
|
1624 } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1625 } |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1626 |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1627 Find Field@NProgram[prog, name, type:fieldtype,notfound] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1628 { |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1629 bp,notfound <- [[prog]Blueprints >>]Index[[type]Name >>] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1630 fieldtype,notfound <- [bp]Get Field Type[name] |
|
709df3e82bb4
Added methods to support type inference
Mike Pavone <pavone@retrodev.com>
parents:
42
diff
changeset
|
1631 } |
|
44
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1632 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1633 Implicit Conversion@NProgram[prog, fromtype, totype:func,notfound] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1634 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1635 notfound <- No |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1636 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1637 |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1638 Is Method?@NProgram[prog,name:is,is not] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1639 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1640 ,is not <- [[prog]Worker Refs>>]Index[name] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1641 { |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1642 is,is not <- If[[~]Is Method? >>] |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1643 } |
|
a7c79ac22efc
Beginning of basic type inference
Mike Pavone <pavone@retrodev.com>
parents:
43
diff
changeset
|
1644 } |