Mercurial > repos > rhope

annotate backendutils.rhope @ 74:a844c623c7df

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add support for Worker type
author Mike Pavone <pavone@retrodev.com>
date Thu, 01 Jul 2010 21:32:08 -0400
parents 3e20ed8959c4
children 0083b2f7b3c7
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
2 Escape Rhope Name NU[name:escaped]
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3 {
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: 42
diff changeset
4 escaped <- [[[[[[[[[[[[[[[name]Replace["_","UN_"]
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: 42
diff changeset
5 ]Replace["@","AT_"]
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: 42
diff changeset
6 ]Replace[" ","SP_"]
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: 42
diff changeset
7 ]Replace[":","CN_"]
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: 42
diff changeset
8 ]Replace["?","QN_"]
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: 42
diff changeset
9 ]Replace["+","PL_"]
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: 42
diff changeset
10 ]Replace["-","MN_"]
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: 42
diff changeset
11 ]Replace["*","TM_"]
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: 42
diff changeset
12 ]Replace["/","DV_"]
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: 42
diff changeset
13 ]Replace["<","LT_"]
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: 42
diff changeset
14 ]Replace[">","GT_"]
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: 42
diff changeset
15 ]Replace["(","LP_"]
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: 42
diff changeset
16 ]Replace[")","RP_"]
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: 42
diff changeset
17 ]Replace["!","NT_"]
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: 42
diff changeset
18 ]Replace["=","EQ_"]
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
19 }
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
20
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
21 Escape Rhope Name[name:escaped]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
22 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
23 escaped <- Escape Rhope Name NU[[name]Replace["_","__"]]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
24 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
25
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
26 Blueprint AddRef
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
27 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
28 Value
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
29 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
30
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
31 AddRef[value:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
32 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
33 out <- [Build["AddRef"]]Value <<[value]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
34 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
35
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
36 Make Op@AddRef[addref,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
37 {
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
38 //TODO: Make me work with other backends
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
39 out <- [["add_ref((object *)"]Append[ [[addref]Value >>]Make Op[func] ]]Append[")"]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
40 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
41
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
42 Strip Addref@AddRef[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
43 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
44 out <- [[op]Value >>]Strip Addref
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
45 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
46
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
47 Make Op@String[string,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
48 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
49 out <- [func]Resolve[string]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
50 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
51
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
52 Strip Addref@String[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
53 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
54 out <- op
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
55 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
56
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
57 Make Op@Whole Number[num,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
58 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
59 out <- num
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
60 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
61
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
62 Strip Addref@Whole Number[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
63 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
64 out <- op
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
65 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
66
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
67 Make Op@Real Number[num,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
68 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
69 out <- num
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
70 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
71
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
72 Strip Addref@Real Number[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
73 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
74 out <- op
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
75 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
76
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
77 Blueprint Output
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
78 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
79 Name
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
80 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
81
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
82 Output[name:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
83 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
84 out <- [Build["Output"]]Name <<[name]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
85 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
86
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
87 Make Op@Output[op,func:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
88 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
89 out <- [func]Resolve Output[[op]Name >>]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
90 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
91
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
92 Strip Addref@Output[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
93 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
94 out <- op
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
95 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
96
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
97 Blueprint Constant
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
98 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
99 Value
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
100 Need Addref
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
101 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
102
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
103 Constant[var:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
104 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
105 out <- [[Build["Constant"]]Value <<[var]]Need Addref <<[Yes]
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
106 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
107
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
108 Make Op@Constant[const,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
109 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
110 out <- [func]Lookup Constant[[const]Value >>, [const]Need Addref >>]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
111 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
112
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
113 Strip Addref@Constant[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
114 {
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
115 out <- [op]Need Addref <<[No]
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
116 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
117
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
118 Blueprint Result
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
119 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
120 Output Num
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
121 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
122
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
123 Result[num:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
124 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
125 out <- [Build["Result"]]Output Num <<[num]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
126 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
127
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
128 Make Op@Result[result,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
129 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
130 out <- [func]Result Reference[[result]Output Num>>]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
131 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
132
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
133 Strip Addref@Result[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
134 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
135 out <- op
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
136 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
137
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
138 Make Condition[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
139 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
140 If[[Type Of[op]]=["OrValue"]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
141 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
142 out <- OrCond[Make Condition[[op]Left >>], Make Condition[[op]Right >>]]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
143 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
144 out <- op
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
145 }
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
146 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
147
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
148 Blueprint OrValue
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
149 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
150 Left
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
151 Right
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
152 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
153
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
154 OrValue[left,right:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
155 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
156 out <- [[Build["OrValue"]]Left <<[left]]Right <<[right]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
157 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
158
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
159 Make Op@OrValue[orval,func:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
160 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
161 out <- [func]If Null Else[[orval]Left >>, [orval]Right >>]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
162 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
163
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
164 Strip Addref@OrValue[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
165 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
166 out <- [[op]Left <<[ [[op]Left >>]Strip Addref ]]Right <<[ [[op]Right >>]Strip Addref ]
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
167 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
168
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
169 Blueprint NotCond
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
170 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
171 Condition
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
172 }
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
173
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
174 NotCond[cond:out]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
175 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
176 out <- [Build["NotCond"]]Condition <<[[cond]Strip Addref]
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
177 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
178
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
179 Make Op@NotCond[cond,func:out]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
180 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
181 out <- ["!"]Append[[[cond]Condition >>]Make Op[func]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
182 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
183
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
184 Strip Addref@NotCond[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
185 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
186 out <- op
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
187 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
188
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
189 Blueprint OrCond
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
190 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
191 Condition1
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
192 Condition2
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
193 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
194
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
195 OrCond[cond1,cond2:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
196 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
197 out <- [[Build["OrCond"]]Condition1 <<[[cond1]Strip Addref]]Condition2 <<[[cond2]Strip Addref]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
198 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
199
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
200 Make Op@OrCond[cond,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
201 {
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
202 out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" || "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
203 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
204
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
205 Strip Addref@OrCond[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
206 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
207 out <- op
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
208 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
209
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
210 Blueprint AndCond
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
211 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
212 Condition1
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
213 Condition2
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
214 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
215
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
216 AndCond[cond1,cond2:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
217 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
218 out <- [[Build["AndCond"]]Condition1 <<[[cond1]Strip Addref]]Condition2 <<[[cond2]Strip Addref]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
219 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
220
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
221 Make Op@AndCond[cond,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
222 {
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
223 out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" && "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
224 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
225
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
226 Strip Addref@AndCond[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
227 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
228 out <- op
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
229 }
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
230
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
231 Blueprint Field Ref
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
232 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
233 Variable
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
234 Field
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
235 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
236
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
237 Field Ref[var,field:out]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
238 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
239 out <- [[Build["Field Ref"]]Variable <<[var]]Field <<[field]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
240 }
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
241
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
242 Make Op@Field Ref[ref,func:out]
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
243 {
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
244 out <- [func]Field Result[[ref]Variable >>,[ref]Field >>]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
245 }
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
246
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
247 Strip Addref@Field Ref[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
248 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
249 out <- op
35
3498713c3dc9 C backend portion of supporting user defined types is done, but untested. Parser/NWorker still need a fair bit of work
Mike Pavone <pavone@retrodev.com>
parents: 30
diff changeset
250 }
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
251
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
252 Blueprint Type Instance
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
253 {
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
254 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
255 Params
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
256 Variant
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
257 Mutable?
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
258 }
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
259
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
260 Type Instance[raw name:out]
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
261 {
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
262 If[[raw 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
263 {
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
264 name <- "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
265 }{
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
266 name <- raw 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
267 }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
268 out <- [[[[Build["Type Instance"]]Name <<[name]]Params <<[()]]Variant <<["Boxed"]]Mutable? <<[No]
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
269 }
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
270
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
271 Set Variant@Type Instance[type,variant:out,invalid]
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
272 {
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
273 [("Boxed","Naked","Pointer","Raw Pointer")]Find[variant]
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
274 {
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
275 out <- [type]Variant <<[variant]
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
276 }{
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
277 invalid <- 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
278 }
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
279 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
280
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
281 =@Type Instance[type,compare:out]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
282 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
283 If[[Type Of[compare]] = ["String"]]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
284 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
285 out <- [[type]Name >>] = [compare]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
286 }{
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
287 //TODO: Compare parameters
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
288 ,out <- If[[[type]Name >>] = [[compare]Name >>]]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
289 { out <- [[type]Variant >>] = [[compare]Variant >>] }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
290 }
74
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
291 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
292
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
293 Blueprint Worker Literal
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
294 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
295 Name
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
296 Args
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
297 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
298 Worker Literal[name:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
299 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
300 out <- [[Build["Worker Literal"]]Name <<[name]]Args <<[()]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
301 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
302
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
303 Set Input@Worker Literal[worker,argnum,val:out]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
304 {
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
305 out <- [worker]Args <<[ [[worker]Args >>]Set[argnum, val] ]
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
306 }
a844c623c7df Add support for Worker type
Mike Pavone <pavone@retrodev.com>
parents: 49
diff changeset
307