Mercurial > repos > rhope
comparison cbackend_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 | 5a08705f7610 |
comparison
equal
deleted
inserted
replaced
91:bcdc326b3d6e | 92:e73a93fb5de1 |
---|---|
1 Import backendutils_c.rhope | |
2 | |
3 Blueprint C Method Registry | |
4 { | |
5 Lookup | |
6 Next ID | |
7 } | |
8 | |
9 C Method Registry[:out] | |
10 { | |
11 builtins <- [[[[[[[[[[[[[Dictionary[] | |
12 ]Set["+", "METHOD_ADD"] | |
13 ]Set["-", "METHOD_SUB"] | |
14 ]Set["/", "METHOD_DIV"] | |
15 ]Set["*", "METHOD_MUL"] | |
16 ]Set["LShift", "METHOD_LSHIFT"] | |
17 ]Set["RShift", "METHOD_RSHIFT"] | |
18 ]Set["=", "METHOD_EQUALS"] | |
19 ]Set[">", "METHOD_GREATER"] | |
20 ]Set["<", "METHOD_LESS"] | |
21 ]Set["If", "METHOD_IF"] | |
22 ]Set["Set Missing Field", "METHOD_SETFIELDMISSING"] | |
23 ]Set["Get Missing Field", "METHOD_GETFIELDMISSING"] | |
24 ]Set["Missing Method", "METHOD_MISSING"] | |
25 out <- [[Build[C Method Registry()]]Lookup <<[builtins]]Next ID<<[0] | |
26 | |
27 } | |
28 | |
29 Register Method@C Method Registry[reg,method:out] | |
30 { | |
31 [[reg]Lookup >>]Index[method] | |
32 { | |
33 out <- reg | |
34 }{ | |
35 method ID <- [reg]Next ID>> | |
36 new lookup <- [[reg]Lookup >>]Set[method, ["METHOD_FIRST_USER+"]Append[String[method ID]]] | |
37 out <- [[reg]Lookup <<[new lookup]]Next ID <<[[method ID]+[1]] | |
38 } | |
39 } | |
40 | |
41 Method ID@C Method Registry[reg,method:out,notfound] | |
42 { | |
43 out,notfound <- [[reg]Lookup >>]Index[method] | |
44 } | |
45 | |
46 Blueprint C Field Registry | |
47 { | |
48 Lookup | |
49 Next ID | |
50 } | |
51 | |
52 C Field Registry[:out] | |
53 { | |
54 out <- [[Build[C Field Registry()]]Lookup <<[Dictionary[]]]Next ID<<[1] | |
55 | |
56 } | |
57 | |
58 Register Field@C Field Registry[reg,field:out] | |
59 { | |
60 [[reg]Lookup >>]Index[field] | |
61 { | |
62 out <- reg | |
63 }{ | |
64 field ID <- [reg]Next ID>> | |
65 new lookup <- [[reg]Lookup >>]Set[field, field ID] | |
66 out <- [[reg]Lookup <<[new lookup]]Next ID <<[[field ID]+[1]] | |
67 } | |
68 } | |
69 | |
70 Field ID@C Field Registry[reg,field:out,notfound] | |
71 { | |
72 out,notfound <- [[reg]Lookup >>]Index[field] | |
73 } | |
74 | |
75 Blueprint C Type | |
76 { | |
77 Name | |
78 Fields | |
79 Methods | |
80 Init | |
81 Copy | |
82 Cleanup | |
83 | |
84 } | |
85 | |
86 C Type[name:out] | |
87 { | |
88 out <- [[[[[[Build[C Type()]]Name <<[name]]Fields <<[()]]Methods <<[()]]Init <<["NULL"]]Copy <<["NULL"]]Cleanup <<["NULL"] | |
89 } | |
90 | |
91 Add Field@C Type[ctype,name,type:out] | |
92 { | |
93 out <- [ctype]Fields <<[ [[ctype]Fields >>]Append[ [[()]Append[name]]Append[type] ] ] | |
94 } | |
95 | |
96 Add Method@C Type[ctype,name:out] | |
97 { | |
98 out <- [ctype]Methods <<[ [[ctype]Methods >>]Append[name] ] | |
99 } | |
100 | |
101 Register Methods@C Type[ctype,method reg:out] | |
102 { | |
103 out <- Fold[Register Method[?], method reg, [ctype]Methods >>] | |
104 } | |
105 | |
106 _Register Field C[reg,field:out] | |
107 { | |
108 name <- [field]Index[0] | |
109 out <- [reg]Register Field[name] | |
110 } | |
111 | |
112 Register Fields@C Type[ctype,field reg:out] | |
113 { | |
114 out <- Fold[_Register Field C[?], field reg, [ctype]Fields >>] | |
115 } | |
116 | |
117 Rhope Type to C[type:out,array] | |
118 { | |
119 If[[Blueprint Of[type]]=[Type Instance()]] | |
120 { | |
121 variant <- [type]Variant >> | |
122 If[[[type]Name >>] = ["Array"]] | |
123 { | |
124 [("Naked","Raw Pointer")]Find[=[variant,?]] | |
125 { | |
126 /* | |
127 //Below code assumes that paramaterized types are implemented | |
128 pre param <- [[type]Params >>]Index[0] {} | |
129 { pre param <- Type Instance["Any Type"] } | |
130 [[type]Params >>]Index[1] | |
131 { param,param <- [pre param]Set Variant[~] } | |
132 { param <- Val[pre param] } | |
133 child type <- Rhope Type to C[param] | |
134 If[[variant] = ["Naked"]] | |
135 { | |
136 out <- Val[child type] | |
137 array <- "[1]" | |
138 }{ | |
139 out <- [child type]Append[" *"] | |
140 array <- "" | |
141 } */ | |
142 out <- "void *" | |
143 array <- "" | |
144 }{ | |
145 typename <- "Array" | |
146 } | |
147 primitive <- No | |
148 }{ | |
149 ,regulartype <- [("Naked","Raw Pointer")]Find[=[variant,?]] | |
150 { | |
151 [("Int64","Int32","Int16","Int8")]Find[=[[type]Name >>,?]] | |
152 { | |
153 primitive <- Yes | |
154 [[type]Name >>]Slice[3] {} | |
155 { typename <- [["int"]Append[~]]Append["_t"] } | |
156 }{ | |
157 ,regulartype <- [("UInt64","UInt32","UInt16","UInt8")]Find[=[[type]Name >>,?]] | |
158 { | |
159 primitive <- Yes | |
160 [[type]Name >>]Slice[4] {} | |
161 { typename <- [["uint"]Append[~]]Append["_t"] } | |
162 } | |
163 } | |
164 } | |
165 | |
166 Val[regulartype] | |
167 { | |
168 typename <- [type]Name >> | |
169 primitive <- No | |
170 } | |
171 } | |
172 }{ | |
173 typename <- type | |
174 param <- "Any Type" | |
175 variant <- "boxed" | |
176 primitive <- No | |
177 } | |
178 | |
179 Val[typename] | |
180 { array <- "" } | |
181 If[[typename] = ["Any Type"]] | |
182 { | |
183 out <- "struct object *" | |
184 }{ | |
185 [("Naked","Raw Pointer")]Find[=[variant,?]] | |
186 { | |
187 If[primitive] | |
188 { | |
189 prefix <- "" | |
190 }{ | |
191 prefix <- "nt_" | |
192 } | |
193 }{ | |
194 prefix <- "t_" | |
195 } | |
196 | |
197 If[[variant]=["Naked"]] | |
198 { | |
199 postfix <- "" | |
200 }{ | |
201 postfix <- " *" | |
202 } | |
203 } | |
204 If[primitive] | |
205 { | |
206 escaped <- Val[typename] | |
207 }{ | |
208 escaped <- Escape Rhope Name[typename] | |
209 } | |
210 out <- [[prefix]Append[escaped]]Append[postfix] | |
211 } | |
212 | |
213 _Type Def C Type[text,field:out] | |
214 { | |
215 name <- [field]Index[0] | |
216 ,postfix <- Rhope Type to C[[field]Index[1]] | |
217 { type <- ["\n\t"]Append[~] } | |
218 | |
219 out <- [[[[text]Append[type]]Append[" "]]Append[[Escape Rhope Name[name]]Append[postfix]]]Append[";"] | |
220 } | |
221 | |
222 Type Def@C Type[ctype:out] | |
223 { | |
224 If[[[[ctype]Fields >>]Length] = [1]] | |
225 { | |
226 out <- [[[[_Type Def C Type["typedef struct {\n\tobject _SP_header;\n\t", [[ctype]Fields >>]Index[0]]]Append["\n} t_"]]Append[Escape Rhope Name[[ctype]Name >>]]]Append[";"] | |
227 ]Append[ | |
228 [[[["typedef " | |
229 ]Append[Rhope Type to C[ [[[ctype]Fields >>]Index[0]]Index[1] ]] | |
230 ]Append[" nt_"] | |
231 ]Append[Escape Rhope Name[[ctype]Name >>]] | |
232 ]Append[";"] ] | |
233 }{ | |
234 //HACK!!! | |
235 If[[[ctype]Name >>]=["Blueprint"]] | |
236 { | |
237 out <- "" | |
238 }{ | |
239 [("Array","Worker")]Find[=[[ctype]Name >>,?]] | |
240 { oend <- "\nMObject(" } | |
241 { oend <- "\nObject(" } | |
242 out <- [Fold[_Type Def C Type[?], "OBegin", [ctype]Fields >>]]Append[ [[oend]Append[Escape Rhope Name[[ctype]Name >>]]]Append[")"] ] | |
243 } | |
244 } | |
245 } | |
246 | |
247 _Type Init C[type name,method reg,text,method:out] | |
248 { | |
249 out <- [[text]Append[[["\n\tadd_method(bp, "]Append[ [method reg]Method ID[method] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[method]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"] | |
250 } | |
251 | |
252 _Type Init C Field[type name,field reg,text,field:out] | |
253 { | |
254 fname <- [field]Index[0] | |
255 out <- [[[[text]Append[[["\n\tadd_getter(bp, "]Append[ String[[field reg]Field ID[fname]] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" >>"]]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"] | |
256 ]Append[[["\n\tadd_setter(bp, "]Append[ String[[field reg]Field ID[fname]] ]]Append[ [[", MethodName("]Append[Escape Rhope Name[[fname]Append[" <<"]]]]Append[[","]Append[Escape Rhope Name[type name]]]]]]Append["));"] | |
257 } | |
258 | |
259 Type Init@C Type[ctype,id,method reg,field reg:out] | |
260 { | |
261 [("Array","Worker")]Find[=[[ctype]Name >>, ?]] | |
262 { size <- "-1" } | |
263 { | |
264 [("Int64","Int32","Int16","Int8")]Find[=[[ctype]Name >>, ?]] | |
265 { | |
266 [[ctype]Name >>]Slice[3] {} | |
267 { typename <- [["int"]Append[~]]Append["_t"] } | |
268 }{ | |
269 [("UInt64","UInt32","UInt16","UInt8")]Find[=[[ctype]Name >>, ?]] | |
270 { | |
271 [[ctype]Name >>]Slice[4] {} | |
272 { typename <- [["uint"]Append[~]]Append["_t"] } | |
273 }{ | |
274 If[[[ctype]Name >>]=["Blueprint"]] | |
275 { typename <- "blueprint *" } | |
276 { | |
277 If[[[ctype]Name >>]=["Boolean"]] | |
278 { typename <- "int32_t" } | |
279 { typename <- ["nt_"]Append[Escape Rhope Name[[ctype]Name >>]] } | |
280 } | |
281 } | |
282 } | |
283 size <- [["sizeof("]Append[typename]]Append[")"] | |
284 } | |
285 start <- [["\tbp = register_type_byid(" | |
286 ]Append[id] | |
287 ]Append[ | |
288 [[", "]Append[size] | |
289 ]Append[ | |
290 [", (special_func)"]Append[ | |
291 [ | |
292 [[[[Escape Rhope Name[[ctype]Init >>] | |
293 ]Append[", (special_func)"] | |
294 ]Append[Escape Rhope Name[[ctype]Copy >> ]] | |
295 ]Append[", (special_func)"] | |
296 ]Append[Escape Rhope Name[[ctype]Cleanup >>]] | |
297 ]Append[");"]]] ] | |
298 out <- Val[start]//Fold[[["_Type Init C Field"]Set Input[0, [ctype]Name >>]]Set Input[1, field reg], Fold[[["_Type Init C"]Set Input[0, [ctype]Name >>]]Set Input[1, method reg], start, [ctype]Methods >>], [ctype]Fields >>] | |
299 } | |
300 | |
301 Blueprint C Type Registry | |
302 { | |
303 Lookup | |
304 Definitions | |
305 Next ID | |
306 } | |
307 | |
308 C Type Registry[:out] | |
309 { | |
310 out <- [[[Build[C Type Registry()]]Lookup << [ | |
311 [[[[[[[[[[[[[[[[[[Dictionary[] | |
312 ]Set["UInt8", "TYPE_UINT8"] //1 | |
313 ]Set["UInt16", "TYPE_UINT16"] //2 | |
314 ]Set["UInt32", "TYPE_UINT32"] //3 | |
315 ]Set["UInt64", "TYPE_UINT64"] //4 | |
316 ]Set["Int8", "TYPE_INT8"] //5 | |
317 ]Set["Int16", "TYPE_INT16"] //6 | |
318 ]Set["Int32", "TYPE_INT32"] //7 | |
319 ]Set["Int64", "TYPE_INT64"] //8 | |
320 ]Set["Boolean", "TYPE_BOOLEAN"] //9 | |
321 ]Set["Float32", "TYPE_FLOAT32"] //10 | |
322 ]Set["Float64", "TYPE_FLOAT64"] //11 | |
323 ]Set["Real Number", "TYPE_FLOAT64"] //12 | |
324 ]Set["Blueprint", "TYPE_BLUEPRINT"] //13 | |
325 ]Set["Array", "TYPE_ARRAY"] //14 | |
326 ]Set["Worker", "TYPE_WORKER"] //15 | |
327 ]Set["Method Missing Exception", "TYPE_METHODMISSINGEXCEPTION"] //16 | |
328 ]Set["Field Missing Exception", "TYPE_FIELDMISSINGEXCEPTION"] //17 | |
329 ]Set["Wrong Type Exception", "TYPE_WRONGTYPEEXCEPTION"]] //18 | |
330 ]Definitions << [Dictionary[]] | |
331 ]Next ID <<[0] | |
332 } | |
333 | |
334 _Type Defs C[text,def:out] | |
335 { | |
336 out <- [[text]Append[[def]Type Def]]Append["\n\n"] | |
337 } | |
338 | |
339 Type Defs@C Type Registry[reg:out] | |
340 { | |
341 out <- Fold[_Type Defs C[?], "", [reg]Definitions >>] | |
342 } | |
343 | |
344 _Type Inits C[reg,method reg,field reg,text,def,name:out] | |
345 { | |
346 out <- [[text]Append[ [def]Type Init[[reg]Type ID[name], method reg, field reg] ]]Append["\n\n"] | |
347 } | |
348 | |
349 Type Inits@C Type Registry[reg,method reg,field reg:out] | |
350 { | |
351 out <- Fold[_Type Inits C[reg, method reg, field reg, ?], "", [reg]Definitions >>] | |
352 } | |
353 | |
354 Register Type@C Type Registry[reg,def:out] | |
355 { | |
356 name <- [def]Name >> | |
357 [[reg]Lookup >>]Index[name] | |
358 { | |
359 [[reg]Definitions >>]Index[name] | |
360 { | |
361 out <- reg | |
362 }{ | |
363 out <- [reg]Definitions <<[[[reg]Definitions >>]Set[name, def]] | |
364 } | |
365 }{ | |
366 out <- [[[reg]Lookup <<[ [[reg]Lookup >>]Set[name, ["TYPE_FIRST_USER+"]Append[String[[reg]Next ID >>]]] ] | |
367 ]Definitions <<[ [[reg]Definitions >>]Set[name, def] ] | |
368 ]Next ID <<[ [[reg]Next ID >>]+[1] ] | |
369 } | |
370 } | |
371 | |
372 Type ID@C Type Registry[reg,name:out,notfound] | |
373 { | |
374 out <- [[reg]Lookup >>]Index[name] {} | |
375 { | |
376 ,notfound <- If[[name]=["Any Type"]] | |
377 { out <- "0" } | |
378 } | |
379 } | |
380 | |
381 Simple Type?@C Type Registry[reg,name:yep,nope,notfound] | |
382 { | |
383 ,notfound <- [[reg]Definitions >>]Index[name] | |
384 { | |
385 yep,nope <- If[[[[~]Fields >>]Length] = [1]] | |
386 } | |
387 } | |
388 | |
389 Blueprint C Function | |
390 { | |
391 Name | |
392 Inputs | |
393 Outputs | |
394 Convention | |
395 Variables | |
396 Statements | |
397 Method Registry | |
398 Field Registry | |
399 Type Registry | |
400 Constants | |
401 Input Types | |
402 Output Types | |
403 Resume Index | |
404 Last NumParams | |
405 } | |
406 | |
407 C Function[name,inputs,outputs,convention:out] | |
408 { | |
409 out <- C Function With Registry[name,inputs,outputs,convention, C Method Registry[], C Field Registry[], C Type Registry[]] | |
410 } | |
411 | |
412 C Function With Registry[name,inputs,outputs,convention,registry,field reg,type reg:out] | |
413 { | |
414 out <- [[[[[[[[[[[[[[Build[C Function()] | |
415 ]Name <<[name] | |
416 ]Inputs <<[inputs] | |
417 ]Outputs <<[outputs] | |
418 ]Convention <<[convention] | |
419 ]Variables <<[Dictionary[]] | |
420 ]Statements <<[()] | |
421 ]Method Registry <<[registry] | |
422 ]Field Registry <<[field reg] | |
423 ]Type Registry <<[type reg] | |
424 ]Constants <<[Dictionary[]] | |
425 ]Input Types <<[ Fold[Append[?, "Any Type"], (), inputs] ] | |
426 ]Output Types <<[ Fold[Append[?, "Any Type"], (), outputs] ] | |
427 ]Resume Index <<[1] | |
428 ]Last NumParams <<[-1] | |
429 } | |
430 | |
431 Set Input Type@C Function[func,type,input num:out] | |
432 { | |
433 out <- [func]Input Types <<[ [[func]Input Types >>]Set[input num, type] ] | |
434 } | |
435 | |
436 Set Output Type@C Function[func,type,output num:out] | |
437 { | |
438 out <- [func]Output Types <<[ [[func]Output Types >>]Set[output num, type] ] | |
439 } | |
440 | |
441 Register Constant@C Function[func,name,constant:out] | |
442 { | |
443 out <- [func]Constants <<[ [[func]Constants >>]Set[name, constant] ] | |
444 } | |
445 | |
446 Allocate Var@C Function[func,name,type:out] | |
447 { | |
448 out <- [func]Variables <<[ [[func]Variables >>]Set[name,type] ] | |
449 } | |
450 | |
451 Add Statement@C Function[func,statement:out] | |
452 { | |
453 out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[statement]Append[";\n"]]] ] | |
454 } | |
455 | |
456 Add Raw Line@C Function[func,line:out] | |
457 { | |
458 out <- [func]Statements <<[ [[func]Statements >>]Append[["\t"]Append[[line]Append["\n"]]] ] | |
459 } | |
460 | |
461 Add Operator Statement@C Function[func,psource1,psource2,pdest,op:out] | |
462 { | |
463 source1 <- [psource1]Make Op[func] | |
464 source2 <- [psource2]Make Op[func] | |
465 dest <- [pdest]Make Op[func] | |
466 out <- [func]Add Statement[[[[[dest]Append[" = "]]Append[source1]]Append[op]]Append[source2]] | |
467 } | |
468 | |
469 Add@C Function[func,source1,source2,dest:out] | |
470 { | |
471 out <- [func]Add Operator Statement[source1,source2,dest," + "] | |
472 } | |
473 | |
474 Sub@C Function[func,source1,source2,dest:out] | |
475 { | |
476 out <- [func]Add Operator Statement[source1,source2,dest," - "] | |
477 } | |
478 | |
479 Multiply@C Function[func,source1,source2,dest:out] | |
480 { | |
481 out <- [func]Add Operator Statement[source1,source2,dest," * "] | |
482 } | |
483 | |
484 Divide@C Function[func,source1,source2,dest:out] | |
485 { | |
486 out <- [func]Add Operator Statement[source1,source2,dest," / "] | |
487 } | |
488 | |
489 DoLShift@C Function[func,source1,source2,dest:out] | |
490 { | |
491 out <- [func]Add Operator Statement[source1,source2,dest," << "] | |
492 } | |
493 | |
494 DoRShift@C Function[func,source1,source2,dest:out] | |
495 { | |
496 out <- [func]Add Operator Statement[source1,source2,dest," >> "] | |
497 } | |
498 | |
499 CompLess@C Function[func,source1,source2,dest:out] | |
500 { | |
501 out <- [func]Add Operator Statement[source1,source2,dest," < "] | |
502 } | |
503 | |
504 CompGreater@C Function[func,source1,source2,dest:out] | |
505 { | |
506 out <- [func]Add Operator Statement[source1,source2,dest," > "] | |
507 } | |
508 | |
509 CompEqual@C Function[func,source1,source2,dest:out] | |
510 { | |
511 out <- [func]Add Operator Statement[source1,source2,dest," == "] | |
512 } | |
513 | |
514 CompLessEqual@C Function[func,source1,source2,dest:out] | |
515 { | |
516 out <- [func]Add Operator Statement[source1,source2,dest," <= "] | |
517 } | |
518 | |
519 CompGreaterEqual@C Function[func,source1,source2,dest:out] | |
520 { | |
521 out <- [func]Add Operator Statement[source1,source2,dest," >= "] | |
522 } | |
523 | |
524 CompNotEqual@C Function[func,source1,source2,dest:out] | |
525 { | |
526 out <- [func]Add Operator Statement[source1,source2,dest," != "] | |
527 } | |
528 | |
529 Move@C Function[func,psource,pdest:out] | |
530 { | |
531 source <- [psource]Make Op[func] | |
532 dest <- [pdest]Make Op[func] | |
533 out <- [func]Add Statement[[[dest]Append[" = "]]Append[source]] | |
534 } | |
535 | |
536 Do AddRef@C Function[func,psource,pdest:out] | |
537 { | |
538 source <- [psource]Make Op[func] | |
539 dest <- [pdest]Make Op[func] | |
540 out <- [func]Add Statement[[[[dest]Append[" = add_ref((object *)"]]Append[source]]Append[")"]] | |
541 } | |
542 | |
543 AddRef No Dest@C Function[func,psource:out] | |
544 { | |
545 source <- [psource]Make Op[func] | |
546 out <- [func]Add Statement[[["add_ref((object *)"]Append[source]]Append[")"]] | |
547 } | |
548 | |
549 Release@C Function[func,psource:out] | |
550 { | |
551 source <- [psource]Make Op[func] | |
552 out <- [func]Add Statement[[["release_ref((object *)"]Append[source]]Append[")"]] | |
553 } | |
554 | |
555 Set Null@C Function[func,pdest:out] | |
556 { | |
557 dest <- [pdest]Make Op[func] | |
558 out <- [func]Add Statement[[dest]Append[" = NULL"]] | |
559 } | |
560 | |
561 Lookup Constant@C Function[func,const,doaddref:out] | |
562 { | |
563 var <- ["_const_"]Append[Escape Rhope Name[const]] | |
564 If[doaddref] | |
565 { | |
566 out <- [["add_ref("]Append[var]]Append[")"] | |
567 }{ | |
568 out <- Val[var] | |
569 } | |
570 } | |
571 | |
572 Field Result@C Function[func,var,field:out] | |
573 { | |
574 as op <- [var]Make Op[func] | |
575 [(String(),String Cat(),String Slice())]Find[=[Blueprint Of[var],?]] | |
576 { | |
577 [[func]Inputs >>]Find[=[var,?]] | |
578 { | |
579 type <- [[func]Input Types >>]Index[~] | |
580 | |
581 }{ | |
582 type <- [[func]Variables >>]Index[var] { Print["op refers to a var"] } | |
583 { | |
584 [[func]Outputs >>]Find[=[var,?]] | |
585 { | |
586 type <- [[func]Output Types >>]Index[~] | |
587 }{ | |
588 //Does it make sense for us to do this? | |
589 type <- Type Instance["Any Type"] | |
590 } | |
591 } | |
592 } | |
593 }{ | |
594 type <- Type Instance["Any Type"] | |
595 } | |
596 If[[[func]Convention >>] = ["rhope"]] | |
597 { | |
598 If[[type] = ["Any Type"]] | |
599 { | |
600 rvar <- Val[as op] | |
601 }{ | |
602 rvar <- [[[["(("]Append[ Rhope Type to C[type] ]]Append[")("]]Append[as op]]Append["))"] | |
603 } | |
604 }{ | |
605 rvar <- Val[as op] | |
606 } | |
607 | |
608 [[func]Type Registry >>]Simple Type?[[type]Name >>] | |
609 { access <- "->" } | |
610 { access <- "->payload." } | |
611 { | |
612 //TODO: Generate some kind of error/exception in this case | |
613 access <- "->" | |
614 } | |
615 out <- [[rvar]Append[access]]Append[Escape Rhope Name[field]] | |
616 } | |
617 | |
618 Read Field@C Function[func,var,field:out,result op] | |
619 { | |
620 out <- func | |
621 result op <- Field Ref[var,field] | |
622 } | |
623 | |
624 Write Field@C Function[func,var,field:out,result op] | |
625 { | |
626 out <- func | |
627 result op <- Field Ref[var,field] | |
628 } | |
629 | |
630 Set Field Null@C Function[func,var,field:out] | |
631 { | |
632 out <- [func]Add Statement[ [[func]Field Result[var,field]]Append[" = NULL"] ] | |
633 } | |
634 | |
635 Copy@C Function[func,pdest:out] | |
636 { | |
637 dest <- [pdest]Make Op[func] | |
638 out <- [func]Add Statement[ [dest]Append[[[" = copy_object("]Append[dest]]Append[")"]] ] | |
639 } | |
640 | |
641 Box@C Function[func,psource,pdest,type:out] | |
642 { | |
643 dest <- [pdest]Make Op[func] | |
644 source <- [psource]Make Op[func] | |
645 out <- [func]Add Statement[ | |
646 [[[[[dest | |
647 ]Append[" = naked_to_boxed("] | |
648 ]Append[ [[func]Type Registry >>]Type ID[[type]Name >>] ] | |
649 ]Append[", &"] | |
650 ]Append[source] | |
651 ]Append[")"] ] | |
652 } | |
653 | |
654 Unbox@C Function[func,psource,pdest:out] | |
655 { | |
656 dest <- [pdest]Make Op[func] | |
657 source <- [psource]Make Op[func] | |
658 out <- [func]Add Statement[ | |
659 [[[["boxed_to_naked(" | |
660 ]Append[source] | |
661 ]Append[", &"] | |
662 ]Append[dest] | |
663 ]Append[")"] ] | |
664 } | |
665 | |
666 Get Raw Pointer@C Function[func,psource,pdest:out] | |
667 { | |
668 dest <- [pdest]Make Op[func] | |
669 source <- [psource]Make Op[func] | |
670 out <- [func]Add Statement[ [[[dest]Append[" = (void*)("]]Append[source]]Append[" + 1)"] ] | |
671 } | |
672 | |
673 Array Raw Pointer@C Function[func,psource,pdest:out] | |
674 { | |
675 dest <- [pdest]Make Op[func] | |
676 source <- [psource]Make Op[func] | |
677 out <- [func]Add Statement[ [[[dest]Append[" = ((char *)"]]Append[source]]Append[")+ sizeof(t_Array)"] ] | |
678 } | |
679 | |
680 _Function Arg C[func,val,inputnum:out] | |
681 { | |
682 out <- [func]Add Raw Line[ | |
683 [[[["SetParam(" | |
684 ]Append[String[inputnum]] | |
685 ]Append[", "] | |
686 ]Append[val] | |
687 ]Append[")"] | |
688 ] | |
689 } | |
690 | |
691 _Val Function Arg C[func,val,inputnum,worker:out] | |
692 { | |
693 out <- [func]Add Raw Line[ | |
694 [[[[[["VCSetParam(" | |
695 ]Append[worker] | |
696 ]Append[", "] | |
697 ]Append[String[inputnum]] | |
698 ]Append[", "] | |
699 ]Append[val] | |
700 ]Append[")"] | |
701 ] | |
702 } | |
703 | |
704 Method Call@C Function[func,method,args:out] | |
705 { | |
706 out <- [func]Call[method,args] | |
707 } | |
708 | |
709 Val Call@C Function[func,to call,args:out] | |
710 { | |
711 worker <- Make Op[Strip Addref[to call], func] | |
712 rargs <- Map[args, Make Op[?, func]] | |
713 | |
714 If[[[func]Last NumParams >>] = [-1]] | |
715 { | |
716 freed <- Val[func] | |
717 }{ | |
718 freed <- [func]Add Raw Line["FreeCall"] | |
719 } | |
720 prepped <- [[freed]Add Raw Line[ | |
721 [[[["VCPrepCall(" | |
722 ]Append[worker] | |
723 ]Append[", "] | |
724 ]Append[String[[rargs]Length]] | |
725 ]Append[")"] ] | |
726 ]Last NumParams <<[[rargs]Length] | |
727 | |
728 | |
729 out <- [[[[Fold[_Val Function Arg C[?, ?, ?, worker], prepped, rargs] | |
730 ]Add Raw Line[ | |
731 [[[[[[[["ValCall(" | |
732 ]Append[worker] | |
733 ]Append[", "] | |
734 ]Append[String[[rargs]Length]] | |
735 ]Append[", "] | |
736 ]Append[String[[func]Resume Index >>]] | |
737 ]Append[", "] | |
738 ]Append[Escape Rhope Name[[func]Name >>]] | |
739 ]Append[")"]] | |
740 ]Add Raw Line["DISPATCH"] | |
741 ]Add Raw Line[ | |
742 [[[["ValCallPostlude(" | |
743 ]Append[String[[func]Resume Index >>]] | |
744 ]Append[", "] | |
745 ]Append[Escape Rhope Name[[func]Name >>]] | |
746 ]Append[")"]] | |
747 ]Resume Index <<[ [[func]Resume Index >>]+[1] ] | |
748 } | |
749 | |
750 Call@C Function[func,name,args:out] | |
751 { | |
752 If[[name]=["Call@Worker"]] | |
753 { | |
754 //TODO: Handle case when user explicitly calls the fully qualified version, but the type of the first arg isn't Worker | |
755 out <- [func]Val Call[[args]Index[0], Tail[args,1]] | |
756 }{ | |
757 If[[name]=["Call"]] | |
758 { | |
759 to call <- [args]Index[0] | |
760 last numparams <- [func]Last NumParams >> | |
761 out <- [[[[[[func]Add Raw Line[[["if (get_blueprint("]Append[Make Op[Strip Addref[to call], func]]]Append[")->type_id == TYPE_WORKER) {"]] | |
762 ]Val Call[to call, Tail[args,1]] | |
763 ]Add Raw Line["} else {"] | |
764 ]Last NumParams <<[last numparams] | |
765 ]Func Base["Call",args, "Call"] | |
766 ]Add Raw Line["}"] | |
767 }{ | |
768 out <- [func]Func Base[Escape Rhope Name[name],args, "Call"] | |
769 } | |
770 } | |
771 } | |
772 | |
773 Func Base@C Function[func,tocall,args,type:out] | |
774 { | |
775 Print[ [[func]Name >>]Append[ [": Func Base("]Append[tocall] ] ] | |
776 rargs <- Map[args, Make Op[?, func]] | |
777 | |
778 If[[[rargs]Length] > [[func]Last NumParams >>]] | |
779 { | |
780 If[[[func]Last NumParams >>] = [-1]] | |
781 { | |
782 freed <- Val[func] | |
783 }{ | |
784 freed <- [func]Add Raw Line["FreeCall"] | |
785 } | |
786 prepped <- [[freed]Add Raw Line[ [["PrepCall("]Append[String[[rargs]Length]]]Append[")"] ] | |
787 ]Last NumParams <<[[rargs]Length] | |
788 }{ | |
789 prepped <- Val[func] | |
790 } | |
791 | |
792 | |
793 out <- [[Fold[_Function Arg C[?], prepped, rargs] | |
794 ]Add Raw Line[ | |
795 [[[[[[[[[type]Append["("] | |
796 ]Append[tocall] | |
797 ]Append[", "] | |
798 ]Append[String[[rargs]Length]] | |
799 ]Append[", "] | |
800 ]Append[String[[func]Resume Index >>]] | |
801 ]Append[", "] | |
802 ]Append[Escape Rhope Name[[func]Name >>]] | |
803 ]Append[")"]] | |
804 ]Resume Index <<[ [[func]Resume Index >>]+[1] ] | |
805 } | |
806 | |
807 Call Foreign@C Function[func,name,language,args,store result:out] | |
808 { | |
809 rargs <- Map[args, Make Op[?, func]] | |
810 //Assume language = "C" for now | |
811 base <- [[[name]Append["("]]Append[ Join[rargs, ", "] ]]Append[")"] | |
812 ,do store <- [(String(), String Slice(), String Cat())]Find[=[Blueprint Of[store result], ?]] | |
813 { | |
814 ,do store <- If[[store result]=[""]] | |
815 { stmt <- Val[base] } | |
816 } | |
817 | |
818 Val[do store] | |
819 { stmt <- [[Make Op[store result, func]]Append[" = "]]Append[base] } | |
820 out <- [func]Add Statement[stmt] | |
821 } | |
822 | |
823 Get Field Call@C Function[func,field,source:out] | |
824 { | |
825 out <- [func]Func Base[Escape Rhope Name[[field]Append[" >>"]], [()]Append[source], "Call"] | |
826 } | |
827 | |
828 Set Field Call@C Function[func,field,object,value:out] | |
829 { | |
830 out <- [func]Func Base[Escape Rhope Name[[field]Append[" <<"]], [[()]Append[object]]Append[value], "Call"] | |
831 } | |
832 | |
833 Tail Method Call@C Function[func,method,args:out] | |
834 { | |
835 out <- [func]Func Base[[[func]Method Registry >>]Method ID[method],args, "TMCall"] | |
836 } | |
837 | |
838 Tail Call@C Function[func,name,args:out] | |
839 { | |
840 out <- [func]Func Base[Escape Rhope Name[name],args, "TCall"] | |
841 } | |
842 | |
843 Resolve@C Function[func,op:out] | |
844 { | |
845 If[[[func]Convention >>] = ["rhope"]] | |
846 { | |
847 [[func]Inputs >>]Find[=[op,?]] | |
848 { | |
849 out <- [["my_cdata->params["]Append[String[~]]]Append[" ]"] | |
850 }{ | |
851 out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]Append[Escape Rhope Name[op]] | |
852 } | |
853 }{ | |
854 out <- Escape Rhope Name[op] | |
855 } | |
856 } | |
857 | |
858 Resolve Output@C Function[func,name:out] | |
859 { | |
860 If[[[func]Convention >>] = ["rhope"]] | |
861 { | |
862 out <- [[["lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]Append[Escape Rhope Name[name]] | |
863 }{ | |
864 out <- Escape Rhope Name[name] | |
865 } | |
866 } | |
867 | |
868 Instruction Stream@C Function[func:out] | |
869 { | |
870 out <- [func]Statements <<[()] | |
871 } | |
872 | |
873 _If C[func, statement:out] | |
874 { | |
875 out <- [func]Statements <<[ [[func]Statements >>]Append[ ["\t"]Append[statement] ] ] | |
876 } | |
877 | |
878 Do If@C Function[func,condition,stream:out] | |
879 { | |
880 cond <- [condition]Make Op[func] | |
881 out <- [[Fold[_If C[?], [[func | |
882 ]Add Raw Line[ [["if("]Append[cond]]Append[")"] ] | |
883 ]Add Raw Line["{"], [stream]Statements >>] | |
884 ]Add Raw Line["}"] | |
885 ]Resume Index <<[[stream]Resume Index >>] | |
886 | |
887 } | |
888 | |
889 Discard Outputs@C Function[func,first to discard:out] | |
890 { | |
891 out <- [[[[[func | |
892 ]Add Raw Line[[["for(idx = "]Append[String[first to discard]]]Append["; idx < cdata->num_params; ++idx)"]] | |
893 ]Add Raw Line["{"] | |
894 ]Add Raw Line[" if (cdata->params[idx])"] | |
895 ]Add Raw Line[" release_ref(cdata->params[idx]);"] | |
896 ]Add Raw Line["}"] | |
897 } | |
898 | |
899 Result Reference@C Function[func,output:out] | |
900 { | |
901 out <- [["cdata->params["]Append[String[output]]]Append["]"] | |
902 } | |
903 | |
904 Checked Result Reference@C Function[func,output:out] | |
905 { | |
906 out <- [[[["("]Append[output]]Append[" < cdata->num_params ? cdata->params["]]Append[output]]Append["] : NULL)"] | |
907 } | |
908 | |
909 | |
910 If Null Else@C Function[func,left,right:out] | |
911 { | |
912 check <- [[Make Condition[left]]Strip Addref]Make Op[func] | |
913 l <- [left]Make Op[func] | |
914 r <- [right]Make Op[func] | |
915 out <- [[[[[["(" | |
916 ]Append[check] | |
917 ]Append[" ? "] | |
918 ]Append[l] | |
919 ]Append[" : "] | |
920 ]Append[r] | |
921 ]Append[")"] | |
922 } | |
923 | |
924 _Set Outputs C[string,inputname,inputnum,func:out] | |
925 { | |
926 out <- [string]Append[[[ [ ["\tRet("]Append[String[inputnum]] ]Append[ [[", lv_"]Append[Escape Rhope Name[[func]Name >>]]]Append["->"]]]Append[Escape Rhope Name[inputname]]]Append[")\n"]] | |
927 } | |
928 | |
929 Set Outputs@C Function[func:out] | |
930 { | |
931 If[[[func]Convention >>] = ["rhope"]] | |
932 { | |
933 out <- [[[Fold[_Set Outputs C[?, ?, ?, func], "", [func]Outputs >>]]Append["\tNumRet("]]Append[String[[[func]Outputs >>]Length]]]Append[")\n"] | |
934 }{ | |
935 [[func]Outputs >>]Index[0] | |
936 { | |
937 out <- [["\treturn "]Append[Escape Rhope Name[~]]]Append[";\n"] | |
938 }{ | |
939 out <- "" | |
940 } | |
941 } | |
942 } | |
943 _Output Defs C[string,varname,index,func:out] | |
944 { | |
945 out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[[[func]Output Types >>]Index[index]]] ]]Append[[" "]Append[Escape Rhope Name[varname]]]]Append[";\n"] | |
946 } | |
947 _Var Defs C[string,type,varname:out] | |
948 { | |
949 Print[["Variable: "]Append[varname]] | |
950 { | |
951 out <- [[[string]Append[ ["\t"]Append[Rhope Type to C[type]] ]]Append[[" "]Append[Escape Rhope Name[varname]]]]Append[";\n"] | |
952 { Print["Produced Output"]} | |
953 } | |
954 } | |
955 | |
956 | |
957 Definitions@C Function[func:out] | |
958 { | |
959 Print[["Definitions@C Function: "]Append[[func]Name >>]] | |
960 { | |
961 If[ [[[func]Convention >>] = ["rhope"]] And [[ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] > [0]] ] | |
962 { | |
963 localtype <- [[[Fold[_Output Defs C[?, ?, ?, func], Fold[_Var Defs C[?],"typedef struct {\n", [func]Variables >>], [func]Outputs >>]]Append["} lt_"]]Append[Escape Rhope Name[[func]Name >>]]]Append[";\n"] | |
964 }{ | |
965 localtype <- "" | |
966 } | |
967 | |
968 If[ [[func]Convention >>] = ["rhope"] ] | |
969 { | |
970 /* parts <- [[func]Name >>]Split["@"] | |
971 [parts]Index[1] | |
972 { | |
973 proto <- [[[["MethodDef(" | |
974 ]Append[Escape Rhope Name[[parts]Index[0]]] | |
975 ]Append[", "] | |
976 ]Append[Escape Rhope Name[~]] | |
977 ]Append[")\n"] | |
978 }{ | |
979 proto <- [["FuncDef("]Append[Escape Rhope Name[[func]Name >>]]]Append[")\n"] | |
980 } */ | |
981 out <- Val[localtype] | |
982 }{ | |
983 out <- [[func]Naked Proto]Append[";\n"] | |
984 } | |
985 } | |
986 } | |
987 | |
988 _Proto Input[list,input,index,types:out] | |
989 { | |
990 out <- [list]Append[ [[Rhope Type to C[[types]Index[index]]]Append[" "]]Append[Escape Rhope Name[input]] ] | |
991 } | |
992 | |
993 Naked Proto@C Function[func:out] | |
994 { | |
995 [[func]Output Types >>]Index[0] | |
996 { | |
997 outtype <- [Rhope Type to C[~]]Append[" "] | |
998 }{ | |
999 outtype <- "void " | |
1000 } | |
1001 out <- [[[[outtype | |
1002 ]Append[ Escape Rhope Name[[func]Name >>]] | |
1003 ]Append["("] | |
1004 ]Append[ [Fold[_Proto Input[?, ?, ?, [func]Input Types >>], (), [func]Inputs >>]]Join[", "] ] | |
1005 ]Append[")"] | |
1006 } | |
1007 | |
1008 Type Check@C Function[func,text,type,input num:out] | |
1009 { | |
1010 If[[type] = ["Any Type"]] | |
1011 { | |
1012 out <- text | |
1013 }{ | |
1014 out <- [text]Append[ [["\tParam("]Append[input num]]Append[ [[", "]Append[ [[func]Type Registry >>]Type ID[type] ]]Append[")"] ] ] | |
1015 } | |
1016 } | |
1017 | |
1018 Check Param Type C[text,type,input num,func:out] | |
1019 { | |
1020 [(String(),String Cat(),String Slice())]Find[=[Blueprint Of[type],?]] | |
1021 { | |
1022 typename <- type | |
1023 }{ | |
1024 typename <- [type]Name >> | |
1025 } | |
1026 If[[typename] = ["Any Type"]] | |
1027 { | |
1028 out <- text | |
1029 }{ | |
1030 out <- [text]Append[[[["\tParam("]Append[String[input num]]]Append[ [","]Append[ [[func]Type Registry >>]Type ID[typename] ] ]]Append[")\n"]] | |
1031 } | |
1032 } | |
1033 | |
1034 Text@C Function[func:out] | |
1035 { | |
1036 Print[["Text@C Function: "]Append[[func]Name >>]] | |
1037 If[ [[func]Convention >>] = ["rhope"] ] | |
1038 { | |
1039 before <- [[func]Name >>]Partition["@"] {} {} | |
1040 { | |
1041 type <- "MethodImpl" | |
1042 cname <- [[[[Escape Rhope Name[before] | |
1043 ]Append[", "] | |
1044 ]Append[Escape Rhope Name[~]] | |
1045 ]Append[", "] | |
1046 ]Append[ [[func]Type Registry >>]Type ID[~] ] | |
1047 }{ | |
1048 type <- "Func" | |
1049 cname <- Val[fname] | |
1050 } | |
1051 fname <- Escape Rhope Name[[func]Name >>] | |
1052 param check <- Fold[Check Param Type C[?, ?, ?, func], "", [func]Input Types >>] | |
1053 If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ] | |
1054 { | |
1055 out <- [[[[[[[[ [type]Append["NoLocals("] | |
1056 ]Append[cname] | |
1057 ]Append[",\n\tNumParams "] | |
1058 ]Append[ String[[[func]Inputs >>]Length] ] | |
1059 ]Append[")\n\n"] | |
1060 ]Append[param check] | |
1061 ]Append[ [[func]Statements >>]Join[""] ] | |
1062 ]Append["EndFuncNoLocals\n"] | |
1063 ]Append["DISPATCH"] | |
1064 }{ | |
1065 If[[[func]Last NumParams >>] = [-1]] | |
1066 { | |
1067 freecall <- "" | |
1068 }{ | |
1069 freecall <- "\n\tFreeCall\n" | |
1070 } | |
1071 out <- [[[[[[[[[[ [type]Append["("] | |
1072 ]Append[cname] | |
1073 ]Append[",\n\tNumParams "] | |
1074 ]Append[ String[[[func]Inputs >>]Length] ] | |
1075 ]Append[")\n\n"] | |
1076 ]Append[param check] | |
1077 ]Append[ [[func]Statements >>]Join[""] ] | |
1078 ]Append[freecall] | |
1079 ]Append[[func]Set Outputs] | |
1080 ]Append[[["EndFunc("]Append[fname]]Append[")\n"]] | |
1081 ]Append["DISPATCH"] | |
1082 } | |
1083 }{ | |
1084 | |
1085 out <- [[[ | |
1086 Fold[_Output Defs C[?, ?, ?, func], | |
1087 Fold[_Var Defs C[?], [[func]Naked Proto]Append["\n{"], [func]Variables >>], [func]Outputs >>] | |
1088 ]Append[[[func]Statements >>]Join[""]] | |
1089 ]Append[[func]Set Outputs] | |
1090 ]Append["}"] | |
1091 } | |
1092 } | |
1093 | |
1094 Blueprint C Program | |
1095 { | |
1096 Functions | |
1097 Method Registry | |
1098 Field Registry | |
1099 Type Registry | |
1100 Libraries | |
1101 } | |
1102 | |
1103 C Program[:out] | |
1104 { | |
1105 out <- [[[[[Build[C Program()]]Functions <<[Dictionary[]]]Method Registry <<[C Method Registry[]]]Type Registry <<[C Type Registry[]]]Field Registry <<[C Field Registry[]]]Libraries <<[Dictionary[]] | |
1106 } | |
1107 | |
1108 Link@C Program[program,language,library:out] | |
1109 { | |
1110 If[[library] = ["runtime"]] | |
1111 { | |
1112 out <- program | |
1113 }{ | |
1114 langlibs <- [[program]Libraries >>]Index[language] {} | |
1115 { langlibs <- Dictionary[] } | |
1116 out <- [program]Libraries <<[ [[program]Libraries >>]Set[language, [langlibs]Set[library, Yes]] ] | |
1117 } | |
1118 } | |
1119 | |
1120 Register Type@C Program[program,def:out] | |
1121 { | |
1122 out <- [[[program]Type Registry <<[ [[program]Type Registry >>]Register Type[def] ] | |
1123 ]Method Registry <<[ [def]Register Methods[[program]Method Registry >>] ] | |
1124 ]Field Registry <<[ [def]Register Fields[[program]Field Registry >>] ] | |
1125 } | |
1126 | |
1127 Create Type@C Program[program,name:out] | |
1128 { | |
1129 out <- C Type[name] | |
1130 } | |
1131 | |
1132 Create Function@C Program[program,name,inputs,outputs,convention:out] | |
1133 { | |
1134 out <- C Function With Registry[name,inputs,outputs,convention, [program]Method Registry >>, [program]Field Registry >>, [program]Type Registry >>] | |
1135 } | |
1136 | |
1137 Store Function@C Program[program,func:out] | |
1138 { | |
1139 out <- [program]Functions <<[ [[program]Functions >>]Set[ [func]Name >>, func] ] | |
1140 } | |
1141 | |
1142 Method?@C Program[program,funcname:is,isnot] | |
1143 { | |
1144 is,isnot <- [[program]Method Registry >>]Method ID[funcname] | |
1145 } | |
1146 | |
1147 _Defs C Program[text,func:out] | |
1148 { | |
1149 def <- [func]Definitions | |
1150 If[[def]=[""]] | |
1151 { | |
1152 out <- text | |
1153 }{ | |
1154 out <- [text]Append[[def]Append["\n\n"]] | |
1155 } | |
1156 } | |
1157 | |
1158 _Text C Program[text,func,type reg:out] | |
1159 { | |
1160 out <- [text]Append[[[ [func]Type Registry <<[type reg] ]Text]Append["\n\n"]] | |
1161 } | |
1162 | |
1163 Combine Consts[consts,func:out] | |
1164 { | |
1165 out <- Combine[[func]Constants >>, consts] | |
1166 } | |
1167 | |
1168 _Consts C Program[text,value,name:out] | |
1169 { | |
1170 out <- [text]Append[ [["object * _const_"]Append[Escape Rhope Name[name]]]Append[";\n"] ] | |
1171 } | |
1172 | |
1173 Const Construct C[value,type reg:out] | |
1174 { | |
1175 valtype <- Blueprint Of[value] | |
1176 [(Int8(),UInt8(),Int16(),UInt16(),Int32(),UInt32(),Int64(),UInt64())]Find[=[valtype,?]] | |
1177 { | |
1178 size <- [("8","16","32","64")]Index[[~]/[2]] | |
1179 If[[~]Mod[2]] | |
1180 { s <- "UI" } | |
1181 { s <- "I" } | |
1182 | |
1183 out <- [[[[[["make_" | |
1184 ]Append[s] | |
1185 ]Append["nt"] | |
1186 ]Append[size] | |
1187 ]Append["("] | |
1188 ]Append[String[value]] | |
1189 ]Append[")"] | |
1190 }{ | |
1191 If[[valtype] = [Type Instance()]] | |
1192 { | |
1193 //TODO: Support parametric types | |
1194 typeid <- [type reg]Type ID[[value]Name >>] | |
1195 out <- [["make_Blueprint("]Append[typeid]]Append[")"] | |
1196 }{ | |
1197 If[[valtype] = [Boolean()]] | |
1198 { | |
1199 If[value] | |
1200 { | |
1201 out <- "make_Bool(1)" | |
1202 }{ | |
1203 out <- "make_Bool(0)" | |
1204 } | |
1205 }{ | |
1206 | |
1207 [(String(),String Slice(),String Cat())]Find[=[valtype,?]] | |
1208 { | |
1209 out <- [["make_String(\""]Append[ [[[value]Replace["\\", "\\\\"]]Replace["\n", "\\n"]]Replace["\"", "\\\""] ]]Append["\")"] | |
1210 }{ | |
1211 If[[valtype]=[Worker Literal()]] | |
1212 { | |
1213 //TODO: Figure out how to fully support these in nested cases | |
1214 //or workaround the problem higher up in the food chain | |
1215 [[value]Args >>]Last | |
1216 { size <- String[[~]+[1]] } | |
1217 { size <- "0" } | |
1218 out <- [[[[[["make_Worker(FUNC_" | |
1219 ]Append[Escape Rhope Name[[value]Name >>]] | |
1220 ]Append[", "] | |
1221 ]Append[size] | |
1222 ]Append[", "] | |
1223 ]Append[String[Fold[+[1,?], 0, [value]Args >>]]] | |
1224 ]Append[")"] | |
1225 }{ | |
1226 out <- "UnhandledLiteralType" | |
1227 } | |
1228 } | |
1229 } | |
1230 } | |
1231 | |
1232 } | |
1233 } | |
1234 | |
1235 _Set Worker Params C[text,param,num,type reg,name:out] | |
1236 { | |
1237 out <- [text]Append[ | |
1238 [[[[[["\t((object **)(((t_Worker *)_const_" | |
1239 ]Append[name] | |
1240 ]Append[")+1))["] | |
1241 ]Append[String[num]] | |
1242 ]Append["] = "] | |
1243 ]Append[Const Construct C[param, type reg]] | |
1244 ]Append[";\n"] ] | |
1245 } | |
1246 | |
1247 _Set Consts C Program[text,value,name,type reg:out] | |
1248 { | |
1249 valtype <- Blueprint Of[value] | |
1250 [(String(),String Cat(),String Slice(),Worker Literal(),List(),List Leaf())]Find[=[valtype,?]] | |
1251 { | |
1252 out <- text | |
1253 }{ | |
1254 Const Construct C[value,type reg] | |
1255 { out <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] } | |
1256 } | |
1257 } | |
1258 | |
1259 _Set List Els[text,el,index,type reg:out] | |
1260 { | |
1261 out <- [[text]Append[ | |
1262 [["\tinout[1] = " | |
1263 ]Append[Const Construct C[index,type reg]] | |
1264 ]Append[ | |
1265 [[";\n\tinout[2] = " | |
1266 ]Append[Const Construct C[el, type reg]] | |
1267 ]Append[";\n"] | |
1268 ]]]Append["\trhope(FUNC_Set, inout, 3, 3);\n"] | |
1269 } | |
1270 | |
1271 _Set Late Consts C[text,value,name,type reg:out] | |
1272 { | |
1273 valtype <- Blueprint Of[value] | |
1274 [(String(),String Cat(),String Slice(),Worker Literal(),List(),List Leaf())]Find[=[valtype,?]] | |
1275 { | |
1276 If[[~]>[3]] | |
1277 { | |
1278 out <- [Fold[_Set List Els[?, ?, ?, type reg], "\trhope(FUNC_List, inout, 0, 1);\n", value] | |
1279 ]Append[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = inout[0];\n"]] | |
1280 }{ | |
1281 Const Construct C[value,type reg] | |
1282 { init <- [text]Append[ [[[["\t_const_"]Append[Escape Rhope Name[name]]]Append[" = "]]Append[~]]Append[";\n"] ] } | |
1283 | |
1284 If[[valtype]=[Worker Literal()]] | |
1285 { | |
1286 out <- Fold[_Set Worker Params C[?, ?, ?, type reg, Escape Rhope Name[name]], init, [value]Args >>] | |
1287 }{ | |
1288 out <- Val[init] | |
1289 } | |
1290 } | |
1291 }{ | |
1292 out <- text | |
1293 } | |
1294 } | |
1295 | |
1296 _Dispatch Switch Sub[text, num, name:out] | |
1297 { | |
1298 out <- [[[[[text | |
1299 ]Append["\tResumeEntry("] | |
1300 ]Append[String[num]] | |
1301 ]Append[","] | |
1302 ]Append[name] | |
1303 ]Append[")\\\n"] | |
1304 } | |
1305 | |
1306 _Dispatch Switch[text,func,raw name:out] | |
1307 { | |
1308 If[[[func]Convention >>] = ["rhope"]] | |
1309 { | |
1310 name <- Escape Rhope Name[raw name] | |
1311 out <- [[text]Append[ [["\tDispatchEntry("]Append[name]]Append[")\\\n"] ] | |
1312 ]Append[Fold[_Dispatch Switch Sub[?, ?, name], "", Range[1, [func]Resume Index >>]]] | |
1313 }{ | |
1314 out <- text | |
1315 } | |
1316 } | |
1317 | |
1318 _Dispatch Switch Methods[text,id,raw name:out] | |
1319 { | |
1320 name <- Escape Rhope Name[raw name] | |
1321 out <- [text]Append[ [["\tDispatchEntry("]Append[name]]Append[")\\\n"] ] | |
1322 } | |
1323 | |
1324 _Dispatch Enum Sub[text, num, name:out] | |
1325 { | |
1326 out <- [[[[[text | |
1327 ]Append["\tRES_"] | |
1328 ]Append[String[num]] | |
1329 ]Append["_"] | |
1330 ]Append[name] | |
1331 ]Append[",\n"] | |
1332 } | |
1333 | |
1334 _Dispatch Enum[text,func,raw name:out] | |
1335 { | |
1336 If[[[func]Convention >>] = ["rhope"]] | |
1337 { | |
1338 name <- Escape Rhope Name[raw name] | |
1339 out <- [[text]Append[ [["\tFUNC_"]Append[name]]Append[",\n"] ] | |
1340 ]Append[Fold[_Dispatch Enum Sub[?, ?, name], "", Range[1, [func]Resume Index >>]]] | |
1341 }{ | |
1342 out <- text | |
1343 } | |
1344 } | |
1345 | |
1346 _Dispatch Enum Methods[text,types,name:out] | |
1347 { | |
1348 out <- [text]Append[ [["\tFUNC_"]Append[Escape Rhope Name[name]]]Append[",\n"] ] | |
1349 } | |
1350 | |
1351 Dispatch@C Program[program,all methods:out] | |
1352 { | |
1353 out <- [[[[["typedef enum {\n" | |
1354 ]Append[Fold[_Dispatch Enum[?], | |
1355 [Fold[_Dispatch Enum Methods[?], "", all methods]]Append["\tFUNC_Build,\n\tFUNC_BlueprintSP_Of,\n\tFUNC_ID,\n\tFUNC_BlueprintSP_FromSP_ID,\n"], | |
1356 [program]Functions >>]] | |
1357 ]Append["\tEND\n} funcids;\n\n"] | |
1358 ]Append["#define DispatchEntries \\\n"] | |
1359 ]Append[Fold[_Dispatch Switch[?], | |
1360 [Fold[_Dispatch Switch Methods[?], "", all methods]]Append["\tDispatchEntry(Build)\\\n\tDispatchEntry(BlueprintSP_Of)\\\n\tDispatchEntry(ID)\\\n\tDispatchEntry(BlueprintSP_FromSP_ID)\\\n"], | |
1361 [program]Functions >>]] | |
1362 ]Append["\tEndEntry\n\n"] | |
1363 } | |
1364 | |
1365 Not Native[func:out] | |
1366 { | |
1367 If[[[func]Convention >>] = ["rhope"]] | |
1368 { out <- No } | |
1369 { out <- Yes } | |
1370 } | |
1371 | |
1372 Native[func:out] | |
1373 { | |
1374 out <- [[func]Convention >>] = ["rhope"] | |
1375 } | |
1376 | |
1377 Local Pointers[text,func:out] | |
1378 { | |
1379 If[ [ [[[func]Variables >>]Length]+[[[func]Outputs >>]Length] ] = [0] ] | |
1380 { | |
1381 out <- text | |
1382 }{ | |
1383 out <- [text]Append[[["\tFuncDef("]Append[Escape Rhope Name[[func]Name >>]]]Append[")\n"]] | |
1384 } | |
1385 } | |
1386 | |
1387 _Method to Types[dict,name,type:out] | |
1388 { | |
1389 typelist <- [dict]Index[name] {} | |
1390 { typelist <- () } | |
1391 | |
1392 out <- [dict]Set[name, [typelist]Append[[type]Name >>]] | |
1393 | |
1394 } | |
1395 | |
1396 _Field to Types[dict,field,type:out] | |
1397 { | |
1398 name <- [field]Index[0] | |
1399 out <- _Method to Types[_Method to Types[dict, [name]Append[" >>"], type], [name]Append[" <<"], type] | |
1400 | |
1401 } | |
1402 | |
1403 Method to Types[dict,type:out] | |
1404 { | |
1405 out <- Fold[_Method to Types[?, ?, type], dict, [type]Methods >>] | |
1406 } | |
1407 | |
1408 Field to Types[dict,type:out] | |
1409 { | |
1410 out <- Fold[_Field to Types[?, ?, type], dict, [type]Fields >>] | |
1411 } | |
1412 | |
1413 _Method Dispatch[text, type, method, reg: out] | |
1414 { | |
1415 out <- [[[[[[[text]Append["\tMethodDispatch("]]Append[ [reg]Type ID[type] ]]Append[","]]Append[Escape Rhope Name[method]]]Append[","]]Append[Escape Rhope Name[type]]]Append[")\n"] | |
1416 } | |
1417 | |
1418 Method Dispatch[text, types, method, reg: out] | |
1419 { | |
1420 out <- [[[Fold[_Method Dispatch[?, ?, method, reg], [[[text]Append["Method("]]Append[ Escape Rhope Name[method] ]]Append[")\n"], types] | |
1421 ]Append["EndMethod("] | |
1422 ]Append[Escape Rhope Name[method]] | |
1423 ]Append[")\n\n"] | |
1424 } | |
1425 | |
1426 Text@C Program[program:out] | |
1427 { | |
1428 type defs <- [[program]Type Registry >>]Definitions >> | |
1429 constants <- Fold[Combine Consts[?], Dictionary[], [program]Functions >>] | |
1430 all methods <- Fold[Field to Types[?], Fold[Method to Types[?], Dictionary[], type defs], type defs] | |
1431 headers <- "#include <stdio.h> | |
1432 #include <stdlib.h> | |
1433 #include \"builtin.h\" | |
1434 #include \"object.h\" | |
1435 #include \"context.h\" | |
1436 #include \"func.h\" | |
1437 #include \"integer.h\" | |
1438 #include \"blueprint.h\" | |
1439 #include \"array.h\" | |
1440 #include \"worker.h\" | |
1441 #include \"bool.h\"\n\n" | |
1442 out <- [[[[[[[[[[[[[[[headers | |
1443 ]Append[[program]Dispatch[all methods]] | |
1444 ]Append[[[program]Type Registry >>]Type Defs] | |
1445 ]Append[Fold[_Consts C Program[?], | |
1446 Fold[_Defs C Program[?], "", [program]Functions >>], | |
1447 constants]] | |
1448 ]Append[Fold[_Text C Program[?, ?, [program]Type Registry >>], "", Filter[[program]Functions >>, Not Native[?]]]] | |
1449 ]Append["\n | |
1450 int32_t rhope(uint32_t func, object ** params, uint16_t numparams, uint16_t callspace) | |
1451 { | |
1452 uint16_t resume,idx, vcparam_offset, last_vcparam; | |
1453 context * ct; | |
1454 calldata * cdata, *temp_cdata, *my_cdata; | |
1455 DispatchVar | |
1456 FuncDef(Build) | |
1457 FuncDef(BlueprintSP_Of) | |
1458 FuncDef(ID) | |
1459 FuncDef(BlueprintSP_FromSP_ID)\n"] | |
1460 ]Append[Fold[Local Pointers[?], "", [program]Functions >>]] | |
1461 ]Append[" | |
1462 ct = new_context(); | |
1463 cdata = alloc_cdata(ct, NULL, callspace); | |
1464 cdata->num_params = numparams; | |
1465 for(idx = 0; idx < numparams; ++idx) | |
1466 cdata->params[idx] = params[idx]; | |
1467 cdata->func = END; | |
1468 DISPATCH\n"] | |
1469 ]Append[Fold[Method Dispatch[?, ?, ?, [program]Type Registry >>], "", all methods]] | |
1470 ]Append[" | |
1471 Func(Build, | |
1472 NumParams 1) | |
1473 | |
1474 Param(0, TYPE_BLUEPRINT) | |
1475 | |
1476 lv_Build->bp = ((t_Blueprint *)(cdata->params[0]))->bp; | |
1477 release_ref(cdata->params[0]); | |
1478 | |
1479 Ret(0, new_object_bp(lv_Build->bp)) | |
1480 EndFunc(Build) | |
1481 DISPATCH | |
1482 | |
1483 Func(BlueprintSP_Of, | |
1484 NumParams 1) | |
1485 | |
1486 lv_BlueprintSP_Of->bp = get_blueprint(cdata->params[0]); | |
1487 release_ref(cdata->params[0]); | |
1488 | |
1489 Ret(0, new_object(TYPE_BLUEPRINT)) | |
1490 ((t_Blueprint *)cdata->params[0])->bp = lv_BlueprintSP_Of->bp; | |
1491 EndFunc(BlueprintSP_Of) | |
1492 DISPATCH | |
1493 | |
1494 Func(ID, NumParams 1) | |
1495 | |
1496 Param(0, TYPE_BLUEPRINT) | |
1497 | |
1498 lv_ID->id = new_object(TYPE_UINT32); | |
1499 ((t_UInt32 *)lv_ID->id)->Num = ((t_Blueprint *)cdata->params[0])->bp->type_id; | |
1500 release_ref(cdata->params[0]); | |
1501 Ret(0, lv_ID->id) | |
1502 EndFunc(ID) | |
1503 DISPATCH | |
1504 | |
1505 Func(BlueprintSP_FromSP_ID, NumParams 1) | |
1506 | |
1507 Param(0, TYPE_UINT32) | |
1508 | |
1509 lv_BlueprintSP_FromSP_ID->type = ((t_UInt32 *)cdata->params[0])->Num; | |
1510 if (lv_BlueprintSP_FromSP_ID->type >= max_registered_type || !registered_types[lv_BlueprintSP_FromSP_ID->type]) { | |
1511 Ret(1, cdata->params[0]) | |
1512 Ret(0, NULL) | |
1513 } else { | |
1514 release_ref(cdata->params[0]); | |
1515 Ret(0, new_object(TYPE_BLUEPRINT)) | |
1516 ((t_Blueprint *)cdata->params[0])->bp = registered_types[lv_BlueprintSP_FromSP_ID->type]; | |
1517 Ret(1, NULL) | |
1518 } | |
1519 | |
1520 EndFunc(BlueprintSP_FromSP_ID) | |
1521 DISPATCH\n"] | |
1522 ]Append[Fold[_Text C Program[?, ?, [program]Type Registry >>], "", Filter[[program]Functions >>, Native[?]]]] | |
1523 ]Append[" | |
1524 DO_END: | |
1525 for(idx = 0; idx < cdata->num_params; ++idx) | |
1526 params[idx] = cdata->params[idx]; | |
1527 free_context(ct); | |
1528 return cdata->num_params; | |
1529 | |
1530 _exception: | |
1531 puts(\"Exception! Trace follows:\"); | |
1532 while(cdata && cdata->func != END) | |
1533 { | |
1534 printf(\"%d\\n\", cdata->func); | |
1535 cdata = cdata->lastframe; | |
1536 } | |
1537 return -1; | |
1538 } | |
1539 | |
1540 #include \"builtin.c\" | |
1541 #include \"array.c\" | |
1542 #include \"worker.c\" | |
1543 | |
1544 int main(int argc, char **argv) | |
1545 { | |
1546 blueprint * bp; | |
1547 int numret; | |
1548 int idx; | |
1549 object * inout[2]; | |
1550 register_builtin_types();\n\n"] | |
1551 ]Append[ [[program]Type Registry >>]Type Inits[[program]Method Registry >>, [program]Field Registry >>] ] | |
1552 ]Append[Fold[_Set Consts C Program[?, ?, ?, [program]Type Registry >>], "", constants]] | |
1553 ]Append[Fold[_Set Late Consts C[?, ?, ?, [program]Type Registry >>], "", constants]] | |
1554 ]Append[" | |
1555 rhope(FUNC_List, inout, 0, 1); | |
1556 for (idx = 0; idx < argc; ++idx) | |
1557 { | |
1558 inout[1] = make_String(argv[idx]); | |
1559 rhope(FUNC_Append, inout, 2, 2); | |
1560 } | |
1561 numret = rhope(FUNC_Main, inout, 1, 1); | |
1562 if (!numret) | |
1563 return 0; | |
1564 if (numret < 0) | |
1565 return numret; | |
1566 if (get_blueprint(inout[0])->type_id == TYPE_INT32) | |
1567 return ((t_Int32 *)inout[0])->Num; | |
1568 | |
1569 rhope(FUNC_If, inout, 1, 2); | |
1570 if (inout[0]) | |
1571 return 0; | |
1572 return 1; | |
1573 }\n\n"] | |
1574 | |
1575 } | |
1576 | |
1577 |