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