Mercurial > repos > rhope
comparison backendutils_c.rhope @ 92:e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Mon, 02 Aug 2010 00:58:55 -0400 |
parents | |
children | e09c2d1d6d5b |
comparison
equal
deleted
inserted
replaced
91:bcdc326b3d6e | 92:e73a93fb5de1 |
---|---|
1 | |
2 Escape Rhope Name[name:escaped] | |
3 { | |
4 escaped <- [name]Replace[ | |
5 ("_", "@", " ", ":", "?", "+", "-", "*", "/", "<", ">", "(", ")", "!", "=", "'", | |
6 "\"", "\t", ",", ".", "\n", "{", "}", "[", "]", "#", "\\", "\r", ";", "&", "|", "%", "^"), | |
7 ("UN_","AT_","SP_","CN_","QN_","PL_","MN_","TM_","DV_","LT_","GT_","LP_","RP_","NT_","EQ_","PR_", | |
8 "DP_","TB_","CM_","PD_","NL_","LC_","RC_", "LS_", "RS_", "HS_", "BS_", "CR_", "SC_", "AM_", "PI_", "PC_", "CT_")] | |
9 } | |
10 | |
11 Blueprint AddRef | |
12 { | |
13 Value | |
14 } | |
15 | |
16 AddRef[value:out] | |
17 { | |
18 out <- [Build[AddRef()]]Value <<[value] | |
19 } | |
20 | |
21 Make Op@AddRef[addref,func:out] | |
22 { | |
23 //TODO: Make me work with other backends | |
24 out <- [["add_ref((object *)"]Append[ [[addref]Value >>]Make Op[func] ]]Append[")"] | |
25 } | |
26 | |
27 Strip Addref@AddRef[op:out] | |
28 { | |
29 out <- [[op]Value >>]Strip Addref | |
30 } | |
31 | |
32 Make Op@String[string,func:out] | |
33 { | |
34 out <- [func]Resolve[string] | |
35 } | |
36 | |
37 Strip Addref@String[op:out] | |
38 { | |
39 out <- op | |
40 } | |
41 | |
42 Make Op@Whole Number[num,func:out] | |
43 { | |
44 out <- num | |
45 } | |
46 | |
47 Strip Addref@Whole Number[op:out] | |
48 { | |
49 out <- op | |
50 } | |
51 | |
52 Make Op@Real Number[num,func:out] | |
53 { | |
54 out <- num | |
55 } | |
56 | |
57 Strip Addref@Real Number[op:out] | |
58 { | |
59 out <- op | |
60 } | |
61 | |
62 Blueprint Output | |
63 { | |
64 Name | |
65 } | |
66 | |
67 Output[name:out] | |
68 { | |
69 out <- [Build[Output()]]Name <<[name] | |
70 } | |
71 | |
72 Make Op@Output[op,func:out] | |
73 { | |
74 out <- [func]Resolve Output[[op]Name >>] | |
75 } | |
76 | |
77 Strip Addref@Output[op:out] | |
78 { | |
79 out <- op | |
80 } | |
81 | |
82 Blueprint Constant | |
83 { | |
84 Value | |
85 Need Addref | |
86 } | |
87 | |
88 Constant[var:out] | |
89 { | |
90 out <- [[Build[Constant()]]Value <<[var]]Need Addref <<[Yes] | |
91 } | |
92 | |
93 Make Op@Constant[const,func:out] | |
94 { | |
95 out <- [func]Lookup Constant[[const]Value >>, [const]Need Addref >>] | |
96 } | |
97 | |
98 Strip Addref@Constant[op:out] | |
99 { | |
100 out <- [op]Need Addref <<[No] | |
101 } | |
102 | |
103 Blueprint Result | |
104 { | |
105 Output Num | |
106 } | |
107 | |
108 Result[num:out] | |
109 { | |
110 out <- [Build[Result()]]Output Num <<[num] | |
111 } | |
112 | |
113 Make Op@Result[result,func:out] | |
114 { | |
115 out <- [func]Result Reference[[result]Output Num>>] | |
116 } | |
117 | |
118 Strip Addref@Result[op:out] | |
119 { | |
120 out <- op | |
121 } | |
122 | |
123 Blueprint Check Result | |
124 { | |
125 Output Num | |
126 } | |
127 | |
128 Check Result[num:out] | |
129 { | |
130 out <- [Build[Check Result()]]Output Num <<[num] | |
131 } | |
132 | |
133 Make Op@Check Result[result,func:out] | |
134 { | |
135 out <- [func]Checked Result Reference[[result]Output Num>>] | |
136 } | |
137 | |
138 Strip Addref@Check Result[op:out] | |
139 { | |
140 out <- op | |
141 } | |
142 | |
143 Make Condition[op:out] | |
144 { | |
145 If[[Blueprint Of[op]]=[OrValue()]] | |
146 { | |
147 out <- OrCond[Make Condition[[op]Left >>], Make Condition[[op]Right >>]] | |
148 }{ | |
149 out <- op | |
150 } | |
151 } | |
152 | |
153 Blueprint OrValue | |
154 { | |
155 Left | |
156 Right | |
157 } | |
158 | |
159 OrValue[left,right:out] | |
160 { | |
161 out <- [[Build[OrValue()]]Left <<[left]]Right <<[right] | |
162 } | |
163 | |
164 Make Op@OrValue[orval,func:out] | |
165 { | |
166 out <- [func]If Null Else[[orval]Left >>, [orval]Right >>] | |
167 } | |
168 | |
169 Strip Addref@OrValue[op:out] | |
170 { | |
171 out <- [[op]Left <<[ [[op]Left >>]Strip Addref ]]Right <<[ [[op]Right >>]Strip Addref ] | |
172 } | |
173 | |
174 Blueprint NotCond | |
175 { | |
176 Condition | |
177 } | |
178 | |
179 NotCond[cond:out] | |
180 { | |
181 out <- [Build[NotCond()]]Condition <<[[cond]Strip Addref] | |
182 } | |
183 | |
184 Make Op@NotCond[cond,func:out] | |
185 { | |
186 out <- ["!"]Append[[[cond]Condition >>]Make Op[func]] | |
187 } | |
188 | |
189 Strip Addref@NotCond[op:out] | |
190 { | |
191 out <- op | |
192 } | |
193 | |
194 Blueprint OrCond | |
195 { | |
196 Condition1 | |
197 Condition2 | |
198 } | |
199 | |
200 OrCond[cond1,cond2:out] | |
201 { | |
202 out <- [[Build[OrCond()]]Condition1 <<[[cond1]Strip Addref]]Condition2 <<[[cond2]Strip Addref] | |
203 } | |
204 | |
205 Make Op@OrCond[cond,func:out] | |
206 { | |
207 out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" || "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]] | |
208 } | |
209 | |
210 Strip Addref@OrCond[op:out] | |
211 { | |
212 out <- op | |
213 } | |
214 | |
215 Blueprint AndCond | |
216 { | |
217 Condition1 | |
218 Condition2 | |
219 } | |
220 | |
221 AndCond[cond1,cond2:out] | |
222 { | |
223 out <- [[Build[AndCond()]]Condition1 <<[[cond1]Strip Addref]]Condition2 <<[[cond2]Strip Addref] | |
224 } | |
225 | |
226 Make Op@AndCond[cond,func:out] | |
227 { | |
228 out <- ["("]Append[[[ [[cond]Condition1 >>]Make Op[func] ]Append[" && "]]Append[[ [[cond]Condition2 >>]Make Op[func] ]Append[")"]]] | |
229 } | |
230 | |
231 Strip Addref@AndCond[op:out] | |
232 { | |
233 out <- op | |
234 } | |
235 | |
236 Blueprint Field Ref | |
237 { | |
238 Variable | |
239 Field | |
240 } | |
241 | |
242 Field Ref[var,field:out] | |
243 { | |
244 out <- [[Build[Field Ref()]]Variable <<[var]]Field <<[field] | |
245 } | |
246 | |
247 Make Op@Field Ref[ref,func:out] | |
248 { | |
249 out <- [func]Field Result[[ref]Variable >>,[ref]Field >>] | |
250 } | |
251 | |
252 Strip Addref@Field Ref[op:out] | |
253 { | |
254 out <- op | |
255 } | |
256 | |
257 Blueprint Type Instance | |
258 { | |
259 Name | |
260 Params | |
261 Variant | |
262 Mutable? | |
263 } | |
264 | |
265 Type Instance[raw name:out] | |
266 { | |
267 If[[raw name]=[""]] | |
268 { | |
269 name <- "Any Type" | |
270 }{ | |
271 name <- raw name | |
272 } | |
273 out <- [[[[Build[Type Instance()]]Name <<[name]]Params <<[()]]Variant <<["Boxed"]]Mutable? <<[No] | |
274 } | |
275 | |
276 Set Variant@Type Instance[type,variant:out,invalid] | |
277 { | |
278 [("Boxed","Naked","Pointer","Raw Pointer")]Find[=[variant,?]] | |
279 { | |
280 out <- [type]Variant <<[variant] | |
281 }{ | |
282 invalid <- type | |
283 } | |
284 } | |
285 | |
286 =@Type Instance[type,compare:out] | |
287 { | |
288 If[[Blueprint Of[compare]] = [Type Instance()]] | |
289 { | |
290 //TODO: Compare parameters | |
291 ,out <- If[[[type]Name >>] = [[compare]Name >>]] | |
292 { out <- [[type]Variant >>] = [[compare]Variant >>] } | |
293 }{ | |
294 out <- [[type]Name >>] = [compare] | |
295 } | |
296 } | |
297 | |
298 String@Type Instance[type:out] | |
299 { | |
300 typestr <- [[[[type]Name >> | |
301 ]Append["("] | |
302 ]Append[ [[type]Params >>]Join[", "] ] | |
303 ]Append[")"] | |
304 If[[type]Mutable? >>] | |
305 { | |
306 out <- [[ [["("]Append[typestr]]Append[", "] ]Append[[type]Variant >>]]Append[", Mutable)"] | |
307 }{ | |
308 If[[[type]Variant >>] = ["Boxed"]] | |
309 { | |
310 out <- Val[typestr] | |
311 }{ | |
312 out <- [[ [["("]Append[typestr]]Append[", "] ]Append[[type]Variant >>]]Append[", Mutable)"] | |
313 } | |
314 } | |
315 } | |
316 | |
317 Blueprint Worker Literal | |
318 { | |
319 Name | |
320 Args | |
321 } | |
322 | |
323 Worker Literal[name:out] | |
324 { | |
325 out <- [[Build[Worker Literal()]]Name <<[name]]Args <<[()] | |
326 } | |
327 | |
328 Set Input@Worker Literal[worker,argnum,val:out] | |
329 { | |
330 out <- [worker]Args <<[ [[worker]Args >>]Set[argnum, val] ] | |
331 } | |
332 |