Added separate cc/ci emitters, modified driver, added antlr3.1 option
[charm.git] / src / langs / charj / src / charj / translator / CharjCIEmitter.g
1 /**
2  * ANTLR (v3) Tree Parser for the Charj Language
3  */
4
5 tree grammar CharjCIEmitter;
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) -> classExtends(type={$t.st})
111     ;   
112
113 interfaceExtendsClause 
114     :   ^(EXTENDS_CLAUSE (typeList+=type)+) -> interfaceExtends(ts={$typeList})
115     ;   
116     
117 implementsClause
118     :   ^(IMPLEMENTS_CLAUSE type+)
119     ;
120         
121 genericTypeParameterList
122     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
123     ;
124
125 genericTypeParameter
126     :   ^(IDENT bound?)
127     ;
128         
129 bound
130     :   ^(EXTENDS_BOUND_LIST type+)
131     ;
132
133 enumTopLevelScope
134     :   ^(ENUM_TOP_LEVEL_SCOPE enumConstant+ classTopLevelScope?)
135     ;
136     
137 enumConstant
138     :   ^(IDENT arguments? classTopLevelScope?)
139     ;
140     
141     
142 classTopLevelScope
143     :   ^(CLASS_TOP_LEVEL_SCOPE classScopeDeclarations*)
144     ;
145     
146 classScopeDeclarations
147     :   ^(CLASS_INSTANCE_INITIALIZER block)
148     |   ^(CLASS_STATIC_INITIALIZER block)
149     |   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause? block?)
150     |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block?)
151     |   ^(VAR_DECLARATION modifierList type variableDeclaratorList)
152     |   ^(CONSTRUCTOR_DECL modifierList genericTypeParameterList? formalParameterList throwsClause? block)
153     |   typeDeclaration
154     ;
155     
156 interfaceTopLevelScope
157     :   ^(INTERFACE_TOP_LEVEL_SCOPE interfaceScopeDeclarations*)
158     ;
159     
160 interfaceScopeDeclarations
161     :   ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
162     |   ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
163         // Interface constant declarations have been switched to variable
164         // declarations by Charj.g; the parser has already checked that
165         // there's an obligatory initializer.
166     |   ^(VAR_DECLARATION modifierList type variableDeclaratorList)
167     |   typeDeclaration
168     ;
169
170 variableDeclaratorList
171     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
172     ;
173
174 variableDeclarator
175     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
176     ;
177     
178 variableDeclaratorId
179     :   ^(IDENT arrayDeclaratorList?)
180     ;
181
182 variableInitializer
183     :   arrayInitializer
184     |   expression
185     ;
186
187 arrayDeclarator
188     :   LBRACK RBRACK
189     ;
190
191 arrayDeclaratorList
192     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
193     ;
194     
195 arrayInitializer
196     :   ^(ARRAY_INITIALIZER variableInitializer*)
197     ;
198
199 throwsClause
200     :   ^(THROWS_CLAUSE qualifiedIdentifier+)
201     ;
202
203 modifierList
204     :   ^(MODIFIER_LIST modifier*)
205     ;
206
207 modifier
208     :   PUBLIC
209     |   PROTECTED
210     |   PRIVATE
211     |   STATIC
212     |   ABSTRACT
213     |   NATIVE
214     |   SYNCHRONIZED
215     |   TRANSIENT
216     |   VOLATILE
217     |   localModifier
218     ;
219
220 localModifierList
221     :   ^(LOCAL_MODIFIER_LIST localModifier*)
222     ;
223
224 localModifier
225     :   FINAL
226     ;
227
228 type
229     :   ^(TYPE (primitiveType | qualifiedTypeIdent) arrayDeclaratorList?) -> template(t={$text}) "<t>"
230     ;
231
232 qualifiedTypeIdent
233     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
234     ;
235
236 typeIdent
237     :   ^(IDENT genericTypeArgumentList?)
238     ;
239
240 primitiveType
241     :   BOOLEAN
242     |   CHAR
243     |   BYTE
244     |   SHORT
245     |   INT
246     |   LONG
247     |   FLOAT
248     |   DOUBLE
249     ;
250
251 genericTypeArgumentList
252     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
253     ;
254     
255 genericTypeArgument
256     :   type
257     |   ^(QUESTION genericWildcardBoundType?)
258     ;
259
260 genericWildcardBoundType                                                                                                                      
261     :   ^(EXTENDS type)
262     |   ^(SUPER type)
263     ;
264
265 formalParameterList
266     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
267     ;
268     
269 formalParameterStandardDecl
270     :   ^(FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId)
271     ;
272     
273 formalParameterVarargDecl
274     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId)
275     ;
276     
277 qualifiedIdentifier
278     :   IDENT
279     |   ^(DOT qualifiedIdentifier IDENT)
280     ;
281     
282 block
283     :   ^(BLOCK_SCOPE blockStatement*)
284     ;
285     
286 blockStatement
287     :   localVariableDeclaration
288     |   typeDeclaration
289     |   statement
290     ;
291     
292 localVariableDeclaration
293     :   ^(VAR_DECLARATION localModifierList type variableDeclaratorList)
294     ;
295     
296         
297 statement
298     :   block
299     |   ^(ASSERT expression expression?)
300     |   ^(IF parenthesizedExpression statement statement?)
301     |   ^(FOR forInit forCondition forUpdater statement)
302     |   ^(FOR_EACH localModifierList type IDENT expression statement) 
303     |   ^(WHILE parenthesizedExpression statement)
304     |   ^(DO statement parenthesizedExpression)
305     |   ^(TRY block catches? block?)  // The second optional block is the optional finally block.
306     |   ^(SWITCH parenthesizedExpression switchBlockLabels)
307     |   ^(SYNCHRONIZED parenthesizedExpression block)
308     |   ^(RETURN expression?)
309     |   ^(THROW expression)
310     |   ^(BREAK IDENT?)
311     |   ^(CONTINUE IDENT?)
312     |   ^(LABELED_STATEMENT IDENT statement)
313     |   expression
314     |   SEMI // Empty statement.
315     ;
316         
317 catches
318     :   ^(CATCH_CLAUSE_LIST catchClause+)
319     ;
320     
321 catchClause
322     :   ^(CATCH formalParameterStandardDecl block)
323     ;
324
325 switchBlockLabels
326     :   ^(SWITCH_BLOCK_LABEL_LIST switchCaseLabel* switchDefaultLabel? switchCaseLabel*)
327     ;
328         
329 switchCaseLabel
330     :   ^(CASE expression blockStatement*)
331     ;
332     
333 switchDefaultLabel
334     :   ^(DEFAULT blockStatement*)
335     ;
336     
337 forInit
338     :   ^(FOR_INIT (localVariableDeclaration | expression*)?)
339     ;
340     
341 forCondition
342     :   ^(FOR_CONDITION expression?)
343     ;
344     
345 forUpdater
346     :   ^(FOR_UPDATE expression*)
347     ;
348     
349 // EXPRESSIONS
350
351 parenthesizedExpression
352     :   ^(PARENTESIZED_EXPR expression)
353     ;
354     
355 expression
356     :   ^(EXPR expr)
357     ;
358
359 expr
360     :   ^(ASSIGN expr expr)
361     |   ^(PLUS_ASSIGN expr expr)
362     |   ^(MINUS_ASSIGN expr expr)
363     |   ^(STAR_ASSIGN expr expr)
364     |   ^(DIV_ASSIGN expr expr)
365     |   ^(AND_ASSIGN expr expr)
366     |   ^(OR_ASSIGN expr expr)
367     |   ^(XOR_ASSIGN expr expr)
368     |   ^(MOD_ASSIGN expr expr)
369     |   ^(BIT_SHIFT_RIGHT_ASSIGN expr expr)
370     |   ^(SHIFT_RIGHT_ASSIGN expr expr)
371     |   ^(SHIFT_LEFT_ASSIGN expr expr)
372     |   ^(QUESTION expr expr expr)
373     |   ^(LOGICAL_OR expr expr)
374     |   ^(LOGICAL_AND expr expr)
375     |   ^(OR expr expr)
376     |   ^(XOR expr expr)
377     |   ^(AND expr expr)
378     |   ^(EQUAL expr expr)
379     |   ^(NOT_EQUAL expr expr)
380     |   ^(INSTANCEOF expr type)
381     |   ^(LESS_OR_EQUAL expr expr)
382     |   ^(GREATER_OR_EQUAL expr expr)
383     |   ^(BIT_SHIFT_RIGHT expr expr)
384     |   ^(SHIFT_RIGHT expr expr)
385     |   ^(GREATER_THAN expr expr)
386     |   ^(SHIFT_LEFT expr expr)
387     |   ^(LESS_THAN expr expr)
388     |   ^(PLUS expr expr)
389     |   ^(MINUS expr expr)
390     |   ^(STAR expr expr)
391     |   ^(DIV expr expr)
392     |   ^(MOD expr expr)
393     |   ^(UNARY_PLUS expr)
394     |   ^(UNARY_MINUS expr)
395     |   ^(PRE_INC expr)
396     |   ^(PRE_DEC expr)
397     |   ^(POST_INC expr)
398     |   ^(POST_DEC expr)
399     |   ^(NOT expr)
400     |   ^(LOGICAL_NOT expr)
401     |   ^(CAST_EXPR type expr)
402     |   primaryExpression
403     ;
404     
405 primaryExpression
406     :   ^(  DOT
407             (   primaryExpression
408                 (   IDENT
409                 |   THIS
410                 |   SUPER
411                 |   innerNewExpression
412                 |   CLASS
413                 )
414             |   primitiveType CLASS
415             |   VOID CLASS
416             )
417         )
418     |   parenthesizedExpression
419     |   IDENT
420     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
421     |   explicitConstructorCall
422     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
423     |   literal
424     |   newExpression
425     |   THIS
426     |   arrayTypeDeclarator
427     |   SUPER
428     ;
429     
430 explicitConstructorCall
431     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
432     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
433     ;
434
435 arrayTypeDeclarator
436     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
437     ;
438
439 newExpression
440     :   ^(  STATIC_ARRAY_CREATOR
441             (   primitiveType newArrayConstruction
442             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
443             )
444         )
445     |   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? qualifiedTypeIdent arguments classTopLevelScope?)
446     ;
447
448 innerNewExpression // something like 'InnerType innerType = outer.new InnerType();'
449     :   ^(CLASS_CONSTRUCTOR_CALL genericTypeArgumentList? IDENT arguments classTopLevelScope?)
450     ;
451     
452 newArrayConstruction
453     :   arrayDeclaratorList arrayInitializer
454     |   expression+ arrayDeclaratorList?
455     ;
456
457 arguments
458     :   ^(ARGUMENT_LIST expression*)
459     ;
460
461 literal 
462     :   HEX_LITERAL
463     |   OCTAL_LITERAL
464     |   DECIMAL_LITERAL
465     |   FLOATING_POINT_LITERAL
466     |   CHARACTER_LITERAL
467     |   STRING_LITERAL
468     |   TRUE
469     |   FALSE
470     |   NULL
471     ;