Mercurial > repos > rhope

annotate backendutils.rhope @ 42:aabda74c7a88

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fields can now be defined to have naked primitive types
author Mike Pavone <pavone@retrodev.com>
date Tue, 13 Oct 2009 00:07:34 -0400
parents 7f05bbe82f24
children a24eb366195c
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 {
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
4 escaped <- [[[[[[[[[[[[name]Replace["@","_AT_"]
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
5 ]Replace[" ","_SP_"]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 ]Replace[":","_CN_"]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 ]Replace["?","_QN_"]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 ]Replace["+","_PL_"]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 ]Replace["-","_MN_"]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 ]Replace["*","_TM_"]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11 ]Replace["/","_DV_"]
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12 ]Replace["<","_LT_"]
36
495dddadd058 User defined types work in the compiler now
Mike Pavone <pavone@retrodev.com>
parents: 35
diff changeset
13 ]Replace[">","_GT_"]
38
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
14 ]Replace["(","_LP_"]
7f05bbe82f24 Started work on adding Array support
Mike Pavone <pavone@retrodev.com>
parents: 37
diff changeset
15 ]Replace[")","_RP_"]
12
31f8182f3433 Finished fib test and did some small work on the c backend
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16 }
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
17
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
18 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
19 {
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
20 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
21 }
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
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
23 Blueprint AddRef
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
24 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
25 Value
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
26 }
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 AddRef[value:out]
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 out <- [Build["AddRef"]]Value <<[value]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
31 }
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 Make Op@AddRef[addref,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
34 {
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
35 //TODO: Make me work with other backends
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
36 out <- [["add_ref("]Append[ [[addref]Value >>]Make Op[func] ]]Append[")"]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
37 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
38
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
39 Make Op@String[string,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
40 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
41 out <- [func]Resolve[string]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
42 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
43
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
44 Make Op@Whole Number[num,func:out]
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 out <- num
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
47 }
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 Make Op@Real Number[num,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
50 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
51 out <- num
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
52 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
53
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
54 Blueprint Constant
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
55 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
56 Value
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
57 }
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 Constant[var:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
60 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
61 out <- [Build["Constant"]]Value <<[var]
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
62 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
63
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
64 Make Op@Constant[const,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
65 {
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
66 out <- [func]Lookup Constant[[const]Value >>]
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
67 }
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 Blueprint Result
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
70 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
71 Output Num
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
72 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
73
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
74 Result[num:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
75 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
76 out <- [Build["Result"]]Output Num <<[num]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
77 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
78
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
79 Make Op@Result[result,func:out]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
80 {
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
81 out <- [func]Result Reference[[result]Output Num>>]
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
82 }
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
83
21
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
84 Blueprint OrValue
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
85 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
86 Left
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
87 Right
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
88 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
89
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
90 OrValue[left,right:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
91 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
92 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
93 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
94
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
95 Make Op@OrValue[orval,func:out]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
96 {
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
97 out <- [func]If Null Else[[[func]Left >>]Make Op[func], [[func]Right >>]Make Op[func]]
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
98 }
e9272f7ebd26 Limited compilation from dataflow graph to C backend
Mike Pavone <pavone@retrodev.com>
parents: 18
diff changeset
99
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
100 Blueprint NotCond
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
101 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
102 Condition
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
103 }
13
23dd9c766699 C backend close to being useable
mpavone@
parents: 12
diff changeset
104
18
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
105 NotCond[cond:out]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
106 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
107 out <- [Build["NotCond"]]Condition <<[cond]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
108 }
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
109
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
110 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
111 {
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
112 out <- ["!"]Append[[[cond]Condition >>]Make Op[func]]
ea991f95ae1f C backend working well enough to generate Fib test
Mike Pavone <pavone@retrodev.com>
parents: 13
diff changeset
113 }
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
114
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
115 Blueprint OrCond
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
116 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
117 Condition1
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
118 Condition2
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
119 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
120
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
121 OrCond[cond1,cond2:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
122 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
123 out <- [[Build["OrCond"]]Condition1 <<[cond1]]Condition2 <<[cond2]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
124 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
125
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
126 Make Op@OrCond[cond,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
127 {
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
128 out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" || "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
129 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
130
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
131 Blueprint AndCond
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
132 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
133 Condition1
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
134 Condition2
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
135 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
136
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
137 AndCond[cond1,cond2:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
138 {
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
139 out <- [[Build["AndCond"]]Condition1 <<[cond1]]Condition2 <<[cond2]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
140 }
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
141
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
142 Make Op@AndCond[cond,func:out]
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
143 {
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
144 out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" && "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]]
30
914ad38f9b59 Compiler now works for some simple programs
Mike Pavone <pavone@retrodev.com>
parents: 21
diff changeset
145 }
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
146
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
147 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
148 {
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
149 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
150 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
151 }
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
152
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
153 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
154 {
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
155 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
156 }
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
157
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
158 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
159 {
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
160 out <- [func]Field Result[[ref]Variable >>,[ref]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
161 }
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
162
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
163 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
164 {
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
165 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
166 Params
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
167 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
168 }
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
169
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
170 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
171 {
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
172 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
173 {
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
174 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
175 }{
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
176 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
177 }
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
178 out <- [[[Build["Type Instance"]]Name <<[name]]Params <<[()]]Variant <<["Boxed"]
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
179 }
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
180
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
181 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
182 {
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
183 [("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
184 {
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
185 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
186 }{
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
187 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
188 }
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
189 }
42
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
190
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
191 =@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
192 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
193 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
194 {
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
195 out <- [[type]Name >>] = [compare]
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
196 }{
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
197 //TODO: Compare parameters
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
198 ,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
199 { 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
200 }
aabda74c7a88 Fields can now be defined to have naked primitive types
Mike Pavone <pavone@retrodev.com>
parents: 38
diff changeset
201 }