55d88a7d62badc1148ba904839a06f624e5ae2d6
[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) ::=
125 <<
126 <type_preamble_h(sym)>
127 <classDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
128 <type_epilogue_h(sym)>
129 >>
130
131 classDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
132 <<
133 <if(first(pds))>namespace <first(pds)>
134 {
135     <classDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
136 } // namespace <first(pds)>
137 <else>
138 <if(ext)>
139 class <ident> : public <ext> {
140 <else>
141 class <ident> {
142 <endif>
143
144     <csds; separator="\n\n">
145 };
146 <endif>
147 >>
148
149
150 classDeclaration_cc(sym, ident, ext, csds) ::=
151 <<
152 <classDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
153 >>
154
155 classDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
156 <<
157 <if(first(pds))>namespace <first(pds)>
158 {
159     <classDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
160 } // namespace <first(pds)>
161 <else>
162 <csds; separator="\n\n">
163 <endif>
164 >>
165
166
167 chareDeclaration_cc(sym, ident, ext, csds) ::=
168 <<
169 #include "<ident>.decl.h"
170 <chareDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
171 #include "<ident>.def.h"
172 >>
173
174 chareDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
175 <<
176 <if(first(pds))>namespace <first(pds)>
177 {
178     <chareDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
179 } // namespace <first(pds)>
180 <else>
181 <csds; separator="\n\n">
182 <endif>
183 >>
184
185 chareDeclaration_h(sym, ident, ext, csds) ::=
186 <<
187 <chare_preamble_h(sym)>
188 #include "<ident>.decl.h"
189 <chareDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
190 <chare_epilogue_h(sym)>
191 >>
192
193 chareDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
194 <<
195 <if(first(pds))>namespace <first(pds)>
196 {
197     <chareDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
198 } // namespace <first(pds)>
199 <else>
200 <if(ext)>/* superclass: <ext> */<endif>
201 class <ident>: public CBase_<ident> {
202     <csds; separator="\n">
203 };
204 <endif>
205 >>
206
207 chareDeclaration_ci(sym, chareType, arrayDim, ident, ext, csds) ::=
208 <<
209 <if(sym.isMainChare)>main<endif>module <ident> {
210 <if(ext)>
211     extern module <ext>;
212 <endif>
213     <sym.Externs:{ext| extern module <ext>;
214     }>
215     <chareDeclaration_ci_cont(pds = sym.packageNames, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
216 }
217 >>
218
219
220 chareDeclaration_ci_cont(pds, sym, chareType, arrayDim, ident, ext, csds) ::=
221 <<
222 <if(first(pds))>namespace <first(pds)>
223 {
224     <chareDeclaration_ci_cont(pds = rest(pds), sym = sym, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
225 } // namespace <first(pds)>
226 <else>
227 <chareType><if(arrayDim)> [<arrayDim>]<endif> <ident><if(ext)> : <ext><endif> {
228     <csds; separator="\n">
229 };
230 <endif>
231 >>
232
233 funcMethodDecl_h(modl, gtpl, ty, id, fpl, adl, block) ::=
234 <<
235 <modl><ty><gtpl> <id><fpl><adl>;
236 >>
237
238
239 funcMethodDecl_ci(modl, gtpl, ty, id, fpl, adl, block) ::=
240 <<
241 <modl><ty><gtpl> <id><fpl><adl>;
242 >>
243
244
245 funcMethodDecl_cc(sym, modl, gtpl, ty, id, fpl, adl, block) ::=
246 <<
247 <modl><ty><gtpl> <sym.Name>::<id><fpl><adl>
248 <block>
249 >>
250
251
252 ctorDecl_ci(modl, gtpl, id, fpl, block) ::=
253 <<
254 <modl>void<gtpl> <id><fpl>;
255 >>
256
257
258 ctorDecl_h(modl, gtpl, id, fpl, block) ::=
259 <<
260 <modl><id><fpl>;
261 >>
262
263
264 ctorDecl_cc(modl, gtpl, id, fpl, block) ::=
265 <<
266 <modl><id>::<id><fpl>
267 <block>
268 >>
269
270
271 block_cc(bsl) ::=
272 <<
273 {
274     <bsl; separator="\n">
275 }
276 >>
277
278
279 embed_cc(str, blk) ::=
280 <<
281 // begin embedded block: <str>
282 <blk>
283 // end embedded block: <str>
284 >>
285
286
287 class_var_decl(modl, type, declList) ::=
288 <<
289 <modl><type> <declList>;
290 >>
291
292
293 var_decl_list(var_decls) ::=
294 <<
295 <var_decls; separator=", ">
296 >>
297
298
299 var_decl(id, initializer) ::=
300 <<
301 <id><if(initializer)> = <initializer><endif>
302 >>
303
304
305 var_decl_id(id, array_decl_list) ::=
306 <<
307 <id><if(array_decl_list)> <array_decl_list><endif>
308 >>
309
310
311 var_id_decl(id, adl) ::=
312 <<
313 <id><if(adl)> <adl><endif>
314 >>
315
316
317 mod_list_cc(accmods, localmods, charjmods, othermods) ::=
318 <<
319 <if(localmods)><localmods; separator=" "> <endif><if(othermods)><othermods; separator=" "> <endif>
320 >>
321
322 mod_list_h(accmods, localmods, charjmods, othermods) ::=
323 <<
324 <if(accmods)><accmods; separator=" ">: <endif><if(othermods)><othermods; separator=" "> <endif>
325 >>
326
327 mod_list_ci(accmods, localmods, charjmods, othermods) ::=
328 <<
329 <if(charjmods)><charjmods; separator=" "> <endif>
330 >>
331
332 local_var_decl(modList, type, declList) ::=
333 <<
334 <if(modList)><modList> <endif><type> <declList>;
335 >>
336
337 local_mod_list(mods) ::= <<
338 <mods; separator=" ">
339 >>
340
341
342 simple_type(typeID, arrDeclList) ::=
343 <<
344 <typeID><arrDeclList>
345 >>
346
347
348 obj_type(typeID, arrDeclList) ::=
349 <<
350 <typeID><arrDeclList>
351 >>
352
353 proxy_type(typeID, arrDeclList) ::=
354 <<
355 CProxy_<typeID><arrDeclList>
356 >>
357
358 pointer_type(typeID, arrDeclList) ::=
359 <<
360 <typeID>*<arrDeclList>
361 >>
362
363 reference_type(typeID, arrDeclList) ::=
364 <<
365 <typeID>&<arrDeclList>
366 >>
367
368
369 typeIdent(typeID, generics) ::=
370 <<
371 <typeID><generics>
372 >>
373
374
375 generic_arg_list(types) ::=
376 <<
377 \<<types>\>
378 >>
379
380
381 formal_param_list(sdecl, vdecl) ::=
382 <<
383 <if(vdecl)>
384 (<sdecl; separator=", ">, <vdecl>)
385 <else>
386 (<sdecl; separator=", ">)
387 <endif>
388 >>
389
390
391 formal_param_decl(modList, type, declID) ::=
392 <<
393 <if(modList)><modList> <endif><type> <declID>
394 >>
395
396
397 assert(cond, msg) ::=
398 <<
399 <if(msg)>
400 CkAssert(<cond> && <msg>);
401 <else>
402 CkAssert(<cond>);
403 <endif>
404 >>
405
406
407 if(cond, then, else_) ::=
408 <<
409 if <cond> <then><if(else_)> else <else_><endif>
410 >>
411
412
413 for(initializer, cond, update, body) ::=
414 <<
415 for (<if(initializer)><initializer><else>;<endif> <cond>; <update; separator=", ">) <body>
416 >>
417
418 while(cond, body) ::=
419 <<
420 while <cond> <body>
421 >>
422
423 dowhile(cond, body) ::=
424 <<
425 do <body> while <cond>;
426 >>
427
428
429 switch(expr, labels) ::=
430 <<
431 switch <expr> {
432     <labels>
433 }
434 >>
435
436 return(val) ::=
437 <<
438 return<if(val)> <val><endif>;
439 >>
440
441 label(text, stmt) ::=
442 <<
443 <text>: <stmt>
444 >>
445
446 case(expr, block) ::=
447 <<
448 case <expr>: <block>
449 >>
450
451 method_call(primary, generic_types, args) ::=
452 <<
453 <if(generic_types)>
454 <primary>\<<generic_types>\>(<args>)
455 <else>
456 <primary>(<args>)
457 <endif>
458 >>
459
460
461 array_construction_with_init(array_decls, initializer) ::=
462 <<
463 <array_decls> = {<initializer>};
464 >>
465
466
467 array_construction(exprs, array_decls) ::=
468 <<
469 [<exprs; separator="][">]<array_decls>
470 >>
471
472
473 arguments(exprs) ::=
474 <<
475 <exprs; separator=", ">
476 >>
477
478 print(exprs) ::=
479 <<
480 <if(first(exprs))>cout <exprs : { n | \<\< <n> }>;<endif>
481 >>
482
483 println(exprs) ::=
484 <<
485 cout<if(first(exprs))> <exprs : { n | \<\< <n> }><else> <endif>\<\< endl;
486 >>
487
488