Charj: simplify and improve SDAG handling
[charm.git] / src / langs / charj / src / charj / translator / Charj.stg
1 group Charj;
2
3 charjSource_ci(basename, pd, imports, types, ros, debug) ::=
4 <<
5
6 // interface for <basename>
7 <imports; separator="\n">
8 <types; separator="\n\n">
9
10 module <basename>_readonly {
11 <if(ros)>
12     <charjReadonly_ci(pds = pd, ros = ros)>
13 <endif>
14
15 }
16
17 >>
18
19 charjReadonly_ci(pds, ros) ::=
20 <<
21 <if(first(pds))>namespace <first(pds)>
22 {
23     <charjReadonly_ci(pds = rest(pds), ros = ros)>
24 } // namespace <first(pds)>
25 <else>
26 <ros; separator="\n">
27 <endif>
28 >>
29
30 charjSource_h(basename, pd, imports, types, ros, debug) ::=
31 <<
32 #ifndef __<basename>__
33 #define __<basename>__
34
35 /**************************************************************************
36  * WARNING                                                                *
37  **************************************************************************
38  * This is a machine generated header file.                               *
39  * It is not meant to be edited by hand and may be overwritten by charjc. *
40  **************************************************************************/
41
42 <imports; separator="\n">
43 <types; separator="\n\n">
44 <if(ros)>
45 /* Readonly variables */
46 <readonlys_h(pds = pd, ros = ros)>
47 #include "<basename>_readonly.decl.h"
48 <endif>
49
50
51 #endif // __<basename>__
52
53
54 >>
55
56 charjSource_cc(basename, pd, imports, types, ros, debug) ::=
57 <<
58 #include "<basename>.h"
59
60 <imports; separator="\n">
61 <types; separator="\n\n">
62 <if(ros)>
63
64 /* Readonly variable support */
65 <readonlys_cc(pds = pd, ros = ros, basename = basename)>
66 <endif>
67
68
69 >>
70
71 readonlys_h(pds, ros) ::=
72 <<
73 <if(first(pds))>namespace <first(pds)>
74 {
75     <readonlys_h(pds = rest(pds), ros = ros)>
76 } // namespace <first(pds)>
77 <else>
78 <ros; separator="\n">
79 <endif>
80 >>
81
82
83 readonlys_cc_inner(pds, ros, basename) ::=
84 <<
85 <if(first(pds))>namespace <first(pds)>
86 {
87     <readonlys_cc_inner(pds = rest(pds), ros = ros, basename = basename)>
88 } // namespace <first(pds)>
89 <else>
90 <ros; separator="\n">
91 <endif>
92 >>
93
94
95 readonlys_cc(pds, ros, basename) ::=
96 <<
97 <readonlys_cc_inner(pds = pds, ros = ros, basename = basename)>
98 #include "<basename>_readonly.def.h"
99
100 >>
101
102
103 importDeclaration_cc_h(inc_id, use_id) ::=
104 <<
105 #include \<<inc_id>\>
106 using <use_id>;
107 >>
108
109 classExtends_ci(type) ::= "<type>"
110
111
112 classExtends_cc_h(type) ::= "#include \<<type>.h\>"
113
114
115 interfaceExtends(ts) ::=
116 <<
117 : public <ts; separator=", public ">
118 >>
119
120 type_preamble_h(sym) ::=
121 <<
122 <sym.Includes:{include| #include \<<include>\>
123 }>
124 <sym.Usings:{using| using <using>;
125 }>
126 <sym.MemberTypeNames:{name| class <name>;
127 }>
128 >>
129
130 chare_preamble_h(sym) ::=
131 <<
132 <type_preamble_h(sym)>
133 >>
134
135 type_epilogue_h(sym) ::=
136 <<
137 >>
138
139 chare_epilogue_h(sym) ::=
140 <<
141 <type_epilogue_h(sym)>
142 >>
143
144 classDeclaration_h(sym, ident, ext, csds, tident) ::=
145 <<
146 <type_preamble_h(sym)>
147 <if(tident)>
148 <templateDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds, tident = tident)>
149 <else>
150 <classDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
151 <endif>
152 <type_epilogue_h(sym)>
153 >>
154
155 classDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
156 <<
157 <if(first(pds))>namespace <first(pds)>
158 {
159     <classDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
160 } // namespace <first(pds)>
161 <else>
162 <if(ext)>
163 class <ident> : public <ext> {
164 <else>
165 class <ident> {
166 <endif>
167
168     <csds; separator="\n\n">
169     <if(!sym.hasDefaultCtor)>
170     public: <ident>();
171     <endif>
172     protected: void constructorHelper();
173     static bool _trace_registered;
174     void _initTrace();
175 };
176 <endif>
177 >>
178
179 templateDeclaration_h(pds, sym, ident, ext, csds, tident, inits) ::=
180 <<
181 template \<class <tident; separator=", class ">\>
182 <classDeclaration_h_cont(pds=pds, sym=sym, ident=ident, ext=ext, csds=csds, inits=inits)>
183 >>
184
185 classDeclaration_cc(sym, ident, ext, csds, inits) ::=
186 <<
187 <classDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds, inits = inits)>
188 >>
189
190 classDeclaration_cc_cont(pds, sym, ident, ext, csds, inits) ::=
191 <<
192 <if(first(pds))>namespace <first(pds)>
193 {
194     <classDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds, inits = inits)>
195 } // namespace <first(pds)>
196 <else>
197 #if _CHARJ_TRACE_ALL_METHODS || _CHARJ_TRACE_TRACED_METHODS
198 #include \<trace-projections.h\>
199 #endif
200 <csds; separator="\n\n">
201
202 <if(!sym.hasDefaultCtor)>
203 <sym.name>::<ident>()
204 {
205     constructorHelper();
206 }
207 <endif>
208
209 void <sym.name>::constructorHelper()
210 {
211     <inits; separator="\n">
212 }
213
214 bool <sym.name>::_trace_registered = false;
215 void <sym.name>::_initTrace() {
216     #if _CHARJ_TRACE_ALL_METHODS || _CHARJ_TRACE_TRACED_METHODS
217     if (_trace_registered) return;
218     <sym.traceInitializers; separator="\n">
219     _trace_registered = true;
220     #endif
221 }
222 <endif>
223 >>
224
225
226 chareDeclaration_cc(sym, ident, ext, csds, pupers, pupInits, needsMigration, inits) ::=
227 <<
228 #include "<ident>.decl.h"
229 <chareDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds, pupers = pupers, pupInits = pupInits, needsMigration = needsMigration, inits = inits)>
230 #include "<ident>.def.h"
231 >>
232
233 chareDeclaration_cc_cont(pds, sym, ident, ext, csds, pupers, pupInits, needsMigration, inits) ::=
234 <<
235 <if(first(pds))>namespace <first(pds)>
236 {
237     <chareDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds, pupers = pupers, pupInits = pupInits, needsMigration = needsMigration, inits = inits)>
238 } // namespace <first(pds)>
239 <else>
240 #if _CHARJ_TRACE_ALL_METHODS || _CHARJ_TRACE_TRACED_METHODS
241 #include \<trace-projections.h\>
242 #endif
243 <csds; separator="\n\n">
244
245 <if(pupInits)>
246 void <sym.name>::pupInitMethod()
247 {
248     <pupInits; separator="\n">
249 }
250 <endif>
251
252 void <sym.name>::pup(PUP::er &p)
253 {
254 <if(pupInits)>
255     if(p.isUnpacking())
256         pupInitMethod();
257
258 <endif>
259     <pupers; separator="\n">
260 <if(sym.hasSDAG)>
261     __sdag_pup(p);
262
263 <endif>
264 }
265
266 <if(!sym.hasDefaultCtor)>
267 <if(sym.isMainChare)>
268 <sym.name>::<ident>(CkArgMsg* msg)
269 {
270     constructorHelper();
271 }
272 <else>
273 <sym.name>::<ident>()
274 {
275     constructorHelper();
276 }
277 <endif>
278 <endif>
279
280 void <sym.name>::constructorHelper()
281 {
282     <inits; separator="\n">
283 <if(sym.hasSDAG)>
284     __sdag_init();
285
286 <endif>
287 }
288
289 <if(needsMigration)>
290 <sym.name>::<ident>(CkMigrateMessage *m)
291 {
292     constructorHelper();
293 }
294 <endif>
295
296 bool <sym.name>::_trace_registered = false;
297 void <sym.name>::_initTrace() {
298     #if _CHARJ_TRACE_ALL_METHODS || _CHARJ_TRACE_TRACED_METHODS
299     if (_trace_registered) return;
300     <sym.traceInitializers; separator="\n">
301     _trace_registered = true;
302     #endif
303 }
304 <endif>
305 >>
306
307 chareDeclaration_h(sym, ident, ext, csds, needsPupInit, needsMigration) ::=
308 <<
309 <chare_preamble_h(sym)>
310 #include "<ident>.decl.h"
311 <chareDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds, needsPupInit = needsPupInit, needsMigration = needsMigration)>
312 <chare_epilogue_h(sym)>
313 >>
314
315 chareDeclaration_h_cont(pds, sym, ident, ext, csds, needsPupInit, needsMigration) ::=
316 <<
317 <if(first(pds))>namespace <first(pds)>
318 {
319     <chareDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds, needsPupInit = needsPupInit, needsMigration = needsMigration)>
320 } // namespace <first(pds)>
321 <else>
322 <if(ext)>/* superclass: <ext> */<endif>
323 class <ident>: public CBase_<ident> {
324     <if(sym.hasSDAG)><ident>_SDAG_CODE<endif>
325     <csds; separator="\n">
326     <if(needsPupInit)>
327     private: void pupInitMethod();
328     <endif>
329     public: void pup(PUP::er& p);
330     <if(!sym.hasDefaultCtor)>
331     <if(sym.isMainChare)>
332     public: <ident>(CkArgMsg *msg);
333     <else>
334     public: <ident>();
335     <endif>
336     <endif>
337     protected: void constructorHelper();
338     <if(needsMigration)>
339     public: <ident>(CkMigrateMessage*);
340     <endif>
341     static bool _trace_registered;
342     void _initTrace();
343 };
344 <endif>
345 >>
346
347 chareDeclaration_ci(basename, sym, chareType, arrayDim, ident, ext, csds) ::=
348 <<
349 <if(sym.isMainChare)>main<endif>module <ident> {
350 <if(ext)>
351     extern module <ext>;
352 <endif>
353     <sym.Externs:{ext| extern module <ext>;
354 <if(sym.isMainChare)>
355 extern module <basename>_readonly;
356 <endif>
357     }>
358     <chareDeclaration_ci_cont(pds = sym.packageNames, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
359 }
360 >>
361
362
363 chareDeclaration_ci_cont(pds, sym, chareType, arrayDim, ident, ext, csds) ::=
364 <<
365 <if(first(pds))>namespace <first(pds)>
366 {
367     <chareDeclaration_ci_cont(pds = rest(pds), sym = sym, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
368 } // namespace <first(pds)>
369 <else>
370 <chareType><if(arrayDim)> [<arrayDim>]<endif> <ident><if(ext)> : <ext><endif> {
371     <csds; separator="\n">
372 };
373 <endif>
374 >>
375
376 funcMethodDecl_h(modl, gtpl, ty, id, fpl, adl, block) ::=
377 <<
378 <modl><ty><gtpl> <id><fpl><adl>;
379 >>
380
381
382 funcMethodDecl_ci(modl, gtpl, ty, id, fpl, adl, block) ::=
383 <<
384 <modl><ty><gtpl> <id><fpl><adl>;
385 >>
386
387
388 funcMethodDecl_sdag_ci(classSym, methodSym, modl, gtpl, ty, id, fpl, adl, block) ::=
389 <<
390 <modl><ty><gtpl> <id><fpl><adl><if(!block)>;<else>
391 {
392     /* FIXME: macros aren't allowed in sdag code, so tracing doesn't work right
393     #if _CHARJ_TRACE_ALL_METHODS<if(methodSym.isTraced)> || _CHARJ_TRACE_TRACED_METHODS<endif>
394     int _charj_method_trace_timer = CkWallTimer();
395     #endif
396     */
397     <block>
398     /*
399     #if _CHARJ_TRACE_ALL_METHODS<if(methodSym.isTraced)> || _CHARJ_TRACE_TRACED_METHODS<endif>
400     traceUserBracketEvent(<methodSym.traceID>, _charj_method_trace_timer, CkWallTimer());
401     #endif
402     */
403 };
404 <endif>
405 >>
406
407
408 funcMethodDecl_cc(classSym, methodSym, modl, gtpl, ty, id, fpl, adl, block) ::=
409 <<
410 <if(block)>
411 <modl><ty><gtpl> <classSym.Name>::<id><fpl><adl>
412 {
413     #if _CHARJ_TRACE_ALL_METHODS<if(methodSym.isTraced)> || _CHARJ_TRACE_TRACED_METHODS<endif>
414     int _charj_method_trace_timer = CkWallTimer();
415     #endif
416     <block>
417     #if _CHARJ_TRACE_ALL_METHODS<if(methodSym.isTraced)> || _CHARJ_TRACE_TRACED_METHODS<endif>
418     traceUserBracketEvent(<methodSym.traceID>, _charj_method_trace_timer, CkWallTimer());
419     #endif
420 }
421 <endif>
422 >>
423
424
425 ctorDecl_ci(modl, gtpl, id, fpl, block) ::=
426 <<
427 <modl><gtpl><id><fpl>;
428 >>
429
430
431 ctorDecl_h(modl, gtpl, id, fpl, block) ::=
432 <<
433 <modl><id><fpl>;
434 >>
435
436
437 ctorDecl_cc(modl, gtpl, id, fpl, block) ::=
438 <<
439 <modl><id>::<id><fpl>
440 <block>
441 >>
442
443
444 block_cc(bsl) ::=
445 <<
446 {
447     <bsl; separator="\n">
448 }
449
450 >>
451
452 block_atomic(s) ::=
453 <<
454 atomic {
455     <s; separator="\n">
456 }
457
458 >>
459
460 embed_cc(str, blk) ::=
461 <<
462 // begin embedded block: <str>
463 <blk>
464 // end embedded block: <str>
465 >>
466
467
468 class_var_decl(modl, type, declList) ::=
469 <<
470 <modl><type> <declList>;
471 >>
472
473
474 var_decl_list(var_decls) ::=
475 <<
476 <var_decls; separator=", ">
477 >>
478
479
480 var_decl_cc(id, initializer) ::=
481 <<
482 <id><if(initializer)> = <initializer><endif>
483 >>
484
485 var_decl_h(id, initializer) ::=
486 <<
487 <id>
488 >>
489
490 var_decl_ci(id, initializer) ::=
491 <<
492 <id><if(initializer)> = <initializer><endif>
493 >>
494
495 var_decl_id(id, domainExp) ::=
496 <<
497 <id><if(domainExp)>(<domainExp>)<endif>
498 >>
499
500
501 var_id_decl(id, adl) ::=
502 <<
503 <id><if(adl)> <adl><endif>
504 >>
505
506
507 mod_list_cc(accmods, localmods, charjmods, othermods) ::=
508 <<
509 <if(localmods)><localmods; separator=" "> <endif><if(othermods)><othermods; separator=" "> <endif>
510 >>
511
512 mod_list_h(accmods, localmods, charjmods, othermods) ::=
513 <<
514 <if(accmods)><accmods; separator=" ">: <endif><if(othermods)><othermods; separator=" "> <endif>
515 >>
516
517 mod_list_ci(accmods, localmods, charjmods, othermods) ::=
518 <<
519 <if(charjmods)><charjmods; separator=" "> <endif>
520 >>
521
522 local_var_decl(modList, type, declList, domainExps) ::=
523 <<
524 <if(modList)><modList> <endif><type> <declList>;
525 >>
526
527 local_mod_list(mods) ::= 
528 <<
529 <mods; separator=" ">
530 >>
531
532
533 simple_type(typeID, arrDeclList) ::=
534 <<
535 <typeID><arrDeclList>
536 >>
537
538
539 obj_type(typeID, arrDeclList) ::=
540 <<
541 <typeID><arrDeclList>
542 >>
543
544 proxy_type(typeID, arrDeclList) ::=
545 <<
546 CProxy_<typeID><arrDeclList>
547 >>
548
549 pointer_type(typeID, arrDeclList) ::=
550 <<
551 <typeID>*<arrDeclList>
552 >>
553
554 reference_type(typeID, arrDeclList) ::=
555 <<
556 <typeID>&<arrDeclList>
557 >>
558
559
560 typeIdent(typeID, generics) ::=
561 <<
562 <typeID><generics>
563 >>
564
565
566 generic_arg_list(types) ::=
567 <<
568 \<<types>\>
569 >>
570
571
572 formal_param_list(sdecl, vdecl) ::=
573 <<
574 <if(vdecl)>
575 (<sdecl; separator=", ">, <vdecl>)
576 <else>
577 (<sdecl; separator=", ">)
578 <endif>
579 >>
580
581
582 formal_param_decl(modList, type, declID) ::=
583 <<
584 <if(modList)><modList> <endif><type> <declID>
585 >>
586
587
588 assert(cond, msg) ::=
589 <<
590 <if(msg)>
591 CkAssert(<cond> && <msg>);
592 <else>
593 CkAssert(<cond>);
594 <endif>
595 >>
596
597
598 if(cond, then, else_) ::=
599 <<
600 if <cond> <then><if(else_)> else <else_><endif>
601 >>
602
603
604 for(initializer, cond, update, body) ::=
605 <<
606 for (<if(initializer)><initializer><else>;<endif> <cond>; <update; separator=", ">) <body>
607 >>
608
609 while(cond, body) ::=
610 <<
611 while <cond> <body>
612 >>
613
614 dowhile(cond, body) ::=
615 <<
616 do <body> while <cond>;
617 >>
618
619
620 switch(expr, labels) ::=
621 <<
622 switch <expr> {
623     <labels>
624 }
625 >>
626
627 return(val) ::=
628 <<
629 return<if(val)> <val><endif>;
630 >>
631
632 label(text, stmt) ::=
633 <<
634 <text>: <stmt>
635 >>
636
637 case(expr, block) ::=
638 <<
639 case <expr>: <block>
640 >>
641
642 method_call(primary, generic_types, args) ::=
643 <<
644 <if(generic_types)>
645 <primary>\<<generic_types>\>(<args>)
646 <else>
647 <primary>(<args>)
648 <endif>
649 >>
650
651
652 array_construction_with_init(array_decls, initializer) ::=
653 <<
654 <array_decls> = {<initializer>};
655 >>
656
657
658 array_construction(exprs, array_decls) ::=
659 <<
660 [<exprs; separator="][">]<array_decls>
661 >>
662
663
664 arguments(exprs) ::=
665 <<
666 <exprs; separator=", ">
667 >>
668
669 print(exprs) ::=
670 <<
671 <if(first(exprs))>cout <exprs : { n | \<\< <n> }>;<endif>
672 >>
673
674 println(exprs) ::=
675 <<
676 cout<if(first(exprs))> <exprs : { n | \<\< <n> }><else> <endif>\<\< endl;
677 >>
678
679 exit(expr) ::=
680 <<
681 <if(expr)>exit(<expr>)<else>exit(0)<endif>;
682 >>
683
684 exitall() ::=
685 <<
686 CkExit();
687 >>
688
689 range_constructor(range, others, len) ::=
690 <<
691 <if(range)>
692 Domain\<<len>\>(<range>)<if(others)>, <others; separator=", "><endif>
693 <else>
694 <endif>
695 >>