fixed a compiler warning
[charm.git] / src / langs / jade / java.g
1 header {
2 // java.g header
3 package jade;
4 }
5
6 {
7 // java.g class preamble
8 import jade.JJ.ClassNode;
9 }
10
11 /** Java 1.3 Recognizer
12  *
13  * Run 'java Main [-showtree] directory-full-of-java-files'
14  *
15  * [The -showtree option pops up a Swing frame that shows
16  *  the AST constructed from the parser.]
17  * 
18  * Run 'java Main <directory full of java files>'
19  *
20  * Contributing authors:
21  *              John Mitchell           johnm@non.net
22  *              Terence Parr            parrt@magelang.com
23  *              John Lilley                     jlilley@empathy.com
24  *              Scott Stanchfield       thetick@magelang.com
25  *              Markus Mohnen       mohnen@informatik.rwth-aachen.de
26  *      Peter Williams      pete.williams@sun.com
27  *      Allan Jacobs        Allan.Jacobs@eng.sun.com
28  *      Steve Messick       messick@redhills.com
29  *
30  * Version 1.00 December 9, 1997 -- initial release
31  * Version 1.01 December 10, 1997
32  *              fixed bug in octal def (0..7 not 0..8)
33  * Version 1.10 August 1998 (parrt)
34  *              added tree construction
35  *              fixed definition of WS,comments for mac,pc,unix newlines
36  *              added unary plus
37  * Version 1.11 (Nov 20, 1998)
38  *              Added "shutup" option to turn off last ambig warning.
39  *              Fixed inner class def to allow named class defs as statements
40  *              synchronized requires compound not simple statement
41  *              add [] after builtInType DOT class in primaryExpression
42  *              "const" is reserved but not valid..removed from modifiers
43  * Version 1.12 (Feb 2, 1999)
44  *              Changed LITERAL_xxx to xxx in tree grammar.
45  *              Updated java.g to use tokens {...} now for 2.6.0 (new feature).
46  *
47  * Version 1.13 (Apr 23, 1999)
48  *              Didn't have (stat)? for else clause in tree parser.
49  *              Didn't gen ASTs for interface extends.  Updated tree parser too.
50  *              Updated to 2.6.0.
51  * Version 1.14 (Jun 20, 1999)
52  *              Allowed final/abstract on local classes.
53  *              Removed local interfaces from methods
54  *              Put instanceof precedence where it belongs...in relationalExpr
55  *                      It also had expr not type as arg; fixed it.
56  *              Missing ! on SEMI in classBlock
57  *              fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
58  *              fixed: didn't like Object[].class in parser or tree parser
59  * Version 1.15 (Jun 26, 1999)
60  *              Screwed up rule with instanceof in it. :(  Fixed.
61  *              Tree parser didn't like (expr).something; fixed.
62  *              Allowed multiple inheritance in tree grammar. oops.
63  * Version 1.16 (August 22, 1999)
64  *              Extending an interface built a wacky tree: had extra EXTENDS.
65  *              Tree grammar didn't allow multiple superinterfaces.
66  *              Tree grammar didn't allow empty var initializer: {}
67  * Version 1.17 (October 12, 1999)
68  *              ESC lexer rule allowed 399 max not 377 max.
69  *              java.tree.g didn't handle the expression of synchronized
70  *              statements.
71  * Version 1.18 (August 12, 2001)
72  *      Terence updated to Java 2 Version 1.3 by observing/combining work of
73  *      Allan Jacobs and Steve Messick.  Handles 1.3 src.
74  *              Summary:
75  *              o  primary didn't include boolean.class kind of thing
76  *      o  constructor calls parsed explicitly now:
77  *                 see explicitConstructorInvocation
78  *              o  add strictfp modifier
79  *      o  missing objBlock after new expression in tree grammar
80  *              o  merged local class definition alternatives, moved after declaration
81  *              o  fixed problem with ClassName.super.field
82  *      o  reordered some alternatives to make things more efficient
83  *              o  long and double constants were not differentiated from int/float
84  *              o  whitespace rule was inefficient: matched only one char
85  *              o  add an examples directory with some nasty 1.3 cases
86  *              o  made Main.java use buffered IO and a Reader for Unicode support
87  *              o  supports UNICODE?
88  *                 Using Unicode charVocabulay makes code file big, but only
89  *                 in the bitsets at the end. I need to make ANTLR generate
90  *                 unicode bitsets more efficiently.
91  *
92  * class Test {
93  *   public static void main( String args[] ) {
94  *     if (boolean.class.equals(boolean.class)) {
95  *       System.out.println("works");
96  *     }
97  *   }
98  * }
99  *
100  * This grammar is in the PUBLIC DOMAIN
101  */
102 class JavaRecognizer extends Parser;
103 options {
104         k = 2;                           // two token lookahead
105         exportVocab=Java;                // Call its vocabulary "Java"
106         codeGenMakeSwitchThreshold = 2;  // Some optimizations
107         codeGenBitsetTestThreshold = 3;
108         defaultErrorHandler = false;     // Don't generate parser error handlers
109         buildAST = true;
110 }
111
112 tokens {
113         BLOCK; MODIFIERS; OBJBLOCK; SLIST; CTOR_DEF; METHOD_DEF; VARIABLE_DEF; 
114         INSTANCE_INIT; STATIC_INIT; TYPE; CLASS_DEF; INTERFACE_DEF; 
115         PACKAGE_DEF; ARRAY_DECLARATOR; EXTENDS_CLAUSE; IMPLEMENTS_CLAUSE;
116         PARAMETERS; PARAMETER_DEF; LABELED_STAT; TYPECAST; INDEX_OP; 
117         POST_INC; POST_DEC; METHOD_CALL; EXPR; ARRAY_INIT; 
118         IMPORT; UNARY_MINUS; UNARY_PLUS; CASE_GROUP; ELIST; FOR_INIT; FOR_CONDITION; 
119         FOR_ITERATOR; EMPTY_STAT; FINAL="final"; ABSTRACT="abstract";
120         STRICTFP="strictfp"; SUPER_CTOR_CALL; CTOR_CALL; TEMPLATE;
121 }
122         
123 // Compilation Unit: In Java, this is a single file.  This is the start
124 //   rule for this parser
125 compilationUnit
126         :       // A compilation unit starts with an optional package definition
127                 (       packageDefinition
128                 |       /* nothing */
129                 )
130
131                 // Next we have a series of zero or more import statements
132                 ( importDefinition )*
133
134                 // Wrapping things up with any number of class or interface
135                 //    definitions
136                 ( typeDefinition )*
137
138                 EOF!
139         ;
140
141
142 // Package statement: "package" followed by an identifier.
143 packageDefinition
144         options {defaultErrorHandler = true;} // let ANTLR handle errors
145         :       p:"package"^ {#p.setType(PACKAGE_DEF);} identifier SEMI!
146         ;
147
148
149 // Import statement: import followed by a package or class name
150 importDefinition
151         options {defaultErrorHandler = true;}
152         :       i:"import"^ {#i.setType(IMPORT);} identifierStar SEMI!
153         ;
154
155 // A type definition in a file is either a class or interface definition.
156 typeDefinition
157         options {defaultErrorHandler = true;}
158         :       m:modifiers!
159                 ( classDefinition[#m]
160                 | interfaceDefinition[#m]
161                 )
162         |       SEMI!
163         ;
164
165 /** A declaration is the creation of a reference or primitive-type variable
166  *  Create a separate Type/Var tree for each var in the var list.
167  */
168 declaration!
169         :       m:modifiers t:typeSpec[false] v:variableDefinitions[#m,#t]
170                 {#declaration = #v;}
171         ;
172
173 // A type specification is a type name with possible brackets afterwards
174 //   (which would make it an array type).
175 typeSpec[boolean addImagNode]
176         : classTypeSpec[addImagNode]
177         | builtInTypeSpec[addImagNode]
178         ;
179
180 // A class type specification is a class type with possible brackets afterwards
181 //   (which would make it an array type).
182 classTypeSpec[boolean addImagNode]
183         :       identifier (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
184                 {
185                         if ( addImagNode ) {
186                                 #classTypeSpec = #(#[TYPE,"TYPE"], #classTypeSpec);
187                         }
188                 }
189 //          | identifier lt:LT^ {#lt.setType(TEMPLATE);} GT!
190 //              {
191 //                      if ( addImagNode ) {
192 //                              #classTypeSpec = #(#[TYPE,"TYPE"], #classTypeSpec);
193 //                      }
194 //              }
195         ;
196
197 // A builtin type specification is a builtin type with possible brackets
198 // afterwards (which would make it an array type).
199 builtInTypeSpec[boolean addImagNode]
200         :       builtInType (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
201                 {
202                         if ( addImagNode ) {
203                                 #builtInTypeSpec = #(#[TYPE,"TYPE"], #builtInTypeSpec);
204                         }
205                 }
206         ;
207
208 // A type name. which is either a (possibly qualified) class name or
209 //   a primitive (builtin) type
210 type
211         :       identifier
212         |       builtInType
213         ;
214
215 // The primitive types.
216 builtInType
217         :       "void"
218         |       "boolean"
219         |       "byte"
220         |       "char"
221         |       "short"
222         |       "int"
223         |       "float"
224         |       "long"
225         |       "double"
226         ;
227
228 templater
229     :    ( lt:LT^ {#lt.setType(TEMPLATE);} (identifier|constant) ( COMMA! (identifier|constant) )* GT! )
230     ;
231
232 // A (possibly-qualified) java identifier.  We start with the first IDENT
233 //   and expand its name by adding dots and following IDENTS
234 identifier
235         :       IDENT^  ( DOT^ IDENT )* ( templater )?
236         ;
237
238 identifierStar
239         :       IDENT
240                 ( DOT^ IDENT )*
241                 ( DOT^ STAR  )?
242         ;
243
244 // A list of zero or more modifiers.  We could have used (modifier)* in
245 //   place of a call to modifiers, but I thought it was a good idea to keep
246 //   this rule separate so they can easily be collected in a Vector if
247 //   someone so desires
248 modifiers
249         :       ( modifier )*
250                 {#modifiers = #([MODIFIERS, "MODIFIERS"], #modifiers);}
251         ;
252
253 // modifiers for Java classes, interfaces, class/instance vars and methods
254 modifier
255         :       "private"
256         |       "public"
257         |       "protected"
258         |       "static"
259         |       "transient"
260         |       "final"
261         |       "abstract"
262         |       "native"
263         |       "threadsafe"
264         |       "synchronized"
265 //      |       "const"                 // reserved word, but not valid
266         |       "volatile"
267         |       "strictfp"
268         |       "threaded"
269         |       "blocking"
270         |       "readonly"
271         ;
272
273 // Definition of a Java class
274 classDefinition![AST modifiers]
275         :       "class" IDENT
276                 // it _might_ have a superclass...
277                 sc:superClassClause
278                 // it might implement some interfaces...
279                 ic:implementsClause
280                 // now parse the body of the class
281                 cb:classBlock
282 //              {#classDefinition = #(#[CLASS_DEF,"CLASS_DEF"],
283 //                                                         modifiers,IDENT,sc,ic,cb);}
284                 { AST t = new ClassNode(); t.setType(CLASS_DEF); t.setText("CLASS_DEF");
285             #classDefinition = #(t,
286                                                            modifiers,IDENT,sc,ic,cb);}
287         ;
288
289 superClassClause!
290         :       ( "extends" id:identifier )?
291                 {#superClassClause = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],id);}
292         ;
293
294 // Definition of a Java Interface
295 interfaceDefinition![AST modifiers]
296         :       "interface" IDENT
297                 // it might extend some other interfaces
298                 ie:interfaceExtends
299                 // now parse the body of the interface (looks like a class...)
300                 cb:classBlock
301                 {#interfaceDefinition = #(#[INTERFACE_DEF,"INTERFACE_DEF"],
302                                                                         modifiers,IDENT,ie,cb);}
303         ;
304
305
306 // This is the body of a class.  You can have fields and extra semicolons,
307 // That's about it (until you see what a field is...)
308 classBlock
309         :       LCURLY!
310                         ( field | SEMI! )*
311                 RCURLY!
312                 {#classBlock = #([OBJBLOCK, "OBJBLOCK"], #classBlock);}
313         ;
314
315 // An interface can extend several other interfaces...
316 interfaceExtends
317         :       (
318                 e:"extends"!
319                 identifier ( COMMA! identifier )*
320                 )?
321                 {#interfaceExtends = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],
322                                                         #interfaceExtends);}
323         ;
324
325 // A class can implement several interfaces...
326 implementsClause
327         :       (
328                         i:"implements"! identifier ( COMMA! identifier )*
329                 )?
330                 {#implementsClause = #(#[IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE"],
331                                                                  #implementsClause);}
332         ;
333
334 // Now the various things that can be defined inside a class or interface...
335 // Note that not all of these are really valid in an interface (constructors,
336 //   for example), and if this grammar were used for a compiler there would
337 //   need to be some semantic checks to make sure we're doing the right thing...
338 field!
339         :       // method, constructor, or variable declaration
340                 mods:modifiers
341                 (       h:ctorHead s:constructorBody // constructor
342                         {#field = #(#[CTOR_DEF,"CTOR_DEF"], mods, h, s);}
343
344                 |       cd:classDefinition[#mods]       // inner class
345                         {#field = #cd;}
346                         
347                 |       id:interfaceDefinition[#mods]   // inner interface
348                         {#field = #id;}
349
350                 |       t:typeSpec[false]  // method or variable declaration(s)
351                         (       IDENT  // the name of the method
352
353                                 // parse the formal parameter declarations.
354                                 LPAREN! param:parameterDeclarationList RPAREN!
355
356                                 rt:declaratorBrackets[#t]
357
358                                 // get the list of exceptions that this method is
359                                 // declared to throw
360                                 (tc:throwsClause)?
361
362                                 ( s2:compoundStatement | SEMI )
363                                 {#field = #(#[METHOD_DEF,"METHOD_DEF"],
364                                                      mods,
365                                                          #(#[TYPE,"TYPE"],rt),
366                                                          IDENT,
367                                                          param,
368                                                          tc,
369                                                          s2);}
370                         |       v:variableDefinitions[#mods,#t] SEMI
371 //                              {#field = #(#[VARIABLE_DEF,"VARIABLE_DEF"], v);}
372                                 {#field = #v;}
373                         )
374                 )
375
376     // "static { ... }" class initializer
377         |       "static" s3:compoundStatement
378                 {#field = #(#[STATIC_INIT,"STATIC_INIT"], s3);}
379
380     // "{ ... }" instance initializer
381         |       s4:compoundStatement
382                 {#field = #(#[INSTANCE_INIT,"INSTANCE_INIT"], s4);}
383         ;
384
385 constructorBody
386     :   lc:LCURLY^ {#lc.setType(SLIST);}
387                 // Predicate might be slow but only checked once per constructor def
388                 // not for general methods.
389                 (       (explicitConstructorInvocation) => explicitConstructorInvocation
390                 |
391                 )
392         (statement)*
393         RCURLY!
394     ;
395
396 explicitConstructorInvocation
397     :   (       options {
398                                 // this/super can begin a primaryExpression too; with finite
399                                 // lookahead ANTLR will think the 3rd alternative conflicts
400                                 // with 1, 2.  I am shutting off warning since ANTLR resolves
401                                 // the nondeterminism by correctly matching alts 1 or 2 when
402                                 // it sees this( or super(
403                                 generateAmbigWarnings=false;
404                         }
405                 :       "this"! lp1:LPAREN^ argList RPAREN! SEMI!
406                         {#lp1.setType(CTOR_CALL);}
407
408             |   "super"! lp2:LPAREN^ argList RPAREN! SEMI!
409                         {#lp2.setType(SUPER_CTOR_CALL);}
410
411                         // (new Outer()).super()  (create enclosing instance)
412                 |       primaryExpression DOT! "super"! lp3:LPAREN^ argList RPAREN! SEMI!
413                         {#lp3.setType(SUPER_CTOR_CALL);}
414                 )
415     ;
416
417 variableDefinitions[AST mods, AST t]
418         :       variableDeclarator[getASTFactory().dupTree(mods),
419                                                    getASTFactory().dupTree(t)]
420                 (       COMMA!
421                         variableDeclarator[getASTFactory().dupTree(mods),
422                                                            getASTFactory().dupTree(t)]
423                 )*
424         ;
425
426 /** Declaration of a variable.  This can be a class/instance variable,
427  *   or a local variable in a method
428  * It can also include possible initialization.
429  */
430 variableDeclarator![AST mods, AST t]
431         :       id:IDENT d:declaratorBrackets[t] v:varInitializer
432                 {#variableDeclarator = #(#[VARIABLE_DEF,"VARIABLE_DEF"], mods, #(#[TYPE,"TYPE"],d), id, v);}
433         ;
434
435 declaratorBrackets[AST typ]
436         :       {#declaratorBrackets=typ;}
437                 (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
438         ;
439
440 varInitializer
441         :       ( ASSIGN^ initializer )?
442         ;
443
444 // This is an initializer used to set up an array.
445 arrayInitializer
446         :       lc:LCURLY^ {#lc.setType(ARRAY_INIT);}
447                         (       initializer
448                                 (
449                                         // CONFLICT: does a COMMA after an initializer start a new
450                                         //           initializer or start the option ',' at end?
451                                         //           ANTLR generates proper code by matching
452                                         //                       the comma as soon as possible.
453                                         options {
454                                                 warnWhenFollowAmbig = false;
455                                         }
456                                 :
457                                         COMMA! initializer
458                                 )*
459                                 (COMMA!)?
460                         )?
461                 RCURLY!
462         ;
463
464
465 // The two "things" that can initialize an array element are an expression
466 //   and another (nested) array initializer.
467 initializer
468         :       expression
469         |       arrayInitializer
470         ;
471
472 // This is the header of a method.  It includes the name and parameters
473 //   for the method.
474 //   This also watches for a list of exception classes in a "throws" clause.
475 ctorHead
476         :       IDENT  // the name of the method
477
478                 // parse the formal parameter declarations.
479                 LPAREN! parameterDeclarationList RPAREN!
480
481                 // get the list of exceptions that this method is declared to throw
482                 (throwsClause)?
483         ;
484
485 // This is a list of exception classes that the method is declared to throw
486 throwsClause
487         :       "throws"^ identifier ( COMMA! identifier )*
488         ;
489
490
491 // A list of formal parameters
492 parameterDeclarationList
493         :       ( parameterDeclaration ( COMMA! parameterDeclaration )* )?
494                 {#parameterDeclarationList = #(#[PARAMETERS,"PARAMETERS"],
495                                                                         #parameterDeclarationList);}
496         ;
497
498 // A formal parameter.
499 parameterDeclaration!
500         :       pm:parameterModifier t:typeSpec[false] id:IDENT
501                 pd:declaratorBrackets[#t]
502                 {#parameterDeclaration = #(#[PARAMETER_DEF,"PARAMETER_DEF"],
503                                                                         pm, #([TYPE,"TYPE"],pd), id);}
504         ;
505
506 parameterModifier
507         :       (f:"final")?
508                 {#parameterModifier = #(#[MODIFIERS,"MODIFIERS"], f);}
509         ;
510
511 // Compound statement.  This is used in many contexts:
512 //   Inside a class definition prefixed with "static":
513 //      it is a class initializer
514 //   Inside a class definition without "static":
515 //      it is an instance initializer
516 //   As the body of a method
517 //   As a completely indepdent braced block of code inside a method
518 //      it starts a new scope for variable definitions
519
520 compoundStatement
521         :       lc:LCURLY^ {#lc.setType(SLIST);}
522                         // include the (possibly-empty) list of statements
523                         (statement)*
524                 RCURLY!
525         ;
526
527
528 statement
529         // A list of statements in curly braces -- start a new scope!
530         :       compoundStatement
531
532         // declarations are ambiguous with "ID DOT" relative to expression
533         // statements.  Must backtrack to be sure.  Could use a semantic
534         // predicate to test symbol table to see what the type was coming
535         // up, but that's pretty hard without a symbol table ;)
536         |       (declaration)=> declaration SEMI!
537
538         // An expression statement.  This could be a method call,
539         // assignment statement, or any other expression evaluated for
540         // side-effects.
541         |       expression SEMI!
542
543         // class definition
544         |       m:modifiers! classDefinition[#m]
545
546         // Attach a label to the front of a statement
547         |       IDENT c:COLON^ {#c.setType(LABELED_STAT);} statement
548
549         // If-else statement
550         |       "if"^ LPAREN! expression RPAREN! statement
551                 (
552                         // CONFLICT: the old "dangling-else" problem...
553                         //           ANTLR generates proper code matching
554                         //                       as soon as possible.  Hush warning.
555                         options {
556                                 warnWhenFollowAmbig = false;
557                         }
558                 :
559                         "else"! statement
560                 )?
561
562         // For statement
563         |       "for"^
564                         LPAREN!
565                                 forInit SEMI!   // initializer
566                                 forCond SEMI!   // condition test
567                                 forIter         // updater
568                         RPAREN!
569                         statement                     // statement to loop over
570
571         // While statement
572         |       "while"^ LPAREN! expression RPAREN! statement
573
574         // do-while statement
575         |       "do"^ statement "while"! LPAREN! expression RPAREN! SEMI!
576
577         // get out of a loop (or switch)
578         |       "break"^ (IDENT)? SEMI!
579
580         // do next iteration of a loop
581         |       "continue"^ (IDENT)? SEMI!
582
583         // Return an expression
584         |       "return"^ (expression)? SEMI!
585
586         // switch/case statement
587         |       "switch"^ LPAREN! expression RPAREN! LCURLY!
588                         ( casesGroup )*
589                 RCURLY!
590
591         // exception try-catch block
592         |       tryBlock
593
594         // throw an exception
595         |       "throw"^ expression SEMI!
596
597         // synchronize a statement
598         |       "synchronized"^ LPAREN! expression RPAREN! compoundStatement
599
600         // empty statement
601         |       s:SEMI {#s.setType(EMPTY_STAT);}
602         ;
603
604
605 casesGroup
606         :       (       // CONFLICT: to which case group do the statements bind?
607                         //           ANTLR generates proper code: it groups the
608                         //           many "case"/"default" labels together then
609                         //           follows them with the statements
610                         options {
611                                 warnWhenFollowAmbig = false;
612                         }
613                         :
614                         aCase
615                 )+
616                 caseSList
617                 {#casesGroup = #([CASE_GROUP, "CASE_GROUP"], #casesGroup);}
618         ;
619
620 aCase
621         :       ("case"^ expression | "default") COLON!
622         ;
623
624 caseSList
625         :       (statement)*
626                 {#caseSList = #(#[SLIST,"SLIST"],#caseSList);}
627         ;
628
629 // The initializer for a for loop
630 forInit
631                 // if it looks like a declaration, it is
632         :       (       (declaration)=> declaration
633                 // otherwise it could be an expression list...
634                 |       expressionList
635                 )?
636                 {#forInit = #(#[FOR_INIT,"FOR_INIT"],#forInit);}
637         ;
638
639 forCond
640         :       (expression)?
641                 {#forCond = #(#[FOR_CONDITION,"FOR_CONDITION"],#forCond);}
642         ;
643
644 forIter
645         :       (expressionList)?
646                 {#forIter = #(#[FOR_ITERATOR,"FOR_ITERATOR"],#forIter);}
647         ;
648
649 // an exception handler try/catch block
650 tryBlock
651         :       "try"^ compoundStatement
652                 (handler)*
653                 ( "finally"^ compoundStatement )?
654         ;
655
656
657 // an exception handler
658 handler
659         :       "catch"^ LPAREN! parameterDeclaration RPAREN! compoundStatement
660         ;
661
662
663 // expressions
664 // Note that most of these expressions follow the pattern
665 //   thisLevelExpression :
666 //       nextHigherPrecedenceExpression
667 //           (OPERATOR nextHigherPrecedenceExpression)*
668 // which is a standard recursive definition for a parsing an expression.
669 // The operators in java have the following precedences:
670 //    lowest  (13)  = *= /= %= += -= <<= >>= >>>= &= ^= |=
671 //            (12)  ?:
672 //            (11)  ||
673 //            (10)  &&
674 //            ( 9)  |
675 //            ( 8)  ^
676 //            ( 7)  &
677 //            ( 6)  == !=
678 //            ( 5)  < <= > >=
679 //            ( 4)  << >>
680 //            ( 3)  +(binary) -(binary)
681 //            ( 2)  * / %
682 //            ( 1)  ++ -- +(unary) -(unary)  ~  !  (type)
683 //                  []   () (method call)  . (dot -- identifier qualification)
684 //                  new   ()  (explicit parenthesis)
685 //
686 // the last two are not usually on a precedence chart; I put them in
687 // to point out that new has a higher precedence than '.', so you
688 // can validy use
689 //     new Frame().show()
690 // 
691 // Note that the above precedence levels map to the rules below...
692 // Once you have a precedence chart, writing the appropriate rules as below
693 //   is usually very straightfoward
694
695
696
697 // the mother of all expressions
698 expression
699         :       assignmentExpression
700                 {#expression = #(#[EXPR,"EXPR"],#expression);}
701         ;
702
703
704 // This is a list of expressions.
705 expressionList
706         :       expression (COMMA! expression)*
707                 {#expressionList = #(#[ELIST,"ELIST"], expressionList);}
708         ;
709
710
711 // assignment expression (level 13)
712 assignmentExpression
713         :       conditionalExpression
714                 (       (       ASSIGN^
715             |   PLUS_ASSIGN^
716             |   MINUS_ASSIGN^
717             |   STAR_ASSIGN^
718             |   DIV_ASSIGN^
719             |   MOD_ASSIGN^
720             |   SR_ASSIGN^
721             |   BSR_ASSIGN^
722             |   SL_ASSIGN^
723             |   BAND_ASSIGN^
724             |   BXOR_ASSIGN^
725             |   BOR_ASSIGN^
726             )
727                         assignmentExpression
728                 )?
729         ;
730
731
732 // conditional test (level 12)
733 conditionalExpression
734         :       logicalOrExpression
735                 ( QUESTION^ assignmentExpression COLON! conditionalExpression )?
736         ;
737
738
739 // logical or (||)  (level 11)
740 logicalOrExpression
741         :       logicalAndExpression (LOR^ logicalAndExpression)*
742         ;
743
744
745 // logical and (&&)  (level 10)
746 logicalAndExpression
747         :       inclusiveOrExpression (LAND^ inclusiveOrExpression)*
748         ;
749
750
751 // bitwise or non-short-circuiting or (|)  (level 9)
752 inclusiveOrExpression
753         :       exclusiveOrExpression (BOR^ exclusiveOrExpression)*
754         ;
755
756
757 // exclusive or (^)  (level 8)
758 exclusiveOrExpression
759         :       andExpression (BXOR^ andExpression)*
760         ;
761
762
763 // bitwise or non-short-circuiting and (&)  (level 7)
764 andExpression
765         :       equalityExpression (BAND^ equalityExpression)*
766         ;
767
768
769 // equality/inequality (==/!=) (level 6)
770 equalityExpression
771         :       relationalExpression ((NOT_EQUAL^ | EQUAL^) relationalExpression)*
772         ;
773
774
775 // boolean relational expressions (level 5)
776 relationalExpression
777         :       shiftExpression
778                 (       (       (       LT^
779                                 |       GT^
780                                 |       LE^
781                                 |       GE^
782                                 )
783                                 shiftExpression
784                         )*
785                 |       "instanceof"^ typeSpec[true]
786                 )
787         ;
788
789
790 // colon expression for array sections
791 colonExpression
792     :   expression (COLON^ expression (COLON! expression)?)?
793     ;
794
795
796 // bit shift expressions (level 4)
797 shiftExpression
798         :       additiveExpression ((SL^ | SR^ | BSR^) additiveExpression)*
799         ;
800
801
802 // binary addition/subtraction (level 3)
803 additiveExpression
804         :       multiplicativeExpression ((PLUS^ | MINUS^) multiplicativeExpression)*
805         ;
806
807
808 // multiplication/division/modulo (level 2)
809 multiplicativeExpression
810         :       unaryExpression ((STAR^ | DIV^ | MOD^ ) unaryExpression)*
811         ;
812
813 unaryExpression
814         :       INC^ unaryExpression
815         |       DEC^ unaryExpression
816         |       MINUS^ {#MINUS.setType(UNARY_MINUS);} unaryExpression
817         |       PLUS^  {#PLUS.setType(UNARY_PLUS);} unaryExpression
818         |       unaryExpressionNotPlusMinus
819         ;
820
821 unaryExpressionNotPlusMinus
822         :       BNOT^ unaryExpression
823         |       LNOT^ unaryExpression
824
825         |       (       // subrule allows option to shut off warnings
826                         options {
827                                 // "(int" ambig with postfixExpr due to lack of sequence
828                                 // info in linear approximate LL(k).  It's ok.  Shut up.
829                                 generateAmbigWarnings=false;
830                         }
831                 :       // If typecast is built in type, must be numeric operand
832                         // Also, no reason to backtrack if type keyword like int, float...
833                         lpb:LPAREN^ {#lpb.setType(TYPECAST);} builtInTypeSpec[true] RPAREN!
834                         unaryExpression
835
836                         // Have to backtrack to see if operator follows.  If no operator
837                         // follows, it's a typecast.  No semantic checking needed to parse.
838                         // if it _looks_ like a cast, it _is_ a cast; else it's a "(expr)"
839                 |       (LPAREN classTypeSpec[true] RPAREN unaryExpressionNotPlusMinus)=>
840                         lp:LPAREN^ {#lp.setType(TYPECAST);} classTypeSpec[true] RPAREN!
841                         unaryExpressionNotPlusMinus
842
843                 |       postfixExpression
844                 )
845         ;
846
847 // qualified names, array expressions, method invocation, post inc/dec
848 postfixExpression
849         :       primaryExpression // start with a primary
850
851                 (       // qualified id (id.id.id.id...) -- build the name
852                         DOT^ ( IDENT
853                                 | "this"
854                                 | "class"
855                                 | newExpression
856                                 | "super" // ClassName.super.field
857                                 )
858                         // the above line needs a semantic check to make sure "class"
859                         // is the _last_ qualifier.
860
861                         // allow ClassName[].class
862                 |       ( lbc:LBRACK^ {#lbc.setType(ARRAY_DECLARATOR);} RBRACK! )+
863                         DOT^ "class"
864
865                         // an array indexing operation
866 //              |       lb:LBRACK^ {#lb.setType(INDEX_OP);} expression RBRACK!
867                 |       lb1:LBRACK^ {#lb1.setType(INDEX_OP);} colonExpression RBRACK!
868
869                         // method invocation
870                         // The next line is not strictly proper; it allows x(3)(4) or
871                         //  x[2](4) which are not valid in Java.  If this grammar were used
872                         //  to validate a Java program a semantic check would be needed, or
873                         //   this rule would get really ugly...
874                         // It also allows ctor invocation like super(3) which is now
875                         // handled by the explicit constructor rule, but it would
876                         // be hard to syntactically prevent ctor calls here
877                 |       lp:LPAREN^ {#lp.setType(METHOD_CALL);}
878                                 argList
879                         RPAREN!
880                 )*
881
882                 // possibly add on a post-increment or post-decrement.
883                 // allows INC/DEC on too much, but semantics can check
884                 (       in:INC^ {#in.setType(POST_INC);}
885                 |       de:DEC^ {#de.setType(POST_DEC);}
886                 |       // nothing
887                 )
888         ;
889
890 // the basic element of an expression
891 primaryExpression
892         :       IDENT
893         |       constant
894         |       "true"
895         |       "false"
896         |       "this"
897         |       "null"
898         |       newExpression
899         |       LPAREN! assignmentExpression RPAREN!
900         |       "super"
901                 // look for int.class and int[].class
902         |       builtInType 
903                 ( lbt:LBRACK^ {#lbt.setType(ARRAY_DECLARATOR);} RBRACK! )*
904                 DOT^ "class"
905         ;
906
907 /** object instantiation.
908  *  Trees are built as illustrated by the following input/tree pairs:
909  *  
910  *  new T()
911  *  
912  *  new
913  *   |
914  *   T --  ELIST
915  *           |
916  *          arg1 -- arg2 -- .. -- argn
917  *  
918  *  new int[]
919  *
920  *  new
921  *   |
922  *  int -- ARRAY_DECLARATOR
923  *  
924  *  new int[] {1,2}
925  *
926  *  new
927  *   |
928  *  int -- ARRAY_DECLARATOR -- ARRAY_INIT
929  *                                  |
930  *                                EXPR -- EXPR
931  *                                  |      |
932  *                                  1      2
933  *  
934  *  new int[3]
935  *  new
936  *   |
937  *  int -- ARRAY_DECLARATOR
938  *                |
939  *              EXPR
940  *                |
941  *                3
942  *  
943  *  new int[1][2]
944  *  
945  *  new
946  *   |
947  *  int -- ARRAY_DECLARATOR
948  *               |
949  *         ARRAY_DECLARATOR -- EXPR
950  *               |              |
951  *             EXPR             1
952  *               |
953  *               2
954  *  
955  */
956 newExpression
957         :       "new"^ type
958                 (       LPAREN! argList RPAREN! (classBlock)?
959
960                         //java 1.1
961                         // Note: This will allow bad constructs like
962                         //    new int[4][][3] {exp,exp}.
963                         //    There needs to be a semantic check here...
964                         // to make sure:
965                         //   a) [ expr ] and [ ] are not mixed
966                         //   b) [ expr ] and an init are not used together
967
968                 |       newArrayDeclarator (arrayInitializer)?
969                 )
970         ;
971
972 argList
973         :       (       expressionList
974                 |       /*nothing*/
975                         {#argList = #[ELIST,"ELIST"];}
976                 )
977         ;
978
979 newArrayDeclarator
980         :       (
981                         // CONFLICT:
982                         // newExpression is a primaryExpression which can be
983                         // followed by an array index reference.  This is ok,
984                         // as the generated code will stay in this loop as
985                         // long as it sees an LBRACK (proper behavior)
986                         options {
987                                 warnWhenFollowAmbig = false;
988                         }
989                 :
990                         lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);}
991                                 (expression)?
992                         RBRACK!
993                 )+
994         ;
995
996 constant
997         :       NUM_INT
998         |       CHAR_LITERAL
999         |       STRING_LITERAL
1000         |       NUM_FLOAT
1001         |       NUM_LONG
1002         |       NUM_DOUBLE
1003         ;
1004
1005
1006 //----------------------------------------------------------------------------
1007 // The Java scanner
1008 //----------------------------------------------------------------------------
1009 {
1010 // lexer preamble
1011 }
1012 class JavaLexer extends Lexer;
1013
1014 options {
1015         exportVocab=Java;      // call the vocabulary "Java"
1016         testLiterals=false;    // don't automatically test for literals
1017         k=4;                   // four characters of lookahead
1018         charVocabulary='\u0003'..'\uFFFF';
1019         // without inlining some bitset tests, couldn't do unicode;
1020         // I need to make ANTLR generate smaller bitsets; see
1021         // bottom of JavaLexer.java
1022         codeGenBitsetTestThreshold=20;
1023 }
1024
1025
1026
1027 // OPERATORS
1028 QUESTION                :       '?'             ;
1029 LPAREN                  :       '('             ;
1030 RPAREN                  :       ')'             ;
1031 LBRACK                  :       '['             ;
1032 RBRACK                  :       ']'             ;
1033 LCURLY                  :       '{'             ;
1034 RCURLY                  :       '}'             ;
1035 COLON                   :       ':'             ;
1036 COMMA                   :       ','             ;
1037 //DOT                   :       '.'             ;
1038 ASSIGN                  :       '='             ;
1039 EQUAL                   :       "=="    ;
1040 LNOT                    :       '!'             ;
1041 BNOT                    :       '~'             ;
1042 NOT_EQUAL               :       "!="    ;
1043 DIV                             :       '/'             ;
1044 DIV_ASSIGN              :       "/="    ;
1045 PLUS                    :       '+'             ;
1046 PLUS_ASSIGN             :       "+="    ;
1047 INC                             :       "++"    ;
1048 MINUS                   :       '-'             ;
1049 MINUS_ASSIGN    :       "-="    ;
1050 DEC                             :       "--"    ;
1051 STAR                    :       '*'             ;
1052 STAR_ASSIGN             :       "*="    ;
1053 MOD                             :       '%'             ;
1054 MOD_ASSIGN              :       "%="    ;
1055 SR                              :       ">>"    ;
1056 SR_ASSIGN               :       ">>="   ;
1057 BSR                             :       ">>>"   ;
1058 BSR_ASSIGN              :       ">>>="  ;
1059 GE                              :       ">="    ;
1060 GT                              :       ">"             ;
1061 SL                              :       "<<"    ;
1062 SL_ASSIGN               :       "<<="   ;
1063 LE                              :       "<="    ;
1064 LT                              :       '<'             ;
1065 BXOR                    :       '^'             ;
1066 BXOR_ASSIGN             :       "^="    ;
1067 BOR                             :       '|'             ;
1068 BOR_ASSIGN              :       "|="    ;
1069 LOR                             :       "||"    ;
1070 BAND                    :       '&'             ;
1071 BAND_ASSIGN             :       "&="    ;
1072 LAND                    :       "&&"    ;
1073 SEMI                    :       ';'             ;
1074
1075
1076 // Whitespace -- ignored
1077 WS      :       (       ' '
1078                 |       '\t'
1079                 |       '\f'
1080                         // handle newlines
1081                 |       (       options {generateAmbigWarnings=false;}
1082                         :       "\r\n"  // Evil DOS
1083                         |       '\r'    // Macintosh
1084                         |       '\n'    // Unix (the right way)
1085                         )
1086                         { newline(); }
1087                 )+
1088                 { _ttype = Token.SKIP; }
1089         ;
1090
1091 // Single-line comments
1092 SL_COMMENT
1093         :       "//"
1094                 (~('\n'|'\r'))* ('\n'|'\r'('\n')?)
1095                 {$setType(Token.SKIP); newline();}
1096         ;
1097
1098 // multiple-line comments
1099 ML_COMMENT
1100         :       "/*"
1101                 (       /*      '\r' '\n' can be matched in one alternative or by matching
1102                                 '\r' in one iteration and '\n' in another.  I am trying to
1103                                 handle any flavor of newline that comes in, but the language
1104                                 that allows both "\r\n" and "\r" and "\n" to all be valid
1105                                 newline is ambiguous.  Consequently, the resulting grammar
1106                                 must be ambiguous.  I'm shutting this warning off.
1107                          */
1108                         options {
1109                                 generateAmbigWarnings=false;
1110                         }
1111                 :
1112                         { LA(2)!='/' }? '*'
1113                 |       '\r' '\n'               {newline();}
1114                 |       '\r'                    {newline();}
1115                 |       '\n'                    {newline();}
1116                 |       ~('*'|'\n'|'\r')
1117                 )*
1118                 "*/"
1119                 {$setType(Token.SKIP);}
1120         ;
1121
1122
1123 // character literals
1124 CHAR_LITERAL
1125         :       '\'' ( ESC | ~'\'' ) '\''
1126         ;
1127
1128 // string literals
1129 STRING_LITERAL
1130         :       '"' (ESC|~('"'|'\\'))* '"'
1131         ;
1132
1133
1134 // escape sequence -- note that this is protected; it can only be called
1135 //   from another lexer rule -- it will not ever directly return a token to
1136 //   the parser
1137 // There are various ambiguities hushed in this rule.  The optional
1138 // '0'...'9' digit matches should be matched here rather than letting
1139 // them go back to STRING_LITERAL to be matched.  ANTLR does the
1140 // right thing by matching immediately; hence, it's ok to shut off
1141 // the FOLLOW ambig warnings.
1142 protected
1143 ESC
1144         :       '\\'
1145                 (       'n'
1146                 |       'r'
1147                 |       't'
1148                 |       'b'
1149                 |       'f'
1150                 |       '"'
1151                 |       '\''
1152                 |       '\\'
1153                 |       ('u')+ HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT 
1154                 |       ('0'..'3')
1155                         (
1156                                 options {
1157                                         warnWhenFollowAmbig = false;
1158                                 }
1159                         :       ('0'..'7')
1160                                 (       
1161                                         options {
1162                                                 warnWhenFollowAmbig = false;
1163                                         }
1164                                 :       '0'..'7'
1165                                 )?
1166                         )?
1167                 |       ('4'..'7')
1168                         (
1169                                 options {
1170                                         warnWhenFollowAmbig = false;
1171                                 }
1172                         :       ('0'..'9')
1173                         )?
1174                 )
1175         ;
1176
1177
1178 // hexadecimal digit (again, note it's protected!)
1179 protected
1180 HEX_DIGIT
1181         :       ('0'..'9'|'A'..'F'|'a'..'f')
1182         ;
1183
1184
1185 // a dummy rule to force vocabulary to be all characters (except special
1186 //   ones that ANTLR uses internally (0 to 2)
1187 protected
1188 VOCAB
1189         :       '\3'..'\377'
1190         ;
1191
1192
1193 // an identifier.  Note that testLiterals is set to true!  This means
1194 // that after we match the rule, we look in the literals table to see
1195 // if it's a literal or really an identifer
1196 IDENT
1197         options {testLiterals=true;}
1198         :       ('a'..'z'|'A'..'Z'|'_'|'$') ('a'..'z'|'A'..'Z'|'_'|'0'..'9'|'$')*
1199         ;
1200
1201
1202 // a numeric literal
1203 NUM_INT
1204         {boolean isDecimal=false; Token t=null;}
1205     :   '.' {_ttype = DOT;}
1206             (   ('0'..'9')+ (EXPONENT)? (f1:FLOAT_SUFFIX {t=f1;})?
1207                 {
1208                                 if (t != null && t.getText().toUpperCase().indexOf('D')>=0) {
1209                         _ttype = NUM_DOUBLE;
1210                                 }
1211                                 else {
1212                         _ttype = NUM_FLOAT;
1213                                 }
1214                                 }
1215             )?
1216
1217         |       (       '0' {isDecimal = true;} // special case for just '0'
1218                         (       ('x'|'X')
1219                                 (                                                                                       // hex
1220                                         // the 'e'|'E' and float suffix stuff look
1221                                         // like hex digits, hence the (...)+ doesn't
1222                                         // know when to stop: ambig.  ANTLR resolves
1223                                         // it correctly by matching immediately.  It
1224                                         // is therefor ok to hush warning.
1225                                         options {
1226                                                 warnWhenFollowAmbig=false;
1227                                         }
1228                                 :       HEX_DIGIT
1229                                 )+
1230                         |       ('0'..'7')+                                                                     // octal
1231                         )?
1232                 |       ('1'..'9') ('0'..'9')*  {isDecimal=true;}               // non-zero decimal
1233                 )
1234                 (       ('l'|'L') { _ttype = NUM_LONG; }
1235                 
1236                 // only check to see if it's a float if looks like decimal so far
1237                 |       {isDecimal}?
1238             (   '.' ('0'..'9')* (EXPONENT)? (f2:FLOAT_SUFFIX {t=f2;})?
1239             |   EXPONENT (f3:FLOAT_SUFFIX {t=f3;})?
1240             |   f4:FLOAT_SUFFIX {t=f4;}
1241             )
1242             {
1243                         if (t != null && t.getText().toUpperCase() .indexOf('D') >= 0) {
1244                 _ttype = NUM_DOUBLE;
1245                         }
1246             else {
1247                 _ttype = NUM_FLOAT;
1248                         }
1249                         }
1250         )?
1251         ;
1252
1253
1254 // a couple protected methods to assist in matching floating point numbers
1255 protected
1256 EXPONENT
1257         :       ('e'|'E') ('+'|'-')? ('0'..'9')+
1258         ;
1259
1260
1261 protected
1262 FLOAT_SUFFIX
1263         :       'f'|'F'|'d'|'D'
1264         ;
1265