Mercurial > repos > rhope

annotate backendutils.rhope @ 69:d0ce696786cc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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.
author Mike Pavone <pavone@retrodev.com>
date Wed, 16 Jun 2010 04:36:08 +0000
parents 3e20ed8959c4
children a844c623c7df
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 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
99 Value
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
100 }
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 Constant[var:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
103 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
104 out <- [Build["Constant"]]Value <<[var]
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
105 }
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 Make Op@Constant[const,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
108 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
109 out <- [func]Lookup Constant[[const]Value >>]
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
110 }
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 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
113 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
114 out <- op
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
115 }
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 Blueprint Result
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
118 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
119 Output Num
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
120 }
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 Result[num:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
123 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
124 out <- [Build["Result"]]Output Num <<[num]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
125 }
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 Make Op@Result[result,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
128 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
129 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
130 }
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 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
133 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
134 out <- op
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
135 }
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 Make Condition[op:out]
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
138 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
139 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
140 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
141 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
142 }{
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
143 out <- op
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
144 }
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
145 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
146
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
147 Blueprint OrValue
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
148 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
149 Left
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
150 Right
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
151 }
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 OrValue[left,right:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
154 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
155 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
156 }
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 Make Op@OrValue[orval,func:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
159 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
160 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
161 }
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 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
164 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
165 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
166 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
167
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
168 Blueprint NotCond
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
169 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
170 Condition
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
171 }
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
172
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
173 NotCond[cond:out]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
174 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
175 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
176 }
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 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
179 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
180 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
181 }
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 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
184 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
185 out <- op
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
186 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
187
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
188 Blueprint OrCond
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
189 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
190 Condition1
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
191 Condition2
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
192 }
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 OrCond[cond1,cond2:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
195 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
196 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
197 }
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 Make Op@OrCond[cond,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
200 {
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
201 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
202 }
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 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
205 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
206 out <- op
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
207 }
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 Blueprint AndCond
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
210 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
211 Condition1
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
212 Condition2
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
213 }
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 AndCond[cond1,cond2:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
216 {
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
217 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
218 }
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 Make Op@AndCond[cond,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
221 {
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
222 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
223 }
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 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
226 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
227 out <- op
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
228 }
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
229
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 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
231 {
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 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
233 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
234 }
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 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
237 {
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 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
239 }
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 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
242 {
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 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
244 }
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 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
247 {
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
248 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
249 }
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
250
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 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
252 {
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 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
254 Params
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
255 Variant
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
256 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
257 }
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 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
260 {
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 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
262 {
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 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
264 }{
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 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
266 }
49
3e20ed8959c4 Added initial FFI implementation, Array type and 64-bit integers
Mike Pavone <pavone@retrodev.com>
parents: 48
diff changeset
267 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
268 }
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
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
270 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
271 {
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 [("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
273 {
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 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
275 }{
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 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
277 }
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 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
279
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
280 =@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
281 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
282 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
283 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
284 out <- [[type]Name >>] = [compare]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
285 }{
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
286 //TODO: Compare parameters
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
287 ,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
288 { 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
289 }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
290 }