e3299013b2521ab7c9d7ea8263b88c4dcad61e70
[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     PRIMITIVE_VAR_DECLARATION;
220     OBJECT_VAR_DECLARATION;
221     VAR_DECLARATOR;
222     VAR_DECLARATOR_LIST;
223     VOID_METHOD_DECL;
224 }
225
226 @header {
227 package charj.translator;
228 }
229
230 @members {
231     
232     private boolean mMessageCollectionEnabled = false;
233     private boolean mHasErrors = false;
234     private List<String> mMessages;
235
236     /**
237      *  Switches error message collection on or of.
238      *
239      *  The standard destination for parser error messages is <code>System.err</code>.
240      *  However, if <code>true</code> gets passed to this method this default
241      *  behaviour will be switched off and all error messages will be collected
242      *  instead of written to anywhere.
243      *
244      *  The default value is <code>false</code>.
245      *
246      *  @param pNewState  <code>true</code> if error messages should be collected.
247      */
248     public void enableErrorMessageCollection(boolean pNewState) {
249         mMessageCollectionEnabled = pNewState;
250         if (mMessages == null && mMessageCollectionEnabled) {
251             mMessages = new ArrayList<String>();
252         }
253     }
254     
255     /**
256      *  Collects an error message or passes the error message to <code>
257      *  super.emitErrorMessage(...)</code>.
258      *
259      *  The actual behaviour depends on whether collecting error messages
260      *  has been enabled or not.
261      *
262      *  @param pMessage  The error message.
263      */
264      @Override
265     public void emitErrorMessage(String pMessage) {
266         if (mMessageCollectionEnabled) {
267             mMessages.add(pMessage);
268         } else {
269             super.emitErrorMessage(pMessage);
270         }
271     }
272     
273     /**
274      *  Returns collected error messages.
275      *
276      *  @return  A list holding collected error messages or <code>null</code> if
277      *           collecting error messages hasn't been enabled. Of course, this
278      *           list may be empty if no error message has been emited.
279      */
280     public List<String> getMessages() {
281         return mMessages;
282     }
283     
284     /**
285      *  Tells if parsing a Charj source has caused any error messages.
286      *
287      *  @return  <code>true</code> if parsing a Charj source has caused at least
288      *           one error message.
289      */
290     public boolean hasErrors() {
291         return mHasErrors;
292     }
293 }
294
295 @lexer::header {
296 package charj.translator; 
297 }
298
299 @lexer::members {
300 /** 
301  *  Determines if whitespaces and comments should be preserved or thrown away.
302  *
303  *  If <code>true</code> whitespaces and comments will be preserved within the
304  *  hidden channel, otherwise the appropriate tokens will be skiped. This is
305  *  a 'little bit' expensive.
306  */
307 public boolean preserveWhitespacesAndComments = true;
308 }
309
310 // Starting point for parsing a Charj file.
311 charjSource
312     :   compilationUnit
313         ->  ^(CHARJ_SOURCE compilationUnit)
314     ;
315
316 compilationUnit
317     :   packageDeclaration? 
318         importDeclaration* 
319         typeDecls
320         //typeDecls*
321     ;
322
323 typeDecls
324     :   typeDeclaration
325     |   SEMI!
326     ;
327
328 packageDeclaration
329     :   PACKAGE^ qualifiedIdentifier SEMI!  
330     ;
331     
332 importDeclaration
333     :   IMPORT^ STATIC? qualifiedIdentifier DOTSTAR? SEMI!
334     ;
335     
336 typeDeclaration
337     :   modifierList!
338         (   classTypeDeclaration[$modifierList.tree]
339         |   interfaceTypeDeclaration[$modifierList.tree]
340         |   enumTypeDeclaration[$modifierList.tree]
341         )
342     ;
343     
344 classTypeDeclaration[CharjAST modifiers]
345     :   CLASS IDENT genericTypeParameterList? classExtendsClause? implementsClause? classBody
346         ->  ^(CLASS {$modifiers} IDENT genericTypeParameterList? classExtendsClause? implementsClause? classBody)
347     ;
348     
349 classExtendsClause
350     :   EXTENDS type
351         ->  ^(EXTENDS_CLAUSE[$EXTENDS, "EXTENDS_CLAUSE"] type)
352     ;   
353     
354 interfaceExtendsClause
355     :   EXTENDS typeList
356         ->  ^(EXTENDS_CLAUSE[$EXTENDS, "EXTENDS_CLAUSE"] typeList)
357     ;   
358     
359 implementsClause
360     :   IMPLEMENTS typeList
361         ->  ^(IMPLEMENTS_CLAUSE[$IMPLEMENTS, "IMPLEMENTS_CLAUSE"] typeList)
362     ;
363         
364 genericTypeParameterList
365     :   LESS_THAN genericTypeParameter (COMMA genericTypeParameter)* genericTypeListClosing
366         ->  ^(GENERIC_TYPE_PARAM_LIST[$LESS_THAN, "GENERIC_TYPE_PARAM_LIST"] genericTypeParameter+)
367     ;
368
369 genericTypeListClosing  // This 'trick' is fairly dirty - if there's some time a better solution should 
370                         // be found to resolve the problem with nested generic type parameter lists 
371                         // (i.e. <T1 extends AnyType<T2>> for generic type parameters or <T1<T2>> for 
372                         // generic type arguments etc). 
373     :   GREATER_THAN
374     |   SHIFT_RIGHT
375     |   BIT_SHIFT_RIGHT
376     |
377     ;
378
379 genericTypeParameter
380     :   IDENT bound?
381         ->  ^(IDENT bound?)
382     ;
383         
384 bound
385     :   EXTENDS type (AND type)*
386         ->  ^(EXTENDS_BOUND_LIST[$EXTENDS, "EXTENDS_BOUND_LIST"] type+)
387     ;
388
389 enumTypeDeclaration[CharjAST modifiers]
390     :   ENUM IDENT implementsClause? enumBody
391         ->  ^(ENUM {$modifiers} IDENT implementsClause? enumBody)
392     ;
393     
394 enumBody
395     :   LCURLY enumScopeDeclarations RCURLY
396         ->  ^(ENUM_TOP_LEVEL_SCOPE[$LCURLY, "ENUM_TOP_LEVEL_SCOPE"] enumScopeDeclarations)
397     ;
398
399 enumScopeDeclarations
400     :   enumConstants (COMMA!)? enumClassScopeDeclarations?
401     ;
402
403 enumClassScopeDeclarations
404     :   SEMI classScopeDeclarations*
405         ->  ^(CLASS_TOP_LEVEL_SCOPE[$SEMI, "CLASS_TOP_LEVEL_SCOPE"] classScopeDeclarations*)
406     ;
407
408 enumConstants
409     :   enumConstant (COMMA! enumConstant)*
410     ;
411     
412 enumConstant
413     :   IDENT^ arguments? classBody?
414     ;
415     
416 interfaceTypeDeclaration[CharjAST modifiers]
417     :   INTERFACE IDENT genericTypeParameterList? interfaceExtendsClause? interfaceBody
418         ->  ^(INTERFACE {$modifiers} IDENT genericTypeParameterList? interfaceExtendsClause? interfaceBody)
419     ;
420     
421 typeList
422     :   type (COMMA! type)*
423     ;
424     
425 classBody
426     :   LCURLY classScopeDeclarations* RCURLY
427         ->  ^(CLASS_TOP_LEVEL_SCOPE[$LCURLY, "CLASS_TOP_LEVEL_SCOPE"] classScopeDeclarations*)
428     ;
429     
430 interfaceBody
431     :   LCURLY interfaceScopeDeclarations* RCURLY
432         ->  ^(INTERFACE_TOP_LEVEL_SCOPE[$LCURLY, "CLASS_TOP_LEVEL_SCOPE"] interfaceScopeDeclarations*)
433     ;
434
435 classScopeDeclarations
436     :   block
437         ->  ^(CLASS_INSTANCE_INITIALIZER block)
438     |   STATIC block
439         ->  ^(CLASS_STATIC_INITIALIZER[$STATIC, "CLASS_STATIC_INITIALIZER"] block)
440     |   modifierList
441         (   genericTypeParameterList?
442             (   type IDENT formalParameterList arrayDeclaratorList? throwsClause? (block | SEMI)
443                 ->  ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause? block?)
444             |   VOID IDENT formalParameterList throwsClause? (block | SEMI)
445                 ->  ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block?)
446             |   ident=IDENT formalParameterList throwsClause? block
447                 ->  ^(CONSTRUCTOR_DECL[$ident, "CONSTRUCTOR_DECL"] modifierList genericTypeParameterList? IDENT formalParameterList throwsClause? block)
448             )
449         |   simpleType classFieldDeclaratorList SEMI
450             ->  ^(PRIMITIVE_VAR_DECLARATION modifierList simpleType classFieldDeclaratorList)
451         |   objectType classFieldDeclaratorList SEMI
452             ->  ^(OBJECT_VAR_DECLARATION modifierList objectType classFieldDeclaratorList)
453         )
454     |   typeDeclaration
455     |   SEMI!
456     ;
457             
458 interfaceScopeDeclarations
459     :   modifierList
460         (   genericTypeParameterList?
461             (   type IDENT formalParameterList arrayDeclaratorList? throwsClause? SEMI
462                 ->  ^(FUNCTION_METHOD_DECL modifierList genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList? throwsClause?)
463             |   VOID IDENT formalParameterList throwsClause? SEMI
464                 ->  ^(VOID_METHOD_DECL modifierList genericTypeParameterList? IDENT formalParameterList throwsClause?)
465             )
466         |   simpleType interfaceFieldDeclaratorList SEMI
467             ->  ^(PRIMITIVE_VAR_DECLARATION modifierList simpleType interfaceFieldDeclaratorList)
468         |   objectType interfaceFieldDeclaratorList SEMI
469             ->  ^(OBJECT_VAR_DECLARATION modifierList objectType interfaceFieldDeclaratorList)        
470         )
471     |   typeDeclaration
472     |   SEMI!
473     ;
474
475 classFieldDeclaratorList
476     :   classFieldDeclarator (COMMA classFieldDeclarator)*
477         ->  ^(VAR_DECLARATOR_LIST classFieldDeclarator+)
478     ;
479
480 classFieldDeclarator
481     :   variableDeclaratorId (ASSIGN variableInitializer)?
482         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
483     ;
484     
485 interfaceFieldDeclaratorList
486     :   interfaceFieldDeclarator (COMMA interfaceFieldDeclarator)*
487         ->  ^(VAR_DECLARATOR_LIST interfaceFieldDeclarator+)
488     ;
489
490 interfaceFieldDeclarator
491     :   variableDeclaratorId ASSIGN variableInitializer
492         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer)
493     ;
494     
495 variableDeclaratorId
496     :   IDENT^ arrayDeclaratorList?
497     ;
498
499 variableInitializer
500     :   arrayInitializer
501     |   expression
502     ;
503
504 arrayDeclarator
505     :   LBRACK RBRACK
506         ->  ^(ARRAY_DECLARATOR)
507     ;
508
509 arrayDeclaratorList
510     :   arrayDeclarator+
511         ->  ^(ARRAY_DECLARATOR_LIST arrayDeclarator+)   
512     ;
513     
514 arrayInitializer
515     :   LCURLY (variableInitializer (COMMA variableInitializer)* COMMA?)? RCURLY
516         ->  ^(ARRAY_INITIALIZER[$LCURLY, "ARRAY_INITIALIZER"] variableInitializer*)
517     ;
518
519 throwsClause
520     :   THROWS qualifiedIdentList
521         ->  ^(THROWS_CLAUSE[$THROWS, "THROWS_CLAUSE"] qualifiedIdentList)
522     ;
523
524 modifierList
525     :   modifier*   
526         ->  ^(MODIFIER_LIST modifier*)
527     ;
528
529 modifier
530     :   PUBLIC
531     |   PROTECTED
532     |   ENTRY
533     |   PRIVATE
534     |   STATIC
535     |   ABSTRACT
536     |   NATIVE
537     |   SYNCHRONIZED
538     |   TRANSIENT
539     |   VOLATILE
540     |   localModifier
541     ;
542
543 localModifierList
544     :   localModifier*
545         -> ^(LOCAL_MODIFIER_LIST localModifier*)
546     ;
547     
548 localModifier
549     :   FINAL
550     ;
551
552 type
553     :   simpleType
554     |   objectType
555     ;
556
557 simpleType // including static arrays of simple type elements
558     :   primitiveType arrayDeclaratorList?
559         ->  ^(TYPE primitiveType arrayDeclaratorList?)  
560     ;
561     
562 objectType // including static arrays of object type reference elements
563     :   qualifiedTypeIdent arrayDeclaratorList?
564         ->  ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
565     ;
566
567 objectTypeSimplified
568     :   qualifiedTypeIdentSimplified arrayDeclaratorList?
569         ->  ^(TYPE qualifiedTypeIdentSimplified arrayDeclaratorList?)
570     ;
571
572 qualifiedTypeIdent
573     :   typeIdent (DOT typeIdent)*
574         ->  ^(QUALIFIED_TYPE_IDENT typeIdent+) 
575     ;
576
577 qualifiedTypeIdentSimplified
578     :   typeIdentSimplified (DOT typeIdentSimplified)*
579         ->  ^(QUALIFIED_TYPE_IDENT typeIdentSimplified+) 
580     ;
581
582 typeIdent
583     :   IDENT^ genericTypeArgumentList?
584     ;
585
586 typeIdentSimplified
587     :   IDENT^ genericTypeArgumentListSimplified?
588     ;
589
590 primitiveType
591     :   BOOLEAN
592     |   CHAR
593     |   BYTE
594     |   SHORT
595     |   INT
596     |   LONG
597     |   FLOAT
598     |   DOUBLE
599     ;
600
601 genericTypeArgumentList
602     :   LESS_THAN genericTypeArgument (COMMA genericTypeArgument)* genericTypeListClosing
603         ->  ^(GENERIC_TYPE_ARG_LIST[$LESS_THAN, "GENERIC_TYPE_ARG_LIST"] genericTypeArgument+)
604     ;
605
606 genericTypeArgument
607     :   type
608     |   QUESTION genericWildcardBoundType?
609         ->  ^(QUESTION genericWildcardBoundType?)
610     ;
611     
612 genericWildcardBoundType
613     :   (EXTENDS | SUPER)^ type
614     ;
615
616 genericTypeArgumentListSimplified
617     :   LESS_THAN genericTypeArgumentSimplified (COMMA genericTypeArgumentSimplified)* genericTypeListClosing
618         ->  ^(GENERIC_TYPE_ARG_LIST[$LESS_THAN, "GENERIC_TYPE_ARG_LIST"] genericTypeArgumentSimplified+)
619     ;
620     
621 genericTypeArgumentSimplified
622     :   type
623     |   QUESTION
624     ;
625     
626 qualifiedIdentList
627     :   qualifiedIdentifier (COMMA! qualifiedIdentifier)*
628     ;
629     
630 formalParameterList
631     :   LPAREN 
632         (   // Contains at least one standard argument declaration and optionally a variable argument declaration.
633             formalParameterStandardDecl (COMMA formalParameterStandardDecl)* (COMMA formalParameterVarArgDecl)? 
634             ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"] formalParameterStandardDecl+ formalParameterVarArgDecl?) 
635             // Contains a variable argument declaration only.
636         |   formalParameterVarArgDecl
637             ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"] formalParameterVarArgDecl) 
638             // Contains nothing.
639         |   ->  ^(FORMAL_PARAM_LIST[$LPAREN, "FORMAL_PARAM_LIST"]) 
640         )
641         RPAREN
642     ;
643     
644 formalParameterStandardDecl
645     :   localModifierList type variableDeclaratorId
646         ->  ^(FORMAL_PARAM_STD_DECL localModifierList type variableDeclaratorId)
647     ;
648     
649 formalParameterVarArgDecl
650     :   localModifierList type ELLIPSIS variableDeclaratorId
651         ->  ^(FORMAL_PARAM_VARARG_DECL localModifierList type variableDeclaratorId)
652     ;
653     
654 qualifiedIdentifier
655     :   (   IDENT
656             ->  IDENT
657         )
658         (   DOT ident=IDENT
659             ->  ^(DOT $qualifiedIdentifier $ident)
660         )*
661     ;
662     
663 block
664     :   LCURLY blockStatement* RCURLY
665         ->  ^(BLOCK_SCOPE[$LCURLY, "BLOCK_SCOPE"] blockStatement*)
666     ;
667
668 blockStatement
669     :   localVariableDeclaration SEMI!
670     |   typeDeclaration
671     |   statement
672     ;
673     
674 localVariableDeclaration
675     :   localModifierList simpleType classFieldDeclaratorList
676         ->  ^(PRIMITIVE_VAR_DECLARATION localModifierList simpleType classFieldDeclaratorList)
677     |   localModifierList objectType classFieldDeclaratorList
678         ->  ^(OBJECT_VAR_DECLARATION localModifierList objectType classFieldDeclaratorList)
679     ;
680     
681         
682 statement
683     :   block
684     |   ASSERT expr1=expression 
685         (   COLON expr2=expression SEMI
686             ->  ^(ASSERT $expr1 $expr2)
687         |   SEMI
688             ->  ^(ASSERT $expr1)
689         )
690     |   IF parenthesizedExpression ifStat=statement 
691         (   ELSE elseStat=statement
692             ->  ^(IF parenthesizedExpression $ifStat $elseStat)
693         |
694             ->  ^(IF parenthesizedExpression $ifStat)
695         )   
696     |   FOR LPAREN 
697         (   forInit SEMI forCondition SEMI forUpdater RPAREN statement
698             ->  ^(FOR forInit forCondition forUpdater statement) 
699         |   localModifierList type IDENT COLON expression RPAREN statement
700             ->  ^(FOR_EACH[$FOR, "FOR_EACH"] localModifierList type IDENT expression statement)
701         ) 
702     |   WHILE parenthesizedExpression statement
703         ->  ^(WHILE parenthesizedExpression statement)
704     |   DO statement WHILE parenthesizedExpression SEMI
705         ->  ^(DO statement parenthesizedExpression)
706     |   TRY block (catches finallyClause? | finallyClause)
707         ->  ^(TRY block catches? finallyClause?)
708     |   SWITCH parenthesizedExpression LCURLY switchBlockLabels RCURLY
709         ->  ^(SWITCH parenthesizedExpression switchBlockLabels)
710     |   SYNCHRONIZED parenthesizedExpression block
711         ->  ^(SYNCHRONIZED parenthesizedExpression block)
712     |   RETURN expression? SEMI
713         ->  ^(RETURN expression?)
714     |   THROW expression SEMI
715         ->  ^(THROW expression)
716     |   BREAK IDENT? SEMI
717         ->  ^(BREAK IDENT?)
718     |   CONTINUE IDENT? SEMI
719         ->  ^(CONTINUE IDENT?)
720     |   IDENT COLON statement
721         ->  ^(LABELED_STATEMENT IDENT statement)
722     |   EMBED STRING_LITERAL EMBED_BLOCK
723         ->  ^(EMBED STRING_LITERAL EMBED_BLOCK)
724     |   expression SEMI!
725     |   SEMI // Preserve empty statements.
726     ;           
727         
728 catches
729     :   catchClause+
730         ->  ^(CATCH_CLAUSE_LIST catchClause+)
731     ;
732     
733 catchClause
734     :   CATCH^ LPAREN! formalParameterStandardDecl RPAREN! block
735     ;
736
737 finallyClause
738     :   FINALLY block
739         ->  block
740     ;
741
742 switchBlockLabels
743     :   switchCaseLabels switchDefaultLabel? switchCaseLabels
744         ->  ^(SWITCH_BLOCK_LABEL_LIST switchCaseLabels switchDefaultLabel? switchCaseLabels)
745     ;
746     
747 switchCaseLabels
748     :   switchCaseLabel*
749     ;
750         
751 switchCaseLabel
752     :   CASE^ expression COLON! blockStatement*
753     ;
754     
755 switchDefaultLabel
756     :   DEFAULT^ COLON! blockStatement*
757     ;
758     
759 forInit
760     :   localVariableDeclaration
761         ->  ^(FOR_INIT localVariableDeclaration)
762     |   expressionList
763         ->  ^(FOR_INIT expressionList)
764     |
765         ->  ^(FOR_INIT)
766     ;
767     
768 forCondition
769     :   expression?
770         ->  ^(FOR_CONDITION expression?)
771     ;
772     
773 forUpdater
774     :   expressionList?
775         ->  ^(FOR_UPDATE expressionList?)
776     ;
777
778 // EXPRESSIONS
779
780 parenthesizedExpression
781     :   LPAREN expression RPAREN
782         ->  ^(PARENTESIZED_EXPR[$LPAREN, "PARENTESIZED_EXPR"] expression)
783     ;
784     
785 expressionList
786     :   expression (COMMA! expression)*
787     ;
788
789 expression
790     :   assignmentExpression
791         ->  ^(EXPR assignmentExpression)
792     ;
793
794 assignmentExpression
795     :   conditionalExpression 
796         (   (   ASSIGN^
797             |   PLUS_ASSIGN^
798             |   MINUS_ASSIGN^
799             |   STAR_ASSIGN^
800             |   DIV_ASSIGN^
801             |   AND_ASSIGN^
802             |   OR_ASSIGN^
803             |   XOR_ASSIGN^
804             |   MOD_ASSIGN^
805             |   SHIFT_LEFT_ASSIGN^
806             |   SHIFT_RIGHT_ASSIGN^
807             |   BIT_SHIFT_RIGHT_ASSIGN^
808         ) 
809         assignmentExpression)?
810     ;
811     
812 conditionalExpression
813     :   logicalOrExpression (QUESTION^ assignmentExpression COLON! conditionalExpression)?
814     ;
815
816 logicalOrExpression
817     :   logicalAndExpression (LOGICAL_OR^ logicalAndExpression)*
818     ;
819
820 logicalAndExpression
821     :   inclusiveOrExpression (LOGICAL_AND^ inclusiveOrExpression)*
822     ;
823
824 inclusiveOrExpression
825     :   exclusiveOrExpression (OR^ exclusiveOrExpression)*
826     ;
827
828 exclusiveOrExpression
829     :   andExpression (XOR^ andExpression)*
830     ;
831
832 andExpression
833     :   equalityExpression (AND^ equalityExpression)*
834     ;
835
836 equalityExpression
837     :   instanceOfExpression 
838         (   (   EQUAL^
839             |   NOT_EQUAL^
840             ) 
841             instanceOfExpression
842         )*
843     ;
844
845 instanceOfExpression
846     :   relationalExpression (INSTANCEOF^ type)?
847     ;
848
849 relationalExpression
850     :   shiftExpression 
851         (   (   LESS_OR_EQUAL^
852             |   GREATER_OR_EQUAL^
853             |   LESS_THAN^
854             |   GREATER_THAN^
855             )
856             shiftExpression
857         )*
858     ;
859     
860 shiftExpression
861     :   additiveExpression
862         (   (   BIT_SHIFT_RIGHT^
863             |   SHIFT_RIGHT^
864             |   SHIFT_LEFT^
865             )
866             additiveExpression
867         )*
868     ;
869
870 additiveExpression
871     :   multiplicativeExpression
872         (   (   PLUS^
873             |   MINUS^
874             )
875             multiplicativeExpression
876         )*
877     ;
878
879 multiplicativeExpression
880     :   unaryExpression 
881         (   (   STAR^
882             |   DIV^
883             |   MOD^
884             )
885             unaryExpression
886         )*
887     ;
888     
889 unaryExpression
890     :   PLUS unaryExpression
891         ->  ^(UNARY_PLUS[$PLUS, "UNARY_PLUS"] unaryExpression)
892     |   MINUS unaryExpression
893         ->  ^(UNARY_MINUS[$MINUS, "UNARY_MINUS"] unaryExpression)
894     |   INC postfixedExpression
895         ->  ^(PRE_INC[$INC, "PRE_INC"] postfixedExpression)
896     |   DEC postfixedExpression
897         ->  ^(PRE_DEC[$DEC, "PRE_DEC"] postfixedExpression)
898     |   unaryExpressionNotPlusMinus
899     ;
900
901 unaryExpressionNotPlusMinus
902     :   NOT unaryExpression
903         ->  ^(NOT unaryExpression)
904     |   LOGICAL_NOT unaryExpression
905         ->  ^(LOGICAL_NOT unaryExpression)
906     |   LPAREN type RPAREN unaryExpression
907         ->  ^(CAST_EXPR[$LPAREN, "CAST_EXPR"] type unaryExpression)
908     |   postfixedExpression
909     ;
910     
911 postfixedExpression
912         // At first resolve the primary expression ...
913     :   (   primaryExpression
914             ->  primaryExpression
915         )
916         // ... and than the optional things that may follow a primary
917         // expression 0 or more times.
918         (   outerDot=DOT                            
919             // Note: generic type arguments are only valid for method calls,
920             // i.e. if there is an argument list
921             (   (   genericTypeArgumentListSimplified?  
922                     IDENT
923                     ->  ^(DOT $postfixedExpression IDENT)
924                 ) 
925                 (   arguments
926                     ->  ^(METHOD_CALL $postfixedExpression genericTypeArgumentListSimplified? arguments)
927                 )?
928             |   THIS
929                 ->  ^(DOT $postfixedExpression THIS)
930             |   Super=SUPER arguments
931                 ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"] $postfixedExpression arguments)
932             |   (   SUPER innerDot=DOT IDENT
933                     ->  ^($innerDot ^($outerDot $postfixedExpression SUPER) IDENT)
934                 )
935                 (   arguments
936                     ->  ^(METHOD_CALL $postfixedExpression arguments)
937                 )?
938             |   innerNewExpression
939                 ->  ^(DOT $postfixedExpression innerNewExpression)
940             )
941         |   LBRACK expression RBRACK
942             ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression expression)
943         )*
944         // At the end there may follow a post increment/decrement.
945         (   INC -> ^(POST_INC[$INC, "POST_INC"] $postfixedExpression)
946         |   DEC -> ^(POST_DEC[$DEC, "POST_DEC"] $postfixedExpression)
947         )?
948     ;    
949     
950 primaryExpression
951     :   parenthesizedExpression
952     |   literal
953     |   newExpression
954     |   qualifiedIdentExpression
955     |   genericTypeArgumentListSimplified 
956         (   SUPER
957             (   arguments
958                 ->  ^(SUPER_CONSTRUCTOR_CALL[$SUPER, "SUPER_CONSTRUCTOR_CALL"] genericTypeArgumentListSimplified arguments)
959             |   DOT IDENT arguments
960                 ->  ^(METHOD_CALL ^(DOT SUPER IDENT) genericTypeArgumentListSimplified arguments)
961             )
962         |   IDENT arguments
963             ->  ^(METHOD_CALL IDENT genericTypeArgumentListSimplified arguments)
964         |   THIS arguments
965             ->  ^(THIS_CONSTRUCTOR_CALL[$THIS, "THIS_CONSTRUCTOR_CALL"] genericTypeArgumentListSimplified arguments)
966         )
967     |   (   THIS
968             ->  THIS
969         )
970         (   arguments
971             ->  ^(THIS_CONSTRUCTOR_CALL[$THIS, "THIS_CONSTRUCTOR_CALL"] arguments)
972         )?
973     |   SUPER arguments
974         ->  ^(SUPER_CONSTRUCTOR_CALL[$SUPER, "SUPER_CONSTRUCTOR_CALL"] arguments)
975     |   (   SUPER DOT IDENT
976         )
977         (   arguments
978             ->  ^(METHOD_CALL ^(DOT SUPER IDENT) arguments)
979         |   ->  ^(DOT SUPER IDENT)
980         )
981     |   (   primitiveType
982             ->  primitiveType
983         )
984         (   arrayDeclarator
985             ->  ^(arrayDeclarator $primaryExpression)   
986         )* 
987         DOT CLASS
988         ->  ^(DOT $primaryExpression CLASS)
989     |   VOID DOT CLASS
990         ->  ^(DOT VOID CLASS)
991     ;
992     
993 qualifiedIdentExpression
994         // The qualified identifier itself is the starting point for this rule.
995     :   (   qualifiedIdentifier
996             ->  qualifiedIdentifier
997         )
998         // And now comes the stuff that may follow the qualified identifier.
999         (   (   arrayDeclarator
1000                 ->  ^(arrayDeclarator $qualifiedIdentExpression)
1001             )+ 
1002             (   DOT CLASS
1003                 ->  ^(DOT $qualifiedIdentExpression CLASS)
1004             )
1005         |   arguments
1006             ->  ^(METHOD_CALL qualifiedIdentifier arguments)
1007         |   outerDot=DOT
1008             (   CLASS
1009                 ->  ^(DOT qualifiedIdentifier CLASS)
1010             |   genericTypeArgumentListSimplified 
1011                 (   Super=SUPER arguments
1012                     ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"]
1013                             qualifiedIdentifier genericTypeArgumentListSimplified arguments)
1014                 |   SUPER innerDot=DOT IDENT arguments
1015                     ->  ^(METHOD_CALL ^($innerDot ^($outerDot qualifiedIdentifier SUPER) IDENT)
1016                             genericTypeArgumentListSimplified arguments)
1017                 |   IDENT arguments
1018                     ->  ^(METHOD_CALL ^(DOT qualifiedIdentifier IDENT) genericTypeArgumentListSimplified arguments)
1019                 )
1020             |   THIS
1021                 ->  ^(DOT qualifiedIdentifier THIS)
1022             |   Super=SUPER arguments
1023                 ->  ^(SUPER_CONSTRUCTOR_CALL[$Super, "SUPER_CONSTRUCTOR_CALL"] qualifiedIdentifier arguments)
1024             |   innerNewExpression
1025                 ->  ^(DOT qualifiedIdentifier innerNewExpression)
1026             )
1027         )?
1028     ;
1029
1030 newExpression
1031     :   NEW  
1032             (   primitiveType newArrayConstruction      // new static array of primitive type elements
1033                 ->  ^(STATIC_ARRAY_CREATOR[$NEW, "STATIC_ARRAY_CREATOR"] primitiveType newArrayConstruction
1034             )
1035     |   genericTypeArgumentListSimplified? qualifiedTypeIdentSimplified
1036             (   newArrayConstruction                // new static array of object type reference elements
1037                 ->  ^(STATIC_ARRAY_CREATOR[$NEW, "STATIC_ARRAY_CREATOR"] 
1038                     genericTypeArgumentListSimplified? qualifiedTypeIdentSimplified newArrayConstruction
1039             )
1040     |   arguments classBody?                // new object type via constructor invocation
1041                 ->  ^(CLASS_CONSTRUCTOR_CALL[$NEW, "STATIC_ARRAY_CREATOR"] genericTypeArgumentListSimplified? 
1042                     qualifiedTypeIdentSimplified arguments classBody?)
1043             )
1044         )
1045     ;
1046     
1047 innerNewExpression // something like 'InnerType innerType = outer.new InnerType();'
1048     :   NEW genericTypeArgumentListSimplified? IDENT arguments classBody?
1049         ->  ^(CLASS_CONSTRUCTOR_CALL[$NEW, "STATIC_ARRAY_CREATOR"] genericTypeArgumentListSimplified? IDENT arguments classBody?)
1050     ;
1051
1052 newArrayConstruction
1053     :   arrayDeclaratorList arrayInitializer
1054     |   LBRACK! expression RBRACK! (LBRACK! expression RBRACK!)* arrayDeclaratorList?
1055     ;
1056
1057 arguments
1058     :   LPAREN expressionList? RPAREN
1059         ->  ^(ARGUMENT_LIST[$LPAREN, "ARGUMENT_LIST"] expressionList?)
1060     ;
1061
1062 literal 
1063     :   HEX_LITERAL
1064     |   OCTAL_LITERAL
1065     |   DECIMAL_LITERAL
1066     |   FLOATING_POINT_LITERAL
1067     |   CHARACTER_LITERAL
1068     |   STRING_LITERAL
1069     |   TRUE
1070     |   FALSE
1071     |   NULL
1072     ;
1073
1074 // LEXER
1075
1076 HEX_LITERAL : '0' ('x'|'X') HEX_DIGIT+ INTEGER_TYPE_SUFFIX? ;
1077
1078 DECIMAL_LITERAL : ('0' | '1'..'9' '0'..'9'*) INTEGER_TYPE_SUFFIX? ;
1079
1080 OCTAL_LITERAL : '0' ('0'..'7')+ INTEGER_TYPE_SUFFIX? ;
1081
1082 fragment
1083 HEX_DIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ;
1084
1085 fragment
1086 INTEGER_TYPE_SUFFIX : ('l'|'L') ;
1087
1088 FLOATING_POINT_LITERAL
1089     :   ('0'..'9')+ 
1090         (
1091             DOT ('0'..'9')* EXPONENT? FLOAT_TYPE_SUFFIX?
1092         |   EXPONENT FLOAT_TYPE_SUFFIX?
1093         |   FLOAT_TYPE_SUFFIX
1094         )
1095     |   DOT ('0'..'9')+ EXPONENT? FLOAT_TYPE_SUFFIX?
1096     ;
1097
1098 fragment
1099 EXPONENT : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;
1100
1101 fragment
1102 FLOAT_TYPE_SUFFIX : ('f'|'F'|'d'|'D') ;
1103
1104 CHARACTER_LITERAL
1105     :   '\'' ( ESCAPE_SEQUENCE | ~('\''|'\\') ) '\''
1106     ;
1107
1108 STRING_LITERAL
1109     :  '"' ( ESCAPE_SEQUENCE | ~('\\'|'"') )* '"'
1110     ;
1111
1112 fragment
1113 ESCAPE_SEQUENCE
1114     :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
1115     |   UNICODE_ESCAPE
1116     |   OCTAL_ESCAPE
1117     ;
1118
1119 fragment
1120 OCTAL_ESCAPE
1121     :   '\\' ('0'..'3') ('0'..'7') ('0'..'7')
1122     |   '\\' ('0'..'7') ('0'..'7')
1123     |   '\\' ('0'..'7')
1124     ;
1125
1126 fragment
1127 UNICODE_ESCAPE
1128     :   '\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
1129     ;
1130
1131 IDENT
1132     :   CHARJ_ID_START (CHARJ_ID_PART)*
1133     ;
1134
1135 fragment
1136 CHARJ_ID_START
1137     :  '\u0024'
1138     |  '\u0041'..'\u005a'
1139     |  '\u005f'
1140     |  '\u0061'..'\u007a'
1141     |  '\u00c0'..'\u00d6'
1142     |  '\u00d8'..'\u00f6'
1143     |  '\u00f8'..'\u00ff'
1144     |  '\u0100'..'\u1fff'
1145     |  '\u3040'..'\u318f'
1146     |  '\u3300'..'\u337f'
1147     |  '\u3400'..'\u3d2d'
1148     |  '\u4e00'..'\u9fff'
1149     |  '\uf900'..'\ufaff'
1150     ;
1151
1152 fragment
1153 CHARJ_ID_PART
1154     :  CHARJ_ID_START
1155     |  '\u0030'..'\u0039'
1156     ;
1157
1158 WS  :  (' '|'\r'|'\t'|'\u000C'|'\n') 
1159     {   
1160         if (!preserveWhitespacesAndComments) {
1161             skip();
1162         } else {
1163             $channel = HIDDEN;
1164         }
1165     }
1166     ;
1167
1168 EMBED_BLOCK
1169     :   DOUBLE_LCURLY
1170         ( options {greedy=false;} : . )* 
1171         DOUBLE_RCURLY 
1172     ;
1173
1174 COMMENT
1175     :   '/*' ( options {greedy=false;} : . )* '*/'
1176     {   
1177         if (!preserveWhitespacesAndComments) {
1178             skip();
1179         } else {
1180             $channel = HIDDEN;
1181         }
1182     }
1183     ;
1184
1185 LINE_COMMENT
1186     : '//' ~('\n'|'\r')* '\r'? '\n'
1187     {   
1188         if (!preserveWhitespacesAndComments) {
1189             skip();
1190         } else {
1191             $channel = HIDDEN;
1192         }
1193     }
1194     ;