2348c79f85477e42bb24da582c2c59f7efae5baa
[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 block_sdag_ci(bsl) ::=
452 <<
453 atomic {
454     <bsl; separator="\n">
455 }
456 >>
457
458
459 embed_cc(str, blk) ::=
460 <<
461 // begin embedded block: <str>
462 <blk>
463 // end embedded block: <str>
464 >>
465
466
467 class_var_decl(modl, type, declList) ::=
468 <<
469 <modl><type> <declList>;
470 >>
471
472
473 var_decl_list(var_decls) ::=
474 <<
475 <var_decls; separator=", ">
476 >>
477
478
479 var_decl_cc(id, initializer) ::=
480 <<
481 <id><if(initializer)> = <initializer><endif>
482 >>
483
484 var_decl_h(id, initializer) ::=
485 <<
486 <id>
487 >>
488
489 var_decl_ci(id, initializer) ::=
490 <<
491 <id><if(initializer)> = <initializer><endif>
492 >>
493
494 var_decl_id(id, domainExp) ::=
495 <<
496 <id><if(domainExp)>(<domainExp>)<endif>
497 >>
498
499
500 var_id_decl(id, adl) ::=
501 <<
502 <id><if(adl)> <adl><endif>
503 >>
504
505
506 mod_list_cc(accmods, localmods, charjmods, othermods) ::=
507 <<
508 <if(localmods)><localmods; separator=" "> <endif><if(othermods)><othermods; separator=" "> <endif>
509 >>
510
511 mod_list_h(accmods, localmods, charjmods, othermods) ::=
512 <<
513 <if(accmods)><accmods; separator=" ">: <endif><if(othermods)><othermods; separator=" "> <endif>
514 >>
515
516 mod_list_ci(accmods, localmods, charjmods, othermods) ::=
517 <<
518 <if(charjmods)><charjmods; separator=" "> <endif>
519 >>
520
521 local_var_decl(modList, type, declList, domainExps) ::=
522 <<
523 <if(modList)><modList> <endif><type> <declList>;
524 >>
525
526 local_mod_list(mods) ::= 
527 <<
528 <mods; separator=" ">
529 >>
530
531
532 simple_type(typeID, arrDeclList) ::=
533 <<
534 <typeID><arrDeclList>
535 >>
536
537
538 obj_type(typeID, arrDeclList) ::=
539 <<
540 <typeID><arrDeclList>
541 >>
542
543 proxy_type(typeID, arrDeclList) ::=
544 <<
545 CProxy_<typeID><arrDeclList>
546 >>
547
548 pointer_type(typeID, arrDeclList) ::=
549 <<
550 <typeID>*<arrDeclList>
551 >>
552
553 reference_type(typeID, arrDeclList) ::=
554 <<
555 <typeID>&<arrDeclList>
556 >>
557
558
559 typeIdent(typeID, generics) ::=
560 <<
561 <typeID><generics>
562 >>
563
564
565 generic_arg_list(types) ::=
566 <<
567 \<<types>\>
568 >>
569
570
571 formal_param_list(sdecl, vdecl) ::=
572 <<
573 <if(vdecl)>
574 (<sdecl; separator=", ">, <vdecl>)
575 <else>
576 (<sdecl; separator=", ">)
577 <endif>
578 >>
579
580
581 formal_param_decl(modList, type, declID) ::=
582 <<
583 <if(modList)><modList> <endif><type> <declID>
584 >>
585
586
587 assert(cond, msg) ::=
588 <<
589 <if(msg)>
590 CkAssert(<cond> && <msg>);
591 <else>
592 CkAssert(<cond>);
593 <endif>
594 >>
595
596
597 if(cond, then, else_) ::=
598 <<
599 if <cond> <then><if(else_)> else <else_><endif>
600 >>
601
602
603 for(initializer, cond, update, body) ::=
604 <<
605 for (<if(initializer)><initializer><else>;<endif> <cond>; <update; separator=", ">) <body>
606 >>
607
608 while(cond, body) ::=
609 <<
610 while <cond> <body>
611 >>
612
613 dowhile(cond, body) ::=
614 <<
615 do <body> while <cond>;
616 >>
617
618
619 switch(expr, labels) ::=
620 <<
621 switch <expr> {
622     <labels>
623 }
624 >>
625
626 return(val) ::=
627 <<
628 return<if(val)> <val><endif>;
629 >>
630
631 label(text, stmt) ::=
632 <<
633 <text>: <stmt>
634 >>
635
636 case(expr, block) ::=
637 <<
638 case <expr>: <block>
639 >>
640
641 method_call(primary, generic_types, args) ::=
642 <<
643 <if(generic_types)>
644 <primary>\<<generic_types>\>(<args>)
645 <else>
646 <primary>(<args>)
647 <endif>
648 >>
649
650
651 array_construction_with_init(array_decls, initializer) ::=
652 <<
653 <array_decls> = {<initializer>};
654 >>
655
656
657 array_construction(exprs, array_decls) ::=
658 <<
659 [<exprs; separator="][">]<array_decls>
660 >>
661
662
663 arguments(exprs) ::=
664 <<
665 <exprs; separator=", ">
666 >>
667
668 print(exprs) ::=
669 <<
670 <if(first(exprs))>cout <exprs : { n | \<\< <n> }>;<endif>
671 >>
672
673 println(exprs) ::=
674 <<
675 cout<if(first(exprs))> <exprs : { n | \<\< <n> }><else> <endif>\<\< endl;
676 >>
677
678 exit(expr) ::=
679 <<
680 <if(expr)>exit(<expr>)<else>exit(0)<endif>;
681 >>
682
683 exitall() ::=
684 <<
685 CkExit();
686 >>
687
688 range_constructor(range, others, len) ::=
689 <<
690 <if(range)>
691 Domain\<<len>\>(<range>)<if(others)>, <others; separator=", "><endif>
692 <else>
693 <endif>
694 >>