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