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