Added separate cc/ci emitters, modified driver, added antlr3.1 option
[charm.git] / src / langs / charj / src / charj / translator / CharjCCEmitter.g
1 /**
2  * ANTLR (v3) Tree Parser for the Charj Language
3  */
4
5 tree grammar CharjCCEmitter;
6
7 options {
8     backtrack = true; 
9     memoize = true;
10     tokenVocab = Charj;
11     ASTLabelType = CommonTree;
12     output = template;
13     rewrite = true;
14 }
15
16
17 @treeparser::header {
18 package charj.translator;
19 }
20
21 @treeparser::members {
22     
23     boolean mMessageCollectionEnabled = false;
24     private boolean mHasErrors = false;
25     List<String> mMessages;
26
27     /**
28      *  Switches error message collection on or off.
29      *
30      *  The standard destination for parser error messages is <code>System.err</code>.
31      *  However, if <code>true</code> gets passed to this method this default
32      *  behaviour will be switched off and all error messages will be collected
33      *  instead of written to anywhere.
34      *
35      *  The default value is <code>false</code>.
36      *
37      *  @param pNewState  <code>true</code> if error messages should be collected.
38      */
39     public void enableErrorMessageCollection(boolean pNewState) {
40         mMessageCollectionEnabled = pNewState;
41         if (mMessages == null && mMessageCollectionEnabled) {
42             mMessages = new ArrayList<String>();
43         }
44     }
45     
46     /**
47      *  Collects an error message or passes the error message to <code>
48      *  super.emitErrorMessage(...)</code>.
49      *
50      *  The actual behaviour depends on whether collecting error messages
51      *  has been enabled or not.
52      *
53      *  @param pMessage  The error message.
54      */
55      @Override
56     public void emitErrorMessage(String pMessage) {
57         if (mMessageCollectionEnabled) {
58             mMessages.add(pMessage);
59         } else {
60             super.emitErrorMessage(pMessage);
61         }
62     }
63     
64     /**
65      *  Returns collected error messages.
66      *
67      *  @return  A list holding collected error messages or <code>null</code> if
68      *           collecting error messages hasn't been enabled. Of course, this
69      *           list may be empty if no error message has been emited.
70      */
71     public List<String> getMessages() {
72         return mMessages;
73     }
74     
75     /**
76      *  Tells if parsing a Charj source has caused any error messages.
77      *
78      *  @return  <code>true</code> if parsing a Charj source has caused at 
79      *           least one error message.
80      */
81     public boolean hasErrors() {
82         return mHasErrors;
83     }
84 }
85
86 // Starting point for parsing a Charj file.
87 charjSource
88     :   ^(CHARJ_SOURCE packageDeclaration? importDeclaration* (ts+=typeDeclaration)*)
89         -> template(allText={$text}, types={$ts}) <<
90         <allText>
91         >>
92     ;
93
94 packageDeclaration
95     :   ^(PACKAGE qualifiedIdentifier)  
96     ;
97     
98 importDeclaration
99     :   ^(IMPORT STATIC? qualifiedIdentifier DOTSTAR?)
100     ;
101     
102 typeDeclaration
103     :   ^(CLASS modifierList IDENT genericTypeParameterList? classExtendsClause? implementsClause? classTopLevelScope) -> template(t={$text}) "<t>"
104     |   ^(INTERFACE modifierList IDENT genericTypeParameterList? interfaceExtendsClause? interfaceTopLevelScope)
105     |   ^(ENUM modifierList IDENT implementsClause? enumTopLevelScope)
106     ;
107
108
109 classExtendsClause
110     :   ^(EXTENDS_CLAUSE t=type) 
111         -> classExtends(type={$t.st})
112     ;   
113
114 interfaceExtendsClause 
115     :   ^(EXTENDS_CLAUSE (typeList+=type)+) 
116         -> interfaceExtends(ts={$typeList})
117     ;   
118     
119 implementsClause
120     :   ^(IMPLEMENTS_CLAUSE type+)
121     ;
122         
123 genericTypeParameterList
124     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
125     ;
126
127 genericTypeParameter
128     :   ^(IDENT bound?)
129     ;
130         
131 bound
132     :   ^(EXTENDS_BOUND_LIST type+)
133     ;
134
135 enumTopLevelScope
136     :   ^(ENUM_TOP_LEVEL_SCOPE enumConstant+ classTopLevelScope?)
137     ;
138     
139 enumConstant
140     :   ^(IDENT arguments? classTopLevelScope?)
141     ;
142     
143     
144 classTopLevelScope
145     :   ^(CLASS_TOP_LEVEL_SCOPE (csd+=classScopeDeclarations)*) 
146         -> classTopLevelScope(classScopeDeclarations={$csd})
147     ;
148     
149 classScopeDeclarations
150     :   ^(CLASS_INSTANCE_INITIALIZER block)
151     |   ^(CLASS_STATIC_INITIALIZER block)
152     |   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause? block?)
153     |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block?)
154     |   ^(VAR_DECLARATION modifierList type variableDeclaratorList)
155     |   ^(CONSTRUCTOR_DECL modifierList genericTypeParameterList? formalParameterList throwsClause? block)
156     |   typeDeclaration
157     ;
158     
159 interfaceTopLevelScope
160     :   ^(INTERFACE_TOP_LEVEL_SCOPE interfaceScopeDeclarations*)
161     ;
162     
163 interfaceScopeDeclarations
164     :   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
165     |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
166         // Interface constant declarations have been switched to variable
167         // declarations by Charj.g; the parser has already checked that
168         // there's an obligatory initializer.
169     |   ^(VAR_DECLARATION modifierList type variableDeclaratorList)
170     |   typeDeclaration
171     ;
172
173 variableDeclaratorList
174     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
175     ;
176
177 variableDeclarator
178     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
179     ;
180     
181 variableDeclaratorId
182     :   ^(IDENT arrayDeclaratorList?)
183     ;
184
185 variableInitializer
186     :   arrayInitializer
187     |   expression
188     ;
189
190 arrayDeclarator
191     :   LBRACK RBRACK
192     ;
193
194 arrayDeclaratorList
195     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
196     ;
197     
198 arrayInitializer
199     :   ^(ARRAY_INITIALIZER variableInitializer*)
200     ;
201
202 throwsClause
203     :   ^(THROWS_CLAUSE qualifiedIdentifier+)
204     ;
205
206 modifierList
207     :   ^(MODIFIER_LIST modifier*)
208     ;
209
210 modifier
211     :   PUBLIC
212     |   PROTECTED
213     |   PRIVATE
214     |   STATIC
215     |   ABSTRACT
216     |   NATIVE
217     |   SYNCHRONIZED
218     |   TRANSIENT
219     |   VOLATILE
220     |   localModifier
221     ;
222
223 localModifierList
224     :   ^(LOCAL_MODIFIER_LIST localModifier*)
225     ;
226
227 localModifier
228     :   FINAL
229     ;
230
231 type
232     :   ^(TYPE (primitiveType | qualifiedTypeIdent) arrayDeclaratorList?) 
233         -> template(t={$text}) "<t>"
234     ;
235
236 qualifiedTypeIdent
237     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
238     ;
239
240 typeIdent
241     :   ^(IDENT genericTypeArgumentList?)
242     ;
243
244 primitiveType
245     :   BOOLEAN
246     |   CHAR
247     |   BYTE
248     |   SHORT
249     |   INT
250     |   LONG
251     |   FLOAT
252     |   DOUBLE
253     ;
254
255 genericTypeArgumentList
256     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
257     ;
258     
259 genericTypeArgument
260     :   type
261     |   ^(QUESTION genericWildcardBoundType?)
262     ;
263
264 genericWildcardBoundType                                                                                                                      
265     :   ^(EXTENDS type)
266     |   ^(SUPER type)
267     ;
268
269 formalParameterList
270     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
271     ;
272     
273 formalParameterStandardDecl
274     :   ^(FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId)
275     ;
276     
277 formalParameterVarargDecl
278     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId)
279     ;
280     
281 qualifiedIdentifier
282     :   IDENT
283     |   ^(DOT qualifiedIdentifier IDENT)
284     ;
285     
286 block
287     :   ^(BLOCK_SCOPE blockStatement*)
288     ;
289     
290 blockStatement
291     :   localVariableDeclaration
292     |   typeDeclaration
293     |   statement
294     ;
295     
296 localVariableDeclaration
297     :   ^(VAR_DECLARATION localModifierList type variableDeclaratorList)
298     ;
299     
300         
301 statement
302     :   block
303     |   ^(ASSERT expression expression?)
304     |   ^(IF parenthesizedExpression statement statement?)
305     |   ^(FOR forInit forCondition forUpdater statement)
306     |   ^(FOR_EACH localModifierList type IDENT expression statement) 
307     |   ^(WHILE parenthesizedExpression statement)
308     |   ^(DO statement parenthesizedExpression)
309     |   ^(TRY block catches? block?)  // The second optional block is the optional finally block.
310     |   ^(SWITCH parenthesizedExpression switchBlockLabels)
311     |   ^(SYNCHRONIZED parenthesizedExpression block)
312     |   ^(RETURN expression?)
313     |   ^(THROW expression)
314     |   ^(BREAK IDENT?)
315     |   ^(CONTINUE IDENT?)
316     |   ^(LABELED_STATEMENT IDENT statement)
317     |   expression
318     |   SEMI // Empty statement.
319     ;
320         
321 catches
322     :   ^(CATCH_CLAUSE_LIST catchClause+)
323     ;
324     
325 catchClause
326     :   ^(CATCH formalParameterStandardDecl block)
327     ;
328
329 switchBlockLabels
330     :   ^(SWITCH_BLOCK_LABEL_LIST switchCaseLabel* switchDefaultLabel? switchCaseLabel*)
331     ;
332         
333 switchCaseLabel
334     :   ^(CASE expression blockStatement*)
335     ;
336     
337 switchDefaultLabel
338     :   ^(DEFAULT blockStatement*)
339     ;
340     
341 forInit
342     :   ^(FOR_INIT (localVariableDeclaration | expression*)?)
343     ;
344     
345 forCondition
346     :   ^(FOR_CONDITION expression?)
347     ;
348     
349 forUpdater
350     :   ^(FOR_UPDATE expression*)
351     ;
352     
353 // EXPRESSIONS
354
355 parenthesizedExpression
356     :   ^(PARENTESIZED_EXPR expression)
357     ;
358     
359 expression
360     :   ^(EXPR expr)
361     ;
362
363 expr
364     :   ^(ASSIGN expr expr)
365     |   ^(PLUS_ASSIGN expr expr)
366     |   ^(MINUS_ASSIGN expr expr)
367     |   ^(STAR_ASSIGN expr expr)
368     |   ^(DIV_ASSIGN expr expr)
369     |   ^(AND_ASSIGN expr expr)
370     |   ^(OR_ASSIGN expr expr)
371     |   ^(XOR_ASSIGN expr expr)
372     |   ^(MOD_ASSIGN expr expr)
373     |   ^(BIT_SHIFT_RIGHT_ASSIGN expr expr)
374     |   ^(SHIFT_RIGHT_ASSIGN expr expr)
375     |   ^(SHIFT_LEFT_ASSIGN expr expr)
376     |   ^(QUESTION expr expr expr)
377     |   ^(LOGICAL_OR expr expr)
378     |   ^(LOGICAL_AND expr expr)
379     |   ^(OR expr expr)
380     |   ^(XOR expr expr)
381     |   ^(AND expr expr)
382     |   ^(EQUAL expr expr)
383     |   ^(NOT_EQUAL expr expr)
384     |   ^(INSTANCEOF expr type)
385     |   ^(LESS_OR_EQUAL expr expr)
386     |   ^(GREATER_OR_EQUAL expr expr)
387     |   ^(BIT_SHIFT_RIGHT expr expr)
388     |   ^(SHIFT_RIGHT expr expr)
389     |   ^(GREATER_THAN expr expr)
390     |   ^(SHIFT_LEFT expr expr)
391     |   ^(LESS_THAN expr expr)
392     |   ^(PLUS expr expr)
393     |   ^(MINUS expr expr)
394     |   ^(STAR expr expr)
395     |   ^(DIV expr expr)
396     |   ^(MOD expr expr)
397     |   ^(UNARY_PLUS expr)
398     |   ^(UNARY_MINUS expr)
399     |   ^(PRE_INC expr)
400     |   ^(PRE_DEC expr)
401     |   ^(POST_INC expr)
402     |   ^(POST_DEC expr)
403     |   ^(NOT expr)
404     |   ^(LOGICAL_NOT expr)
405     |   ^(CAST_EXPR type expr)
406     |   primaryExpression
407     ;
408     
409 primaryExpression
410     :   ^(  DOT
411             (   primaryExpression
412                 (   IDENT
413                 |   THIS
414                 |   SUPER
415                 |   innerNewExpression
416                 |   CLASS
417                 )
418             |   primitiveType CLASS
419             |   VOID CLASS
420             )
421         )
422     |   parenthesizedExpression
423     |   IDENT
424     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
425     |   explicitConstructorCall
426     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
427     |   literal
428     |   newExpression
429     |   THIS
430     |   arrayTypeDeclarator
431     |   SUPER
432     ;
433     
434 explicitConstructorCall
435     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
436     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
437     ;
438
439 arrayTypeDeclarator
440     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
441     ;
442
443 newExpression
444     :   ^(  STATIC_ARRAY_CREATOR
445             (   primitiveType newArrayConstruction
446             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
447             )
448         )
449     |   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? qualifiedTypeIdent arguments classTopLevelScope?)
450     ;
451
452 innerNewExpression // something like 'InnerType innerType = outer.new InnerType();'
453     :   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? IDENT arguments classTopLevelScope?)
454     ;
455     
456 newArrayConstruction
457     :   arrayDeclaratorList arrayInitializer
458     |   expression+ arrayDeclaratorList?
459     ;
460
461 arguments
462     :   ^(ARGUMENT_LIST expression*)
463     ;
464
465 literal 
466     :   HEX_LITERAL
467     |   OCTAL_LITERAL
468     |   DECIMAL_LITERAL
469     |   FLOATING_POINT_LITERAL
470     |   CHARACTER_LITERAL
471     |   STRING_LITERAL
472     |   TRUE
473     |   FALSE
474     |   NULL
475     ;