Merged arrays into Charj mainline.
[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 <if(ros)>
10
11 module <basename>_readonly {
12     <ros; separator="\n">
13 }
14 <endif>
15 >>
16
17
18 charjSource_h(basename, pd, imports, types, ros, debug) ::=
19 <<
20 #ifndef __<basename>__
21 #define __<basename>__
22
23 /**************************************************************************
24  * WARNING                                                                *
25  **************************************************************************
26  * This is a machine generated header file.                               *
27  * It is not meant to be edited by hand and may be overwritten by charjc. *
28  **************************************************************************/
29
30 <imports; separator="\n">
31 <types; separator="\n\n">
32 <if(ros)>
33 /* Readonly variables */
34 <readonlys_h(pds = pd, ros = ros)>
35 #include "<basename>_readonly.decl.h"
36 <endif>
37
38
39 #endif // __<basename>__
40
41
42 >>
43
44 charjSource_cc(basename, pd, imports, types, ros, debug) ::=
45 <<
46 #include "<basename>.h"
47
48 <imports; separator="\n">
49 <types; separator="\n\n">
50 <if(ros)>
51
52 /* Readonly variable support */
53 <readonlys_cc(pds = pd, ros = ros, basename = basename)>
54 <endif>
55
56
57 >>
58
59 readonlys_h(pds, ros) ::=
60 <<
61 <if(first(pds))>namespace <first(pds)>
62 {
63     <readonlys_h(pds = rest(pds), ros = ros)>
64 } // namespace <first(pds)>
65 <else>
66 <ros; separator="\n">
67 <endif>
68 >>
69
70 readonlys_cc(pds, ros, basename) ::=
71 <<
72 <if(first(pds))>namespace <first(pds)>
73 {
74     <readonlys_cc(pds = rest(pds), ros = ros, basename = basename)>
75 } // namespace <first(pds)>
76 <else>
77 <ros; separator="\n">
78 #include "<basename>_readonly.def.h"
79 <endif>
80
81 >>
82
83 importDeclaration_cc_h(inc_id, use_id) ::=
84 <<
85 #include \<<inc_id>\>
86 using <use_id>;
87 >>
88
89 classExtends_ci(type) ::= "<type>"
90
91
92 classExtends_cc_h(type) ::= "#include \<<type>.h\>"
93
94
95 interfaceExtends(ts) ::=
96 <<
97 : public <ts; separator=", public ">
98 >>
99
100 type_preamble_h(sym) ::=
101 <<
102 <sym.Includes:{include| #include \<<include>\>
103 }>
104 <sym.Usings:{using| using <using>;
105 }>
106 <sym.MemberTypeNames:{name| class <name>;
107 }>
108 >>
109
110 chare_preamble_h(sym) ::=
111 <<
112 <type_preamble_h(sym)>
113 >>
114
115 type_epilogue_h(sym) ::=
116 <<
117 >>
118
119 chare_epilogue_h(sym) ::=
120 <<
121 <type_epilogue_h(sym)>
122 >>
123
124 classDeclaration_h(sym, ident, ext, csds, tident) ::=
125 <<
126 <type_preamble_h(sym)>
127 <if(tident)>
128 <templateDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds, tident = tident)>
129 <else>
130 <classDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
131 <endif>
132 <type_epilogue_h(sym)>
133 >>
134
135 classDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
136 <<
137 <if(first(pds))>namespace <first(pds)>
138 {
139     <classDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
140 } // namespace <first(pds)>
141 <else>
142 <if(ext)>
143 class <ident> : public <ext> {
144 <else>
145 class <ident> {
146 <endif>
147
148     <csds; separator="\n\n">
149 };
150 <endif>
151 >>
152
153 templateDeclaration_h(pds, sym, ident, ext, csds, tident) ::=
154 <<
155 template \<class <tident; separator=", class ">\>
156 <classDeclaration_h_cont(pds=pds, sym=sym, ident=ident, ext=ext, csds=csds)>
157 >>
158
159 classDeclaration_cc(sym, ident, ext, csds) ::=
160 <<
161 <classDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
162 >>
163
164 classDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
165 <<
166 <if(first(pds))>namespace <first(pds)>
167 {
168     <classDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
169 } // namespace <first(pds)>
170 <else>
171 <csds; separator="\n\n">
172 <endif>
173 >>
174
175
176 chareDeclaration_cc(sym, ident, ext, csds) ::=
177 <<
178 #include "<ident>.decl.h"
179 <chareDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
180 #include "<ident>.def.h"
181 >>
182
183 chareDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
184 <<
185 <if(first(pds))>namespace <first(pds)>
186 {
187     <chareDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
188 } // namespace <first(pds)>
189 <else>
190 <csds; separator="\n\n">
191 <endif>
192 >>
193
194 chareDeclaration_h(sym, ident, ext, csds) ::=
195 <<
196 <chare_preamble_h(sym)>
197 #include "<ident>.decl.h"
198 <chareDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
199 <chare_epilogue_h(sym)>
200 >>
201
202 chareDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
203 <<
204 <if(first(pds))>namespace <first(pds)>
205 {
206     <chareDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
207 } // namespace <first(pds)>
208 <else>
209 <if(ext)>/* superclass: <ext> */<endif>
210 class <ident>: public CBase_<ident> {
211     <csds; separator="\n">
212 };
213 <endif>
214 >>
215
216 chareDeclaration_ci(sym, chareType, arrayDim, ident, ext, csds) ::=
217 <<
218 <if(sym.isMainChare)>main<endif>module <ident> {
219 <if(ext)>
220     extern module <ext>;
221 <endif>
222     <sym.Externs:{ext| extern module <ext>;
223     }>
224     <chareDeclaration_ci_cont(pds = sym.packageNames, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
225 }
226 >>
227
228
229 chareDeclaration_ci_cont(pds, sym, chareType, arrayDim, ident, ext, csds) ::=
230 <<
231 <if(first(pds))>namespace <first(pds)>
232 {
233     <chareDeclaration_ci_cont(pds = rest(pds), sym = sym, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
234 } // namespace <first(pds)>
235 <else>
236 <chareType><if(arrayDim)> [<arrayDim>]<endif> <ident><if(ext)> : <ext><endif> {
237     <csds; separator="\n">
238 };
239 <endif>
240 >>
241
242 funcMethodDecl_h(modl, gtpl, ty, id, fpl, adl, block) ::=
243 <<
244 <modl><ty><gtpl> <id><fpl><adl>;
245 >>
246
247
248 funcMethodDecl_ci(modl, gtpl, ty, id, fpl, adl, block) ::=
249 <<
250 <modl><ty><gtpl> <id><fpl><adl>;
251 >>
252
253
254 funcMethodDecl_cc(sym, modl, gtpl, ty, id, fpl, adl, block) ::=
255 <<
256 <modl><ty><gtpl> <sym.Name>::<id><fpl><adl>
257 <block>
258 >>
259
260
261 ctorDecl_ci(modl, gtpl, id, fpl, block) ::=
262 <<
263 <modl>void<gtpl> <id><fpl>;
264 >>
265
266
267 ctorDecl_h(modl, gtpl, id, fpl, block) ::=
268 <<
269 <modl><id><fpl>;
270 >>
271
272
273 ctorDecl_cc(modl, gtpl, id, fpl, block) ::=
274 <<
275 <modl><id>::<id><fpl>
276 <block>
277 >>
278
279
280 block_cc(bsl) ::=
281 <<
282 {
283     <bsl; separator="\n">
284 }
285 >>
286
287
288 embed_cc(str, blk) ::=
289 <<
290 // begin embedded block: <str>
291 <blk>
292 // end embedded block: <str>
293 >>
294
295
296 class_var_decl(modl, type, declList) ::=
297 <<
298 <modl><type> <declList>;
299 >>
300
301
302 var_decl_list(var_decls) ::=
303 <<
304 <var_decls; separator=", ">
305 >>
306
307
308 var_decl_cc(id, initializer) ::=
309 <<
310 <id><if(initializer)> = <initializer><endif>
311 >>
312
313 var_decl_h(id, initializer) ::=
314 <<
315 <id>
316 >>
317
318 var_decl_ci(id, initializer) ::=
319 <<
320 <id><if(initializer)> = <initializer><endif>
321 >>
322
323 var_decl_id(id, domainExp) ::=
324 <<
325 <id><if(domainExp)>(<domainExp>)<endif>
326 >>
327
328
329 var_id_decl(id, adl) ::=
330 <<
331 <id><if(adl)> <adl><endif>
332 >>
333
334
335 mod_list_cc(accmods, localmods, charjmods, othermods) ::=
336 <<
337 <if(localmods)><localmods; separator=" "> <endif><if(othermods)><othermods; separator=" "> <endif>
338 >>
339
340 mod_list_h(accmods, localmods, charjmods, othermods) ::=
341 <<
342 <if(accmods)><accmods; separator=" ">: <endif><if(othermods)><othermods; separator=" "> <endif>
343 >>
344
345 mod_list_ci(accmods, localmods, charjmods, othermods) ::=
346 <<
347 <if(charjmods)><charjmods; separator=" "> <endif>
348 >>
349
350 local_var_decl(modList, type, declList, domainExps) ::=
351 <<
352 <if(modList)><modList> <endif><type> <declList>;
353 >>
354
355 local_mod_list(mods) ::= 
356 <<
357 <mods; separator=" ">
358 >>
359
360
361 simple_type(typeID, arrDeclList) ::=
362 <<
363 <typeID><arrDeclList>
364 >>
365
366
367 obj_type(typeID, arrDeclList) ::=
368 <<
369 <typeID><arrDeclList>
370 >>
371
372 proxy_type(typeID, arrDeclList) ::=
373 <<
374 CProxy_<typeID><arrDeclList>
375 >>
376
377 pointer_type(typeID, arrDeclList) ::=
378 <<
379 <typeID>*<arrDeclList>
380 >>
381
382 reference_type(typeID, arrDeclList) ::=
383 <<
384 <typeID>&<arrDeclList>
385 >>
386
387
388 typeIdent(typeID, generics) ::=
389 <<
390 <typeID><generics>
391 >>
392
393
394 generic_arg_list(types) ::=
395 <<
396 \<<types>\>
397 >>
398
399
400 formal_param_list(sdecl, vdecl) ::=
401 <<
402 <if(vdecl)>
403 (<sdecl; separator=", ">, <vdecl>)
404 <else>
405 (<sdecl; separator=", ">)
406 <endif>
407 >>
408
409
410 formal_param_decl(modList, type, declID) ::=
411 <<
412 <if(modList)><modList> <endif><type> <declID>
413 >>
414
415
416 assert(cond, msg) ::=
417 <<
418 <if(msg)>
419 CkAssert(<cond> && <msg>);
420 <else>
421 CkAssert(<cond>);
422 <endif>
423 >>
424
425
426 if(cond, then, else_) ::=
427 <<
428 if <cond> <then><if(else_)> else <else_><endif>
429 >>
430
431
432 for(initializer, cond, update, body) ::=
433 <<
434 for (<if(initializer)><initializer><else>;<endif> <cond>; <update; separator=", ">) <body>
435 >>
436
437 while(cond, body) ::=
438 <<
439 while <cond> <body>
440 >>
441
442 dowhile(cond, body) ::=
443 <<
444 do <body> while <cond>;
445 >>
446
447
448 switch(expr, labels) ::=
449 <<
450 switch <expr> {
451     <labels>
452 }
453 >>
454
455 return(val) ::=
456 <<
457 return<if(val)> <val><endif>;
458 >>
459
460 label(text, stmt) ::=
461 <<
462 <text>: <stmt>
463 >>
464
465 case(expr, block) ::=
466 <<
467 case <expr>: <block>
468 >>
469
470 method_call(primary, generic_types, args) ::=
471 <<
472 <if(generic_types)>
473 <primary>\<<generic_types>\>(<args>)
474 <else>
475 <primary>(<args>)
476 <endif>
477 >>
478
479
480 array_construction_with_init(array_decls, initializer) ::=
481 <<
482 <array_decls> = {<initializer>};
483 >>
484
485
486 array_construction(exprs, array_decls) ::=
487 <<
488 [<exprs; separator="][">]<array_decls>
489 >>
490
491
492 arguments(exprs) ::=
493 <<
494 <exprs; separator=", ">
495 >>
496
497 print(exprs) ::=
498 <<
499 <if(first(exprs))>cout <exprs : { n | \<\< <n> }>;<endif>
500 >>
501
502 println(exprs) ::=
503 <<
504 cout<if(first(exprs))> <exprs : { n | \<\< <n> }><else> <endif>\<\< endl;
505 >>
506
507 exit(expr) ::=
508 <<
509 <if(expr)>exit(<expr>)<else>exit(0)<endif>;
510 >>
511
512 exitall() ::=
513 <<
514 CkExit();
515 >>
516
517 range_constructor(range, others, len) ::=
518 <<
519 <if(range)>
520 Domain\<<len>\>(<range>)<if(others)>, <others; separator=", "><endif>
521 <else>
522 <endif>
523 >>