Charj: allow multiple type definitions per file
[charm.git] / src / langs / charj / src / charj / translator / Charj.stg
1 group Charj;
2
3 charjSource_ci(basename, pd, ids, tds, debug) ::=
4 <<
5
6 // interface for <basename>
7 <tds; separator="\n\n">
8
9 >>
10
11
12 charjSource_h(basename, pd, ids, tds, debug) ::=
13 <<
14 #ifndef __<basename>__
15 #define __<basename>__
16
17 /**************************************************************************
18  * WARNING                                                                *
19  **************************************************************************
20  * This is a machine generated header file.                               *
21  * It is not meant to be edited by hand and may be overwritten by charjc. *
22  **************************************************************************/
23
24 <ids>
25 <tds; separator="\n\n">
26
27 #endif // __<basename>__
28
29 >>
30
31
32 charjSource_cc(basename, pd, ids, tds, debug) ::=
33 <<
34 #include "<basename>.h"
35
36 <ids>
37 <tds; separator="\n\n">
38
39 >>
40
41 importDeclaration_cc_h(inc_id, use_id) ::=
42 <<
43 #include \<<inc_id>\>
44 using <use_id>;
45 >>
46
47 classExtends_ci(type) ::= "<type>"
48
49
50 classExtends_cc_h(type) ::= "#include \<<type>.h\>"
51
52
53 interfaceExtends(ts) ::=
54 <<
55 : public <ts; separator=", public ">
56 >>
57
58 type_preamble_h(sym) ::=
59 <<
60 <sym.Includes:{include| #include\<<include>\>
61 }>
62 <sym.Usings:{using| using <using>;
63 }>
64 <sym.MemberTypeNames:{name| class <name>;
65 }>
66 >>
67
68 classDeclaration_h(sym, ident, ext, csds) ::=
69 <<
70 <type_preamble_h(sym)>
71 <classDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
72 >>
73
74 classDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
75 <<
76 <if(first(pds))>namespace <first(pds)>
77 {
78     <classDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
79 } // namespace <first(pds)>
80 <else>
81 <if(ext)>
82 class <ident> : public <ext> {
83 <else>
84 class <ident> {
85 <endif>
86
87     <csds; separator="\n\n">
88 };
89 <endif>
90 >>
91
92
93 classDeclaration_cc(sym, ident, ext, csds) ::=
94 <<
95 <classDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
96 >>
97
98 classDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
99 <<
100 <if(first(pds))>namespace <first(pds)>
101 {
102     <classDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
103 } // namespace <first(pds)>
104 <else>
105 <csds; separator="\n\n">
106 <endif>
107 >>
108
109
110 chareDeclaration_cc(sym, ident, ext, csds) ::=
111 <<
112 #include "<ident>.decl.h"
113 <chareDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
114 #include "<ident>.def.h"
115 >>
116
117 chareDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
118 <<
119 <if(first(pds))>namespace <first(pds)>
120 {
121     <chareDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
122 } // namespace <first(pds)>
123 <else>
124 <csds; separator="\n\n">
125 <endif>
126 >>
127
128 chareDeclaration_h(sym, ident, ext, csds) ::=
129 <<
130 <type_preamble_h(sym)>
131 #include "<ident>.decl.h"
132 <chareDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
133 >>
134
135 chareDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
136 <<
137 <if(first(pds))>namespace <first(pds)>
138 {
139     <chareDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
140 } // namespace <first(pds)>
141 <else>
142 <if(ext)>/* superclass: <ext> */<endif>
143 class <ident>: public CBase_<ident> {
144     <csds; separator="\n">
145 };
146 <endif>
147 >>
148
149 chareDeclaration_ci(sym, chareType, arrayDim, ident, ext, csds) ::=
150 <<
151 module <ident> {
152 <if(ext)>
153     extern module <ext>;
154 <endif>
155     <chareDeclaration_ci_cont(pds = sym.packageNames, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
156 }
157 >>
158
159
160 chareDeclaration_ci_cont(pds, sym, chareType, arrayDim, ident, ext, csds) ::=
161 <<
162 <if(first(pds))>namespace <first(pds)>
163 {
164     <chareDeclaration_ci_cont(pds = rest(pds), sym = sym, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
165 } // namespace <first(pds)>
166 <else>
167 <chareType><if(arrayDim)> [<arrayDim>]<endif> <ident><if(ext)> : <ext><endif> {
168     <csds; separator="\n">
169 };
170 <endif>
171 >>
172
173 funcMethodDecl_h(modl, gtpl, ty, id, fpl, adl, block) ::=
174 <<
175 <if(first(modl))><modl; separator=" ">: <endif><ty><gtpl> <id><fpl><adl>;
176 >>
177
178
179 funcMethodDecl_ci(modl, gtpl, ty, id, fpl, adl, block) ::=
180 <<
181 entry <ty><gtpl> <id><fpl><adl>;
182 >>
183
184
185 funcMethodDecl_cc(sym, modl, gtpl, ty, id, fpl, adl, block) ::=
186 <<
187 <ty><gtpl> <sym.Name>::<id><fpl><adl>
188 <block>
189 >>
190
191
192 ctorDecl_ci(modl, gtpl, id, fpl, block) ::=
193 <<
194 entry void<gtpl> <id><fpl>;
195 >>
196
197
198 ctorDecl_h(modl, gtpl, id, fpl, block) ::=
199 <<
200 <if(modl)><modl; separator=" ">: <endif><id><fpl>;
201 >>
202
203
204 ctorDecl_cc(modl, gtpl, id, fpl, block) ::=
205 <<
206 <id>::<id><fpl>
207 <block>
208 >>
209
210
211 block_cc(bsl) ::=
212 <<
213 {
214     <bsl; separator="\n">
215 }
216 >>
217
218
219 embed_cc(str, blk) ::=
220 <<
221 // begin embedded block: <str>
222 <blk>
223 // end embedded block: <str>
224 >>
225
226
227 class_var_decl(modl, type, declList) ::=
228 <<
229 <if(modl)><modl>:<else>public:<endif> <type> <declList>;
230 >>
231
232
233 var_decl_list(var_decls) ::=
234 <<
235 <var_decls; separator=", ">
236 >>
237
238
239 var_decl(id, initializer) ::=
240 <<
241 <id><if(initializer)> = <initializer><endif>
242 >>
243
244
245 var_decl_id(id, array_decl_list) ::=
246 <<
247 <id><if(array_decl_list)> <array_decl_list><endif>
248 >>
249
250
251 var_id_decl(id, adl) ::=
252 <<
253 <id><if(adl)> <adl><endif>
254 >>
255
256
257 mod_list(mods) ::=
258 <<
259 <if(mods)><mods; separator=" "><endif>
260 >>
261
262
263 local_mod_list(mods) ::=
264 <<
265 <if(mods)><mods; separator=" "><endif>
266 >>
267
268
269 local_var_decl(modList, type, declList) ::=
270 <<
271 <if(modList)>
272 <modList> <type> <declList>;
273 <else>
274 <type> <declList>;
275 <endif>
276 >>
277
278
279 simple_type(typeID, arrDeclList) ::=
280 <<
281 <typeID><arrDeclList>
282 >>
283
284
285 obj_type(typeID, arrDeclList) ::=
286 <<
287 <typeID><arrDeclList>
288 >>
289
290 proxy_type(typeID, arrDeclList) ::=
291 <<
292 CProxy_<typeID><arrDeclList>
293 >>
294
295 pointer_type(typeID, arrDeclList) ::=
296 <<
297 <typeID>*<arrDeclList>
298 >>
299
300 reference_type(typeID, arrDeclList) ::=
301 <<
302 <typeID>&<arrDeclList>
303 >>
304
305
306 typeIdent(typeID, generics) ::=
307 <<
308 <typeID><generics>
309 >>
310
311
312 generic_arg_list(types) ::=
313 <<
314 \<<types>\>
315 >>
316
317
318 formal_param_list(sdecl, vdecl) ::=
319 <<
320 <if(vdecl)>
321 (<sdecl; separator=", ">, <vdecl>)
322 <else>
323 (<sdecl; separator=", ">)
324 <endif>
325 >>
326
327
328 formal_param_decl(modList, type, declID) ::=
329 <<
330 <if(modList)><modList> <endif><type> <declID>
331 >>
332
333
334 assert(cond, msg) ::=
335 <<
336 <if(msg)>
337 CkAssert(<cond> && <msg>);
338 <else>
339 CkAssert(<cond>);
340 <endif>
341 >>
342
343
344 if(cond, then, else_) ::=
345 <<
346 if <cond> <then><if(else_)> else <else_><endif>
347 >>
348
349
350 for(initializer, cond, update, body) ::=
351 <<
352 for (<if(initializer)><initializer><else>;<endif> <cond>; <update; separator=", ">) <body>
353 >>
354
355 while(cond, body) ::=
356 <<
357 while <cond> <body>
358 >>
359
360 dowhile(cond, body) ::=
361 <<
362 do <body> while <cond>;
363 >>
364
365
366 switch(expr, labels) ::=
367 <<
368 switch <expr> {
369     <labels>
370 }
371 >>
372
373 return(val) ::=
374 <<
375 return<if(val)> <val><endif>;
376 >>
377
378 label(text, stmt) ::=
379 <<
380 <text>: <stmt>
381 >>
382
383 case(expr, block) ::=
384 <<
385 case <expr>: <block>
386 >>
387
388 method_call(primary, generic_types, args) ::=
389 <<
390 <if(generic_types)>
391 <primary>\<<generic_types>\>(<args>)
392 <else>
393 <primary>(<args>)
394 <endif>
395 >>
396
397
398 array_construction_with_init(array_decls, initializer) ::=
399 <<
400 <array_decls> = {<initializer>};
401 >>
402
403
404 array_construction(exprs, array_decls) ::=
405 <<
406 [<exprs; separator="][">]<array_decls>
407 >>
408
409
410 arguments(exprs) ::=
411 <<
412 <exprs; separator=", ">
413 >>
414
415