code cleanup, template tweak
[charm.git] / src / langs / charj / src / charj / translator / Charj.g
1 /**
2  * ANTLR (v3) grammar for the Charj Language
3  *
4  * The other .g files are tree parsers that can read and modify an AST 
5  * using the output of this grammar.
6  */
7
8
9 grammar Charj;
10
11 options {
12     backtrack = true; 
13     memoize = true;
14     output = AST;
15     ASTLabelType = CharjAST;
16 }
17
18 tokens {
19
20     // operators and other special chars
21     
22     AND                     = '&'               ;
23     AND_ASSIGN              = '&='              ;
24     ASSIGN                  = '='               ;
25     AT                      = '@'               ;
26     BIT_SHIFT_RIGHT         = '>>>'             ;
27     BIT_SHIFT_RIGHT_ASSIGN  = '>>>='            ;
28     COLON                   = ':'               ;
29     COMMA                   = ','               ;
30     DEC                     = '--'              ;
31     DIV                     = '/'               ;
32     DIV_ASSIGN              = '/='              ;
33     DOT                     = '.'               ;
34     DOTSTAR                 = '.*'              ;
35     ELLIPSIS                = '...'             ;
36     EQUAL                   = '=='              ;
37     GREATER_OR_EQUAL        = '>='              ;
38     GREATER_THAN            = '>'               ;
39     INC                     = '++'              ;
40     LBRACK                  = '['               ;
41     LCURLY                  = '{'               ;
42     LESS_OR_EQUAL           = '<='              ;
43     LESS_THAN               = '<'               ;
44     LOGICAL_AND             = '&&'              ;
45     LOGICAL_NOT             = '!'               ;
46     LOGICAL_OR              = '||'              ;
47     LPAREN                  = '('               ;
48     MINUS                   = '-'               ;
49     MINUS_ASSIGN            = '-='              ;
50     MOD                     = '%'               ;
51     MOD_ASSIGN              = '%='              ;
52     NOT                     = '~'               ;
53     NOT_EQUAL               = '!='              ;
54     OR                      = '|'               ;
55     OR_ASSIGN               = '|='              ;
56     PLUS                    = '+'               ;
57     PLUS_ASSIGN             = '+='              ;
58     QUESTION                = '?'               ;
59     RBRACK                  = ']'               ;
60     RCURLY                  = '}'               ;
61     RPAREN                  = ')'               ;
62     SEMI                    = ';'               ;
63     SHIFT_LEFT              = '<<'              ;
64     SHIFT_LEFT_ASSIGN       = '<<='             ;
65     SHIFT_RIGHT             = '>>'              ;
66     SHIFT_RIGHT_ASSIGN      = '>>='             ;
67     STAR                    = '*'               ;
68     STAR_ASSIGN             = '*='              ;
69     XOR                     = '^'               ;
70     XOR_ASSIGN              = '^='              ;
71
72     // Charj-specific operators
73     DOUBLE_LCURLY           = '{{'              ;
74     DOUBLE_RCURLY           = '}}'              ;
75
76     // Keywords common to Java and Charj
77     
78     ABSTRACT                = 'abstract'        ;
79     ASSERT                  = 'assert'          ;
80     BOOLEAN                 = 'boolean'         ;
81     BREAK                   = 'break'           ;
82     BYTE                    = 'byte'            ;
83     CASE                    = 'case'            ;
84     CATCH                   = 'catch'           ;
85     CHAR                    = 'char'            ;
86     CLASS                   = 'class'           ;
87     CONTINUE                = 'continue'        ;
88     DEFAULT                 = 'default'         ;
89     DELETE                  = 'delete'          ;
90     DO                      = 'do'              ;
91     DOUBLE                  = 'double'          ;
92     ELSE                    = 'else'            ;
93     ENUM                    = 'enum'            ;
94     EXTENDS                 = 'extends'         ;
95     FALSE                   = 'false'           ;
96     FINAL                   = 'final'           ;
97     FINALLY                 = 'finally'         ;
98     FLOAT                   = 'float'           ;
99     FOR                     = 'for'             ;
100     IF                      = 'if'              ;
101     IMPLEMENTS              = 'implements'      ;
102     INSTANCEOF              = 'instanceof'      ;
103     INTERFACE               = 'interface'       ;
104     IMPORT                  = 'import'          ;
105     INT                     = 'int'             ;
106     LONG                    = 'long'            ;
107     NATIVE                  = 'native'          ;
108     NEW                     = 'new'             ;
109     NULL                    = 'null'            ;
110     PACKAGE                 = 'package'         ;
111     PRIVATE                 = 'private'         ;
112     PROTECTED               = 'protected'       ;
113     PUBLIC                  = 'public'          ;
114     RETURN                  = 'return'          ;
115     SHORT                   = 'short'           ;
116     STATIC                  = 'static'          ;
117     SUPER                   = 'super'           ;
118     SWITCH                  = 'switch'          ;
119     SYNCHRONIZED            = 'synchronized'    ;
120     THIS                    = 'this'            ;
121     THROW                   = 'throw'           ;
122     THROWS                  = 'throws'          ;
123     TRANSIENT               = 'transient'       ;
124     TRUE                    = 'true'            ;
125     TRY                     = 'try'             ;
126     VOID                    = 'void'            ;
127     VOLATILE                = 'volatile'        ;
128     WHILE                   = 'while'           ;
129
130     // Charj-specific keywords
131     EMBED                   = 'embed'           ;
132     ENTRY                   = 'entry'           ;
133
134
135     // C++ keywords that aren't used in charj. 
136     // We don't use these ourselves, but they're still reserved
137     ASM                     = 'asm'             ;
138     AUTO                    = 'auto'            ;
139     BOOL                    = 'bool'            ;
140     CONST_CAST              = 'const_cast'      ;
141     DYNAMIC_CAST            = 'dynamic_cast'    ;
142     EXPLICIT                = 'explicit'        ;
143     EXPORT                  = 'export'          ;
144     EXTERN                  = 'extern'          ;
145     FRIEND                  = 'friend'          ;
146     GOTO                    = 'goto'            ;
147     INLINE                  = 'inline'          ;
148     MUTABLE                 = 'mutable'         ;
149     NAMESPACE               = 'namespace'       ;
150     OPERATOR                = 'operator'        ;
151     REGISTER                = 'register'        ;
152     REINTERPRET_CAST        = 'reinterpret_cast';
153     SIGNED                  = 'signed'          ;
154     SIZEOF                  = 'sizeof'          ;
155     STATIC_CAST             = 'static_cast'     ;
156     STRUCT                  = 'struct'          ;
157     TEMPLATE                = 'template'        ;
158     TYPEDEF                 = 'typedef'         ;
159     TYPEID                  = 'typeid'          ;
160     TYPENAME                = 'typename'        ;
161     UNION                   = 'union'           ;
162     UNSIGNED                = 'unsigned'        ;
163     USING                   = 'using'           ;
164     VIRTUAL                 = 'virtual'         ;
165     WCHAR_T                 = 'wchar_t'         ;
166     
167     
168     
169     // tokens for imaginary nodes
170     
171     ARGUMENT_LIST;
172     ARRAY_DECLARATOR;
173     ARRAY_DECLARATOR_LIST;
174     ARRAY_ELEMENT_ACCESS;
175     ARRAY_INITIALIZER;
176     BLOCK_SCOPE;
177     CAST_EXPR;
178     CATCH_CLAUSE_LIST;
179     CLASS_CONSTRUCTOR_CALL;
180     CLASS_INSTANCE_INITIALIZER;
181     CLASS_STATIC_INITIALIZER;
182     CLASS_TOP_LEVEL_SCOPE;
183     CONSTRUCTOR_DECL;
184     ENUM_TOP_LEVEL_SCOPE;
185     EXPR;
186     EXTENDS_BOUND_LIST;
187     EXTENDS_CLAUSE;
188     FOR_CONDITION;
189     FOR_EACH;
190     FOR_INIT;
191     FOR_UPDATE;
192     FORMAL_PARAM_LIST;
193     FORMAL_PARAM_STD_DECL;
194     FORMAL_PARAM_VARARG_DECL;
195     FUNCTION_METHOD_DECL;
196     GENERIC_TYPE_ARG_LIST;
197     GENERIC_TYPE_PARAM_LIST;
198     INTERFACE_TOP_LEVEL_SCOPE;
199     IMPLEMENTS_CLAUSE;
200     LABELED_STATEMENT;
201     LOCAL_MODIFIER_LIST;
202     CHARJ_SOURCE;
203     METHOD_CALL;
204     MODIFIER_LIST;
205     PARENTESIZED_EXPR;
206     POST_DEC;
207     POST_INC;
208     PRE_DEC;
209     PRE_INC;
210     QUALIFIED_TYPE_IDENT;
211     STATIC_ARRAY_CREATOR;
212     SUPER_CONSTRUCTOR_CALL;
213     SWITCH_BLOCK_LABEL_LIST;
214     THIS_CONSTRUCTOR_CALL;
215     THROWS_CLAUSE;
216     TYPE;
217     UNARY_MINUS;
218     UNARY_PLUS;
219     VAR_DECLARATION;
220     VAR_DECLARATOR;
221     VAR_DECLARATOR_LIST;
222     VOID_METHOD_DECL;
223 }
224
225 @header {
226 package charj.translator;
227 }
228
229 @members {
230     
231     private boolean mMessageCollectionEnabled = false;
232     private boolean mHasErrors = false;
233     private List<String> mMessages;
234
235     /**
236      *  Switches error message collection on or of.
237      *
238      *  The standard destination for parser error messages is <code>System.err</code>.
239      *  However, if <code>true</code> gets passed to this method this default
240      *  behaviour will be switched off and all error messages will be collected
241      *  instead of written to anywhere.
242      *
243      *  The default value is <code>false</code>.
244      *
245      *  @param pNewState  <code>true</code> if error messages should be collected.
246      */
247     public void enableErrorMessageCollection(boolean pNewState) {
248         mMessageCollectionEnabled = pNewState;
249         if (mMessages == null && mMessageCollectionEnabled) {
250             mMessages = new ArrayList<String>();
251         }
252     }
253     
254     /**
255      *  Collects an error message or passes the error message to <code>
256      *  super.emitErrorMessage(...)</code>.
257      *
258      *  The actual behaviour depends on whether collecting error messages
259      *  has been enabled or not.
260      *
261      *  @param pMessage  The error message.
262      */
263      @Override
264     public void emitErrorMessage(String pMessage) {
265         if (mMessageCollectionEnabled) {
266             mMessages.add(pMessage);
267         } else {
268             super.emitErrorMessage(pMessage);
269         }
270     }
271     
272     /**
273      *  Returns collected error messages.
274      *
275      *  @return  A list holding collected error messages or <code>null</code> if
276      *           collecting error messages hasn't been enabled. Of course, this
277      *           list may be empty if no error message has been emited.
278      */
279     public List<String> getMessages() {
280         return mMessages;
281     }
282     
283     /**
284      *  Tells if parsing a Charj source has caused any error messages.
285      *
286      *  @return  <code>true</code> if parsing a Charj source has caused at least
287      *           one error message.
288      */
289     public boolean hasErrors() {
290         return mHasErrors;
291     }
292 }
293
294 @lexer::header {
295 package charj.translator; 
296 }
297
298 @lexer::members {
299 /** 
300  *  Determines if whitespaces and comments should be preserved or thrown away.
301  *
302  *  If <code>true</code> whitespaces and comments will be preserved within the
303  *  hidden channel, otherwise the appropriate tokens will be skiped. This is
304  *  a 'little bit' expensive.
305  */
306 public boolean preserveWhitespacesAndComments = true;
307 }
308
309 // Starting point for parsing a Charj file.
310 charjSource
311     :   compilationUnit
312         ->  ^(CHARJ_SOURCE compilationUnit)
313     ;
314
315 compilationUnit
316     :   packageDeclaration? 
317         importDeclaration* 
318         typeDecls*
319     ;
320
321 typeDecls
322     :   typeDeclaration
323     |   SEMI!
324     ;
325
326 packageDeclaration
327     :   PACKAGE^ qualifiedIdentifier SEMI!  
328     ;
329     
330 importDeclaration
331     :   IMPORT^ STATIC? qualifiedIdentifier DOTSTAR? SEMI!
332     ;
333     
334 typeDeclaration
335     :   modifierList!
336         (   classTypeDeclaration[$modifierList.tree]
337         |   interfaceTypeDeclaration[$modifierList.tree]
338         |   enumTypeDeclaration[$modifierList.tree]
339         )
340     ;
341     
342 classTypeDeclaration[CharjAST modifiers]
343     :   CLASS IDENT genericTypeParameterList? classExtendsClause? implementsClause? classBody
344         ->  ^(CLASS {$modifiers} IDENT genericTypeParameterList? classExtendsClause? implementsClause? classBody)
345     ;
346     
347 classExtendsClause
348     :   EXTENDS type
349         ->  ^(EXTENDS_CLAUSE[$EXTENDS, "EXTENDS_CLAUSE"] type)
350     ;   
351     
352 interfaceExtendsClause
353     :   EXTENDS typeList
354         ->  ^(EXTENDS_CLAUSE[$EXTENDS, "EXTENDS_CLAUSE"] typeList)
355     ;   
356     
357 implementsClause
358     :   IMPLEMENTS typeList
359         ->  ^(IMPLEMENTS_CLAUSE[$IMPLEMENTS, "IMPLEMENTS_CLAUSE"] typeList)
360     ;
361         
362 genericTypeParameterList
363     :   LESS_THAN genericTypeParameter (COMMA genericTypeParameter)* genericTypeListClosing
364         ->  ^(GENERIC_TYPE_PARAM_LIST[$LESS_THAN, "GENERIC_TYPE_PARAM_LIST"] genericTypeParameter+)
365     ;
366
367 genericTypeListClosing  // This 'trick' is fairly dirty - if there's some time a better solution should 
368                         // be found to resolve the problem with nested generic type parameter lists 
369                         // (i.e. <T1 extends AnyType<T2>> for generic type parameters or <T1<T2>> for 
370                         // generic type arguments etc). 
371     :   GREATER_THAN
372     |   SHIFT_RIGHT
373     |   BIT_SHIFT_RIGHT
374     |   // nothing
375     ;
376
377 genericTypeParameter
378     :   IDENT bound?
379         ->  ^(IDENT bound?)
380     ;
381         
382 bound
383     :   EXTENDS type (AND type)*
384         ->  ^(EXTENDS_BOUND_LIST[$EXTENDS, "EXTENDS_BOUND_LIST"] type+)
385     ;
386
387 enumTypeDeclaration[CharjAST modifiers]
388     :   ENUM IDENT implementsClause? enumBody
389         ->  ^(ENUM {$modifiers} IDENT implementsClause? enumBody)
390     ;
391     
392 enumBody
393     :   LCURLY enumScopeDeclarations RCURLY
394         ->  ^(ENUM_TOP_LEVEL_SCOPE[$LCURLY, "ENUM_TOP_LEVEL_SCOPE"] enumScopeDeclarations)
395     ;
396
397 enumScopeDeclarations
398     :   enumConstants (COMMA!)? enumClassScopeDeclarations?
399     ;
400
401 enumClassScopeDeclarations
402     :   SEMI classScopeDeclarations*
403         ->  ^(CLASS_TOP_LEVEL_SCOPE[$SEMI, "CLASS_TOP_LEVEL_SCOPE"] classScopeDeclarations*)
404     ;
405
406 enumConstants
407     :   enumConstant (COMMA! enumConstant)*
408     ;
409     
410 enumConstant
411     :   IDENT^ arguments? classBody?
412     ;
413     
414 interfaceTypeDeclaration[CharjAST modifiers]
415     :   INTERFACE IDENT genericTypeParameterList? interfaceExtendsClause? interfaceBody
416         ->  ^(INTERFACE {$modifiers} IDENT genericTypeParameterList? interfaceExtendsClause? interfaceBody)
417     ;
418     
419 typeList
420     :   type (COMMA! type)*
421     ;
422     
423 classBody
424     :   LCURLY classScopeDeclarations* RCURLY
425         ->  ^(CLASS_TOP_LEVEL_SCOPE[$LCURLY, "CLASS_TOP_LEVEL_SCOPE"] classScopeDeclarations*)
426     ;
427     
428 interfaceBody
429     :   LCURLY interfaceScopeDeclarations* RCURLY
430         ->  ^(INTERFACE_TOP_LEVEL_SCOPE[$LCURLY, "CLASS_TOP_LEVEL_SCOPE"] interfaceScopeDeclarations*)
431     ;
432
433 classScopeDeclarations
434     :   block           ->  ^(CLASS_INSTANCE_INITIALIZER block)
435     |   STATIC block    ->  ^(CLASS_STATIC_INITIALIZER[$STATIC, "CLASS_STATIC_INITIALIZER"] block)
436     |   modifierList
437         (   genericTypeParameterList?
438             (   type IDENT formalParameterList arrayDeclaratorList? throwsClause? (block | SEMI)
439                 ->  ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause? block?)
440             |   VOID IDENT formalParameterList throwsClause? (block | SEMI)
441                 ->  ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block?)
442             |   ident=IDENT formalParameterList throwsClause? block
443                 ->  ^(CONSTRUCTOR_DECL[$ident, "CONSTRUCTOR_DECL"] modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block)
444                 //->  ^(CONSTRUCTOR_DECL[$ident, $ident.text] modifierList genericTypeParameterList? formalParameterList throwsClause? block)
445             )
446         |   type classFieldDeclaratorList SEMI
447             ->  ^(VAR_DECLARATION modifierList type classFieldDeclaratorList)
448         )
449     |   typeDeclaration
450     |   SEMI!
451     ;
452             
453 interfaceScopeDeclarations
454     :   modifierList
455         (   genericTypeParameterList?
456             (   type IDENT formalParameterList arrayDeclaratorList? throwsClause? SEMI
457                 ->  ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
458             |   VOID IDENT formalParameterList throwsClause? SEMI
459                 ->  ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
460             )
461         |   type interfaceFieldDeclaratorList SEMI
462             ->  ^(VAR_DECLARATION modifierList type interfaceFieldDeclaratorList)
463         )
464     |   typeDeclaration
465     |   SEMI!
466     ;
467
468 classFieldDeclaratorList
469     :   classFieldDeclarator (COMMA classFieldDeclarator)*
470         ->  ^(VAR_DECLARATOR_LIST classFieldDeclarator+)
471     ;
472
473 classFieldDeclarator
474     :   variableDeclaratorId (ASSIGN variableInitializer)?
475         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
476     ;
477     
478 interfaceFieldDeclaratorList
479     :   interfaceFieldDeclarator (COMMA interfaceFieldDeclarator)*
480         ->  ^(VAR_DECLARATOR_LIST interfaceFieldDeclarator+)
481     ;
482
483 interfaceFieldDeclarator
484     :   variableDeclaratorId ASSIGN variableInitializer
485         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer)
486     ;
487     
488 variableDeclaratorId
489     :   IDENT^ arrayDeclaratorList?
490     ;
491
492 variableInitializer
493     :   arrayInitializer
494     |   expression
495     ;
496
497 arrayDeclarator
498     :   LBRACK RBRACK
499         ->  ^(ARRAY_DECLARATOR)
500     ;
501
502 arrayDeclaratorList
503     :   arrayDeclarator+
504         ->  ^(ARRAY_DECLARATOR_LIST arrayDeclarator+)   
505     ;
506     
507 arrayInitializer
508     :   LCURLY (variableInitializer (COMMA variableInitializer)* COMMA?)? RCURLY
509         ->  ^(ARRAY_INITIALIZER[$LCURLY, "ARRAY_INITIALIZER"] variableInitializer*)
510     ;
511
512 throwsClause
513     :   THROWS qualifiedIdentList
514         ->  ^(THROWS_CLAUSE[$THROWS, "THROWS_CLAUSE"] qualifiedIdentList)
515     ;
516
517 modifierList
518     :   modifier*   
519         ->  ^(MODIFIER_LIST modifier*)
520     ;
521
522 modifier
523     :   PUBLIC
524     |   PROTECTED
525     |   ENTRY
526     |   PRIVATE
527     |   STATIC
528     |   ABSTRACT
529     |   NATIVE
530     |   SYNCHRONIZED
531     |   TRANSIENT
532     |   VOLATILE
533     |   localModifier
534     ;
535
536 localModifierList
537     :   localModifier*
538         -> ^(LOCAL_MODIFIER_LIST localModifier*)
539     ;
540     
541 localModifier
542     :   FINAL
543     ;
544
545 type
546     :   simpleType
547     |   objectType
548     ;
549
550 simpleType // including static arrays of simple type elements
551     :   primitiveType arrayDeclaratorList?
552         ->  ^(TYPE primitiveType arrayDeclaratorList?)  
553     ;
554     
555 objectType // including static arrays of object type reference elements
556     :   qualifiedTypeIdent arrayDeclaratorList?
557         ->  ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
558     ;
559
560 objectTypeSimplified
561     :   qualifiedTypeIdentSimplified arrayDeclaratorList?
562         ->  ^(TYPE qualifiedTypeIdentSimplified arrayDeclaratorList?)
563     ;
564
565 qualifiedTypeIdent
566     :   typeIdent (DOT typeIdent)*
567         ->  ^(QUALIFIED_TYPE_IDENT typeIdent+) 
568     ;
569
570 qualifiedTypeIdentSimplified
571     :   typeIdentSimplified (DOT typeIdentSimplified)*
572         ->  ^(QUALIFIED_TYPE_IDENT typeIdentSimplified+) 
573     ;
574
575 typeIdent
576     :   IDENT^ genericTypeArgumentList?
577     ;
578
579 typeIdentSimplified
580     :   IDENT^ genericTypeArgumentListSimplified?
581     ;
582
583 primitiveType
584     :   BOOLEAN
585     |   CHAR
586     |   BYTE
587     |   SHORT
588     |   INT
589     |   LONG
590     |   FLOAT
591     |   DOUBLE
592     ;
593
594 genericTypeArgumentList
595     :   LESS_THAN genericTypeArgument (COMMA genericTypeArgument)* genericTypeListClosing
596         ->  ^(GENERIC_TYPE_ARG_LIST[$LESS_THAN, "GENERIC_TYPE_ARG_LIST"] genericTypeArgument+)
597     ;
598
599 genericTypeArgument
600     :   type
601     |   QUESTION genericWildcardBoundType?
602         ->  ^(QUESTION genericWildcardBoundType?)
603     ;
604     
605 genericWildcardBoundType
606     :   (EXTENDS | SUPER)^ type
607     ;
608
609 genericTypeArgumentListSimplified
610     :   LESS_THAN genericTypeArgumentSimplified (COMMA genericTypeArgumentSimplified)* genericTypeListClosing
611         ->  ^(GENERIC_TYPE_ARG_LIST[$LESS_THAN, "GENERIC_TYPE_ARG_LIST"] genericTypeArgumentSimplified+)
612     ;
613     
614 genericTypeArgumentSimplified
615     :   type
616     |   QUESTION
617     ;
618     
619 qualifiedIdentList
620     :   qualifiedIdentifier (COMMA! qualifiedIdentifier)*
621     ;
622     
623 formalParameterList
624     :   LPAREN 
625         (   // Contains at least one standard argument declaration and optionally a variable argument declaration.
626             formalParameterStandardDecl (COMMA formalParameterStandardDecl)* (COMMA formalParameterVarArgDecl)? 
627             ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"] formalParameterStandardDecl+ formalParameterVarArgDecl?) 
628             // Contains a variable argument declaration only.
629         |   formalParameterVarArgDecl
630             ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"] formalParameterVarArgDecl) 
631             // Contains nothing.
632         |   ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"]) 
633         )
634         RPAREN
635     ;
636     
637 formalParameterStandardDecl
638     :   localModifierList type variableDeclaratorId
639         ->  ^(FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId)
640     ;
641     
642 formalParameterVarArgDecl
643     :   localModifierList type ELLIPSIS variableDeclaratorId
644         ->  ^(FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId)
645     ;
646     
647 qualifiedIdentifier
648     :   (   IDENT               ->  IDENT
649         )
650         (   DOT ident=IDENT     ->  ^(DOT $qualifiedIdentifier $ident)
651         )*
652     ;
653     
654 block
655     :   LCURLY blockStatement* RCURLY
656         ->  ^(BLOCK_SCOPE[$LCURLY, "BLOCK_SCOPE"] blockStatement*)
657     ;
658
659 blockStatement
660     :   localVariableDeclaration SEMI!
661     |   typeDeclaration
662     |   statement
663     ;
664     
665 localVariableDeclaration
666     :   localModifierList type classFieldDeclaratorList
667         ->  ^(VAR_DECLARATION localModifierList type classFieldDeclaratorList)
668     ;
669     
670         
671 statement
672     :   block
673     |   ASSERT expr1=expression 
674         (   COLON expr2=expression SEMI                                     ->  ^(ASSERT $expr1 $expr2)
675         |   SEMI                                                            ->  ^(ASSERT $expr1)
676         )
677     |   IF parenthesizedExpression ifStat=statement 
678         (   ELSE elseStat=statement                                         ->  ^(IF parenthesizedExpression $ifStat $elseStat)
679         |                                                                   ->  ^(IF parenthesizedExpression $ifStat)
680         )   
681     |   FOR LPAREN 
682         (   forInit SEMI forCondition SEMI forUpdater RPAREN statement      ->  ^(FOR forInit forCondition forUpdater statement) 
683         |   localModifierList type IDENT COLON expression RPAREN statement
684                                                                             ->  ^(FOR_EACH[$FOR, "FOR_EACH"] localModifierList type IDENT expression statement)
685         ) 
686     |   WHILE parenthesizedExpression statement                             ->  ^(WHILE parenthesizedExpression statement)
687     |   DO statement WHILE parenthesizedExpression SEMI                     ->  ^(DO statement parenthesizedExpression)
688     |   TRY block (catches finallyClause? | finallyClause)                  ->  ^(TRY block catches? finallyClause?)
689     |   SWITCH parenthesizedExpression LCURLY switchBlockLabels RCURLY      ->  ^(SWITCH parenthesizedExpression switchBlockLabels)
690     |   SYNCHRONIZED parenthesizedExpression block                          ->  ^(SYNCHRONIZED parenthesizedExpression block)
691     |   RETURN expression? SEMI                                             ->  ^(RETURN expression?)
692     |   THROW expression SEMI                                               ->  ^(THROW expression)
693     |   BREAK IDENT? SEMI                                                   ->  ^(BREAK IDENT?)
694     |   CONTINUE IDENT? SEMI                                                ->  ^(CONTINUE IDENT?)
695     |   IDENT COLON statement                                               ->  ^(LABELED_STATEMENT IDENT statement)
696     |   EMBED STRING_LITERAL EMBED_BLOCK                                    ->  ^(EMBED STRING_LITERAL EMBED_BLOCK)
697     |   expression SEMI!
698     |   SEMI // Preserve empty statements.
699     ;           
700         
701 catches
702     :   catchClause+
703         ->  ^(CATCH_CLAUSE_LIST catchClause+)
704     ;
705     
706 catchClause
707     :   CATCH^ LPAREN! formalParameterStandardDecl RPAREN! block
708     ;
709
710 finallyClause
711     :   FINALLY block
712         ->  block
713     ;
714
715 switchBlockLabels
716     :   switchCaseLabels switchDefaultLabel? switchCaseLabels
717         ->  ^(SWITCH_BLOCK_LABEL_LIST switchCaseLabels switchDefaultLabel? switchCaseLabels)
718     ;
719     
720 switchCaseLabels
721     :   switchCaseLabel*
722     ;
723         
724 switchCaseLabel
725     :   CASE^ expression COLON! blockStatement*
726     ;
727     
728 switchDefaultLabel
729     :   DEFAULT^ COLON! blockStatement*
730     ;
731     
732 forInit
733     :   localVariableDeclaration    ->  ^(FOR_INIT localVariableDeclaration)
734     |   expressionList              ->  ^(FOR_INIT expressionList)
735     |                               ->  ^(FOR_INIT)
736     ;
737     
738 forCondition
739     :   expression?
740         ->  ^(FOR_CONDITION expression?)
741     ;
742     
743 forUpdater
744     :   expressionList?
745         ->  ^(FOR_UPDATE expressionList?)
746     ;
747
748 // EXPRESSIONS
749
750 parenthesizedExpression
751     :   LPAREN expression RPAREN
752         ->  ^(PARENTESIZED_EXPR[$LPAREN, "PARENTESIZED_EXPR"] expression)
753     ;
754     
755 expressionList
756     :   expression (COMMA! expression)*
757     ;
758
759 expression
760     :   assignmentExpression
761         ->  ^(EXPR assignmentExpression)
762     ;
763
764 assignmentExpression
765     :   conditionalExpression 
766         (   (   ASSIGN^
767             |   PLUS_ASSIGN^
768             |   MINUS_ASSIGN^
769             |   STAR_ASSIGN^
770             |   DIV_ASSIGN^
771             |   AND_ASSIGN^
772             |   OR_ASSIGN^
773             |   XOR_ASSIGN^
774             |   MOD_ASSIGN^
775             |   SHIFT_LEFT_ASSIGN^
776             |   SHIFT_RIGHT_ASSIGN^
777             |   BIT_SHIFT_RIGHT_ASSIGN^
778         ) 
779         assignmentExpression)?
780     ;
781     
782 conditionalExpression
783     :   logicalOrExpression (QUESTION^ assignmentExpression COLON! conditionalExpression)?
784     ;
785
786 logicalOrExpression
787     :   logicalAndExpression (LOGICAL_OR^ logicalAndExpression)*
788     ;
789
790 logicalAndExpression
791     :   inclusiveOrExpression (LOGICAL_AND^ inclusiveOrExpression)*
792     ;
793
794 inclusiveOrExpression
795     :   exclusiveOrExpression (OR^ exclusiveOrExpression)*
796     ;
797
798 exclusiveOrExpression
799     :   andExpression (XOR^ andExpression)*
800     ;
801
802 andExpression
803     :   equalityExpression (AND^ equalityExpression)*
804     ;
805
806 equalityExpression
807     :   instanceOfExpression 
808         (   (   EQUAL^
809             |   NOT_EQUAL^
810             ) 
811             instanceOfExpression
812         )*
813     ;
814
815 instanceOfExpression
816     :   relationalExpression (INSTANCEOF^ type)?
817     ;
818
819 relationalExpression
820     :   shiftExpression 
821         (   (   LESS_OR_EQUAL^
822             |   GREATER_OR_EQUAL^
823             |   LESS_THAN^
824             |   GREATER_THAN^
825             )
826             shiftExpression
827         )*
828     ;
829     
830 shiftExpression
831     :   additiveExpression
832         (   (   BIT_SHIFT_RIGHT^
833             |   SHIFT_RIGHT^
834             |   SHIFT_LEFT^
835             )
836             additiveExpression
837         )*
838     ;
839
840 additiveExpression
841     :   multiplicativeExpression
842         (   (   PLUS^
843             |   MINUS^
844             )
845             multiplicativeExpression
846         )*
847     ;
848
849 multiplicativeExpression
850     :   unaryExpression 
851         (   (   STAR^
852             |   DIV^
853             |   MOD^
854             )
855             unaryExpression
856         )*
857     ;
858     
859 unaryExpression
860     :   PLUS unaryExpression        ->  ^(UNARY_PLUS[$PLUS, "UNARY_PLUS"] unaryExpression)
861     |   MINUS unaryExpression       ->  ^(UNARY_MINUS[$MINUS, "UNARY_MINUS"] unaryExpression)
862     |   INC postfixedExpression     ->  ^(PRE_INC[$INC, "PRE_INC"] postfixedExpression)
863     |   DEC postfixedExpression     ->  ^(PRE_DEC[$DEC, "PRE_DEC"] postfixedExpression)
864     |   unaryExpressionNotPlusMinus
865     ;
866
867 unaryExpressionNotPlusMinus
868     :   NOT unaryExpression                             ->  ^(NOT unaryExpression)
869     |   LOGICAL_NOT unaryExpression                     ->  ^(LOGICAL_NOT unaryExpression)
870     |   LPAREN type RPAREN unaryExpression              ->  ^(CAST_EXPR[$LPAREN, "CAST_EXPR"] type unaryExpression)
871     |   postfixedExpression
872     ;
873     
874 postfixedExpression
875         // At first resolve the primary expression ...
876     :   (   primaryExpression                       ->  primaryExpression
877         )
878         // ... and than the optional things that may follow a primary expression 0 or more times.
879         (   outerDot=DOT                            
880             (   (   genericTypeArgumentListSimplified?  // Note: generic type arguments are only valid for method calls, i.e. if there
881                                                         //       is an argument list.
882                     IDENT                           ->  ^(DOT $postfixedExpression IDENT)
883                 ) 
884                 (   arguments                       ->  ^(METHOD_CALL $postfixedExpression genericTypeArgumentListSimplified? arguments)
885                 )?
886             |   THIS                                ->  ^(DOT $postfixedExpression THIS)
887             |   Super=SUPER arguments                   ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"] $postfixedExpression arguments)
888             |   (   SUPER innerDot=DOT IDENT        ->  ^($innerDot ^($outerDot $postfixedExpression SUPER) IDENT)
889                 )
890                 (   arguments                       ->  ^(METHOD_CALL $postfixedExpression arguments)
891                 )?
892             |   innerNewExpression                  ->  ^(DOT $postfixedExpression innerNewExpression)
893             )
894         |   LBRACK expression RBRACK                ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression expression)
895         )*
896         // At the end there may follow a post increment/decrement.
897         (   INC -> ^(POST_INC[$INC, "POST_INC"] $postfixedExpression)
898         |   DEC -> ^(POST_DEC[$DEC, "POST_DEC"] $postfixedExpression)
899         )?
900     ;    
901     
902 primaryExpression
903     :   parenthesizedExpression
904     |   literal
905     |   newExpression
906     |   qualifiedIdentExpression
907     |   genericTypeArgumentListSimplified 
908         (   SUPER
909             (   arguments                               ->  ^(SUPER_CONSTRUCTOR_CALL[$SUPER, "SUPER_CONSTRUCTOR_CALL"] genericTypeArgumentListSimplified arguments)
910             |   DOT IDENT arguments                     ->  ^(METHOD_CALL ^(DOT SUPER IDENT) genericTypeArgumentListSimplified arguments)
911             )
912         |   IDENT arguments                             ->  ^(METHOD_CALL IDENT genericTypeArgumentListSimplified arguments)
913         |   THIS arguments                              ->  ^(THIS_CONSTRUCTOR_CALL[$THIS, "THIS_CONSTRUCTOR_CALL"] genericTypeArgumentListSimplified arguments)
914         )
915     |   (   THIS                                        ->  THIS
916         )
917         (   arguments                                   ->  ^(THIS_CONSTRUCTOR_CALL[$THIS, "THIS_CONSTRUCTOR_CALL"] arguments)
918         )?
919     |   SUPER arguments                                 ->  ^(SUPER_CONSTRUCTOR_CALL[$SUPER, "SUPER_CONSTRUCTOR_CALL"] arguments)
920     |   (   SUPER DOT IDENT
921         )
922         (   arguments                                   ->  ^(METHOD_CALL ^(DOT SUPER IDENT) arguments)
923         |                                               ->  ^(DOT SUPER IDENT)
924         )
925     |   (   primitiveType                               ->  primitiveType
926         )
927         (   arrayDeclarator                             ->  ^(arrayDeclarator $primaryExpression)   
928         )* 
929         DOT CLASS                                       ->  ^(DOT $primaryExpression CLASS)
930     |   VOID DOT CLASS                                  ->  ^(DOT VOID CLASS)
931     ;
932     
933 qualifiedIdentExpression
934         // The qualified identifier itself is the starting point for this rule.
935     :   (   qualifiedIdentifier                             ->  qualifiedIdentifier
936         )
937         // And now comes the stuff that may follow the qualified identifier.
938         (   (   arrayDeclarator                         ->  ^(arrayDeclarator $qualifiedIdentExpression)
939             )+ 
940             (   DOT CLASS                               ->  ^(DOT $qualifiedIdentExpression CLASS)
941             )
942         |   arguments                                   ->  ^(METHOD_CALL qualifiedIdentifier arguments)
943         |   outerDot=DOT
944             (   CLASS                                   ->  ^(DOT qualifiedIdentifier CLASS)
945             |   genericTypeArgumentListSimplified 
946                 (   Super=SUPER arguments               ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"] qualifiedIdentifier genericTypeArgumentListSimplified arguments)
947                 |   SUPER innerDot=DOT IDENT arguments  ->  ^(METHOD_CALL ^($innerDot ^($outerDot qualifiedIdentifier SUPER) IDENT) genericTypeArgumentListSimplified arguments)
948                 |   IDENT arguments                     ->  ^(METHOD_CALL ^(DOT qualifiedIdentifier IDENT) genericTypeArgumentListSimplified arguments)
949                 )
950             |   THIS                                    ->  ^(DOT qualifiedIdentifier THIS)
951             |   Super=SUPER arguments                   ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"] qualifiedIdentifier arguments)
952             |   innerNewExpression                      ->  ^(DOT qualifiedIdentifier innerNewExpression)
953             )
954         )?
955     ;
956
957 newExpression
958     :   NEW  
959         (   primitiveType newArrayConstruction      // new static array of primitive type elements
960             ->  ^(STATIC_ARRAY_CREATOR[$NEW, "STATIC_ARRAY_CREATOR"] primitiveType newArrayConstruction)
961         |   genericTypeArgumentListSimplified? qualifiedTypeIdentSimplified
962             (   newArrayConstruction                // new static array of object type reference elements
963                 ->  ^(STATIC_ARRAY_CREATOR[$NEW, "STATIC_ARRAY_CREATOR"] genericTypeArgumentListSimplified? qualifiedTypeIdentSimplified newArrayConstruction)
964             |   arguments classBody?                // new object type via constructor invocation
965                 ->  ^(CLASS_CONSTRUCTOR_CALL[$NEW, "STATIC_ARRAY_CREATOR"] genericTypeArgumentListSimplified? qualifiedTypeIdentSimplified arguments classBody?)
966             )
967         )
968     ;
969     
970 innerNewExpression // something like 'InnerType innerType = outer.new InnerType();'
971     :   NEW genericTypeArgumentListSimplified? IDENT arguments classBody?
972         ->  ^(CLASS_CONSTRUCTOR_CALL[$NEW, "STATIC_ARRAY_CREATOR"] genericTypeArgumentListSimplified? IDENT arguments classBody?)
973     ;
974
975 newArrayConstruction
976     :   arrayDeclaratorList arrayInitializer
977     |   LBRACK! expression RBRACK! (LBRACK! expression RBRACK!)* arrayDeclaratorList?
978     ;
979
980 arguments
981     :   LPAREN expressionList? RPAREN
982         ->  ^(ARGUMENT_LIST[$LPAREN, "ARGUMENT_LIST"] expressionList?)
983     ;
984
985 literal 
986     :   HEX_LITERAL
987     |   OCTAL_LITERAL
988     |   DECIMAL_LITERAL
989     |   FLOATING_POINT_LITERAL
990     |   CHARACTER_LITERAL
991     |   STRING_LITERAL
992     |   TRUE
993     |   FALSE
994     |   NULL
995     ;
996
997 // LEXER
998
999 HEX_LITERAL : '0' ('x'|'X') HEX_DIGIT+ INTEGER_TYPE_SUFFIX? ;
1000
1001 DECIMAL_LITERAL : ('0' | '1'..'9' '0'..'9'*) INTEGER_TYPE_SUFFIX? ;
1002
1003 OCTAL_LITERAL : '0' ('0'..'7')+ INTEGER_TYPE_SUFFIX? ;
1004
1005 fragment
1006 HEX_DIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ;
1007
1008 fragment
1009 INTEGER_TYPE_SUFFIX : ('l'|'L') ;
1010
1011 FLOATING_POINT_LITERAL
1012     :   ('0'..'9')+ 
1013         (
1014             DOT ('0'..'9')* EXPONENT? FLOAT_TYPE_SUFFIX?
1015         |   EXPONENT FLOAT_TYPE_SUFFIX?
1016         |   FLOAT_TYPE_SUFFIX
1017         )
1018     |   DOT ('0'..'9')+ EXPONENT? FLOAT_TYPE_SUFFIX?
1019     ;
1020
1021 fragment
1022 EXPONENT : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;
1023
1024 fragment
1025 FLOAT_TYPE_SUFFIX : ('f'|'F'|'d'|'D') ;
1026
1027 CHARACTER_LITERAL
1028     :   '\'' ( ESCAPE_SEQUENCE | ~('\''|'\\') ) '\''
1029     ;
1030
1031 STRING_LITERAL
1032     :  '"' ( ESCAPE_SEQUENCE | ~('\\'|'"') )* '"'
1033     ;
1034
1035 fragment
1036 ESCAPE_SEQUENCE
1037     :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
1038     |   UNICODE_ESCAPE
1039     |   OCTAL_ESCAPE
1040     ;
1041
1042 fragment
1043 OCTAL_ESCAPE
1044     :   '\\' ('0'..'3') ('0'..'7') ('0'..'7')
1045     |   '\\' ('0'..'7') ('0'..'7')
1046     |   '\\' ('0'..'7')
1047     ;
1048
1049 fragment
1050 UNICODE_ESCAPE
1051     :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
1052     ;
1053
1054 IDENT
1055     :   CHARJ_ID_START (CHARJ_ID_PART)*
1056     ;
1057
1058 fragment
1059 CHARJ_ID_START
1060     :  '\u0024'
1061     |  '\u0041'..'\u005a'
1062     |  '\u005f'
1063     |  '\u0061'..'\u007a'
1064     |  '\u00c0'..'\u00d6'
1065     |  '\u00d8'..'\u00f6'
1066     |  '\u00f8'..'\u00ff'
1067     |  '\u0100'..'\u1fff'
1068     |  '\u3040'..'\u318f'
1069     |  '\u3300'..'\u337f'
1070     |  '\u3400'..'\u3d2d'
1071     |  '\u4e00'..'\u9fff'
1072     |  '\uf900'..'\ufaff'
1073     ;
1074
1075 fragment
1076 CHARJ_ID_PART
1077     :  CHARJ_ID_START
1078     |  '\u0030'..'\u0039'
1079     ;
1080
1081 WS  :  (' '|'\r'|'\t'|'\u000C'|'\n') 
1082     {   
1083         if (!preserveWhitespacesAndComments) {
1084             skip();
1085         } else {
1086             $channel = HIDDEN;
1087         }
1088     }
1089     ;
1090
1091 EMBED_BLOCK
1092     :   DOUBLE_LCURLY
1093         ( options {greedy=false;} : . )* 
1094         DOUBLE_RCURLY 
1095     ;
1096
1097 COMMENT
1098     :   '/*' ( options {greedy=false;} : . )* '*/'
1099     {   
1100         if (!preserveWhitespacesAndComments) {
1101             skip();
1102         } else {
1103             $channel = HIDDEN;
1104         }
1105     }
1106     ;
1107
1108 LINE_COMMENT
1109     : '//' ~('\n'|'\r')* '\r'? '\n'
1110     {   
1111         if (!preserveWhitespacesAndComments) {
1112             skip();
1113         } else {
1114             $channel = HIDDEN;
1115         }
1116     }
1117     ;