1 /*

     2  * Copyright 1994-2004 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package sun.tools.java;

    27 

    28 import sun.tools.tree.*;

    29 import java.io.IOException;

    30 import java.io.InputStream;

    31 import java.util.Enumeration;

    32 import java.util.Vector;

    33 

    34 /**

    35  * This class is used to parse Java statements and expressions.

    36  * The result is a parse tree.<p>

    37  *

    38  * This class implements an operator precedence parser. Errors are

    39  * reported to the Environment object, if the error can't be

    40  * resolved immediately, a SyntaxError exception is thrown.<p>

    41  *

    42  * Error recovery is implemented by catching SyntaxError exceptions

    43  * and discarding input tokens until an input token is reached that

    44  * is possibly a legal continuation.<p>

    45  *

    46  * The parse tree that is constructed represents the input

    47  * exactly (no rewrites to simpler forms). This is important

    48  * if the resulting tree is to be used for code formatting in

    49  * a programming environment. Currently only documentation comments

    50  * are retained.<p>

    51  *

    52  * The parsing algorithm does NOT use any type information. Changes

    53  * in the type system do not affect the structure of the parse tree.

    54  * This restriction does introduce an ambiguity an expression of the

    55  * form: (e1) e2 is assumed to be a cast if e2 does not start with

    56  * an operator. That means that (a) - b is interpreted as subtract

    57  * b from a and not cast negative b to type a. However, if a is a

    58  * simple type (byte, int, ...) then it is assumed to be a cast.<p>

    59  *

    60  * WARNING: The contents of this source file are not part of any

    61  * supported API.  Code that depends on them does so at its own risk:

    62  * they are subject to change or removal without notice.

    63  *

    64  * @author      Arthur van Hoff

    65  */

    66 

    67 public

    68 class Parser extends Scanner implements ParserActions, Constants {

    69     /**

    70      * Create a parser

    71      */

    72     protected Parser(Environment env, InputStream in) throws IOException {

    73         super(env, in);

    74         this.scanner = this;

    75         this.actions = this;

    76     }

    77 

    78     /**

    79      * Create a parser, given a scanner.

    80      */

    81     protected Parser(Scanner scanner) throws IOException {

    82         super(scanner.env);

    83         this.scanner = scanner;

    84         ((Scanner)this).env = scanner.env;

    85         ((Scanner)this).token = scanner.token;

    86         ((Scanner)this).pos = scanner.pos;

    87         this.actions = this;

    88     }

    89 

    90     /**

    91      * Create a parser, given a scanner and the semantic callback.

    92      */

    93     public Parser(Scanner scanner, ParserActions actions) throws IOException {

    94         this(scanner);

    95         this.actions = actions;

    96     }

    97 

    98     /**

    99      * Usually <code>this.actions == (ParserActions)this</code>.

   100      * However, a delegate scanner can produce tokens for this parser,

   101      * in which case <code>(Scanner)this</code> is unused,

   102      * except for <code>this.token</code> and <code>this.pos</code>

   103      * instance variables which are filled from the real scanner

   104      * by <code>this.scan()</code> and the constructor.

   105      */

   106     ParserActions actions;

   107 

   108     // Note:  The duplication of methods allows pre-1.1 classes to

   109     // be binary compatible with the new version of the parser,

   110     // which now passes IdentifierTokens to the semantics phase,

   111     // rather than just Identifiers.  This change is necessary,

   112     // since the parser is no longer responsible for managing the

   113     // resolution of type names.  (That caused the "Vector" bug.)

   114     //

   115     // In a future release, the old "plain-Identifier" methods will

   116     // go away, and the corresponding "IdentifierToken" methods

   117     // may become abstract.

   118 

   119     /**

   120      * package declaration

   121      * @deprecated

   122      */

   123     @Deprecated

   124     public void packageDeclaration(long off, IdentifierToken nm) {

   125         // By default, call the deprecated version.

   126         // Any application must override one of the packageDeclaration methods.

   127         packageDeclaration(off, nm.id);

   128     }

   129     /**

   130      * @deprecated

   131      */

   132     @Deprecated

   133     protected void packageDeclaration(long off, Identifier nm) {

   134         throw new RuntimeException("beginClass method is abstract");

   135     }

   136 

   137     /**

   138      * import class

   139      * @deprecated

   140      */

   141     @Deprecated

   142     public void importClass(long off, IdentifierToken nm) {

   143         // By default, call the deprecated version.

   144         // Any application must override one of the packageDeclaration methods.

   145         importClass(off, nm.id);

   146     }

   147     /**

   148      * @deprecated Use the version with the IdentifierToken arguments.

   149      */

   150     @Deprecated

   151     protected void importClass(long off, Identifier nm) {

   152         throw new RuntimeException("importClass method is abstract");

   153     }

   154 

   155     /**

   156      * import package

   157      * @deprecated

   158      */

   159     @Deprecated

   160     public void importPackage(long off, IdentifierToken nm) {

   161         // By default, call the deprecated version.

   162         // Any application must override one of the importPackage methods.

   163         importPackage(off, nm.id);

   164     }

   165     /**

   166      * @deprecated Use the version with the IdentifierToken arguments.

   167      */

   168     @Deprecated

   169     protected void importPackage(long off, Identifier nm) {

   170         throw new RuntimeException("importPackage method is abstract");

   171     }

   172 

   173     /**

   174      * Define class

   175      * @deprecated

   176      */

   177     @Deprecated

   178     public ClassDefinition beginClass(long off, String doc,

   179                                       int mod, IdentifierToken nm,

   180                                       IdentifierToken sup,

   181                                       IdentifierToken impl[]) {

   182         // By default, call the deprecated version.

   183         // Any application must override one of the beginClass methods.

   184         Identifier supId = (sup == null) ? null : sup.id;

   185         Identifier implIds[] = null;

   186         if (impl != null) {

   187             implIds = new Identifier[impl.length];

   188             for (int i = 0; i < impl.length; i++) {

   189                 implIds[i] = impl[i].id;

   190             }

   191         }

   192         beginClass(off, doc, mod, nm.id, supId, implIds);

   193         return getCurrentClass();

   194     }

   195     /**

   196      * @deprecated Use the version with the IdentifierToken arguments.

   197      */

   198     @Deprecated

   199     protected void beginClass(long off, String doc, int mod, Identifier nm,

   200                               Identifier sup, Identifier impl[]) {

   201         throw new RuntimeException("beginClass method is abstract");

   202     }

   203 

   204     /**

   205      * Report the current class under construction.

   206      * By default, it's a no-op which returns null.

   207      * It may only be called before the corresponding endClass().

   208      */

   209     protected ClassDefinition getCurrentClass() {

   210         return null;

   211     }

   212 

   213     /**

   214      * End class

   215      * @deprecated

   216      */

   217     @Deprecated

   218     public void endClass(long off, ClassDefinition c) {

   219         // By default, call the deprecated version.

   220         // Any application must override one of the beginClass methods.

   221         endClass(off, c.getName().getFlatName().getName());

   222     }

   223     /**

   224      * @deprecated Use the version with the IdentifierToken arguments.

   225      */

   226     @Deprecated

   227     protected void endClass(long off, Identifier nm) {

   228         throw new RuntimeException("endClass method is abstract");

   229     }

   230 

   231     /**

   232      * Define a field

   233      * @deprecated

   234      */

   235     @Deprecated

   236     public void defineField(long where, ClassDefinition c,

   237                             String doc, int mod, Type t,

   238                             IdentifierToken nm, IdentifierToken args[],

   239                             IdentifierToken exp[], Node val) {

   240         // By default, call the deprecated version.

   241         // Any application must override one of the defineField methods.

   242         Identifier argIds[] = null;

   243         Identifier expIds[] = null;

   244         if (args != null) {

   245             argIds = new Identifier[args.length];

   246             for (int i = 0; i < args.length; i++) {

   247                 argIds[i] = args[i].id;

   248             }

   249         }

   250         if (exp != null) {

   251             expIds = new Identifier[exp.length];

   252             for (int i = 0; i < exp.length; i++) {

   253                 expIds[i] = exp[i].id;

   254             }

   255         }

   256         defineField(where, doc, mod, t, nm.id, argIds, expIds, val);

   257     }

   258 

   259     /**

   260      * @deprecated Use the version with the IdentifierToken arguments.

   261      */

   262     @Deprecated

   263     protected void defineField(long where, String doc, int mod, Type t,

   264                                Identifier nm, Identifier args[],

   265                                Identifier exp[], Node val) {

   266         throw new RuntimeException("defineField method is abstract");

   267     }

   268 

   269     /*

   270      * A growable array of nodes. It is used as a growable

   271      * buffer to hold argument lists and expression lists.

   272      * I'm not using Vector to make it more efficient.

   273      */

   274     private Node args[] = new Node[32];

   275     protected int argIndex = 0;

   276 

   277     protected final void addArgument(Node n) {

   278         if (argIndex == args.length) {

   279             Node newArgs[] = new Node[args.length * 2];

   280             System.arraycopy(args, 0, newArgs, 0, args.length);

   281             args = newArgs;

   282         }

   283         args[argIndex++] = n;

   284     }

   285     protected final Expression exprArgs(int index)[] {

   286         Expression e[] = new Expression[argIndex - index];

   287         System.arraycopy(args, index, e, 0, argIndex - index);

   288         argIndex = index;

   289         return e;

   290     }

   291     protected final Statement statArgs(int index)[] {

   292         Statement s[] = new Statement[argIndex - index];

   293         System.arraycopy(args, index, s, 0, argIndex - index);

   294         argIndex = index;

   295         return s;

   296     }

   297 

   298     /**

   299      * Expect a token, return its value, scan the next token or

   300      * throw an exception.

   301      */

   302     protected void expect(int t) throws SyntaxError, IOException {

   303         if (token != t) {

   304             switch (t) {

   305               case IDENT:

   306                 env.error(scanner.prevPos, "identifier.expected");

   307                 break;

   308               default:

   309                 env.error(scanner.prevPos, "token.expected", opNames[t]);

   310                 break;

   311             }

   312                 throw new SyntaxError();

   313         }

   314         scan();

   315     }

   316 

   317     /**

   318      * Parse a type expression. Does not parse the []'s.

   319      */

   320     protected Expression parseTypeExpression() throws SyntaxError, IOException {

   321         switch (token) {

   322           case VOID:

   323             return new TypeExpression(scan(), Type.tVoid);

   324           case BOOLEAN:

   325             return new TypeExpression(scan(), Type.tBoolean);

   326           case BYTE:

   327             return new TypeExpression(scan(), Type.tByte);

   328           case CHAR:

   329             return new TypeExpression(scan(), Type.tChar);

   330           case SHORT:

   331             return new TypeExpression(scan(), Type.tShort);

   332           case INT:

   333             return new TypeExpression(scan(), Type.tInt);

   334           case LONG:

   335             return new TypeExpression(scan(), Type.tLong);

   336           case FLOAT:

   337             return new TypeExpression(scan(), Type.tFloat);

   338           case DOUBLE:

   339             return new TypeExpression(scan(), Type.tDouble);

   340           case IDENT:

   341             Expression e = new IdentifierExpression(pos, scanner.idValue);

   342             scan();

   343             while (token == FIELD) {

   344                 e = new FieldExpression(scan(), e, scanner.idValue);

   345                 expect(IDENT);

   346             }

   347             return e;

   348         }

   349 

   350         env.error(pos, "type.expected");

   351         throw new SyntaxError();

   352     }

   353 

   354     /**

   355      * Parse a method invocation. Should be called when the current

   356      * then is the '(' of the argument list.

   357      */

   358     protected Expression parseMethodExpression(Expression e, Identifier id) throws SyntaxError, IOException {

   359        long p = scan();

   360        int i = argIndex;

   361        if (token != RPAREN) {

   362            addArgument(parseExpression());

   363            while (token == COMMA) {

   364                scan();

   365                addArgument(parseExpression());

   366            }

   367        }

   368        expect(RPAREN);

   369        return new MethodExpression(p, e, id, exprArgs(i));

   370     }

   371 

   372     /**

   373      * Parse a new instance expression.  Should be called when the current

   374      * token is the '(' of the argument list.

   375      */

   376     protected Expression parseNewInstanceExpression(long p, Expression outerArg, Expression type) throws SyntaxError, IOException {

   377         int i = argIndex;

   378         expect(LPAREN);

   379         if (token != RPAREN) {

   380             addArgument(parseExpression());

   381             while (token == COMMA) {

   382                 scan();

   383                 addArgument(parseExpression());

   384             }

   385         }

   386         expect(RPAREN);

   387         ClassDefinition body = null;

   388         if (token == LBRACE && !(type instanceof TypeExpression)) {

   389             long tp = pos;

   390             // x = new Type(arg) { subclass body ... }

   391             Identifier superName = FieldExpression.toIdentifier(type);

   392             if (superName == null) {

   393                 env.error(type.getWhere(), "type.expected");

   394             }

   395             Vector ext = new Vector(1);

   396             Vector impl = new Vector(0);

   397             ext.addElement(new IdentifierToken(idNull));

   398             if (token == IMPLEMENTS || token == EXTENDS) {

   399                 env.error(pos, "anonymous.extends");

   400                 parseInheritance(ext, impl); // error recovery

   401             }

   402             body = parseClassBody(new IdentifierToken(tp, idNull),

   403                                   M_ANONYMOUS | M_LOCAL, EXPR, null,

   404                                   ext, impl, type.getWhere());

   405         }

   406         if (outerArg == null && body == null) {

   407             return new NewInstanceExpression(p, type, exprArgs(i));

   408         }

   409         return new NewInstanceExpression(p, type, exprArgs(i), outerArg, body);

   410     }

   411 

   412     /**

   413      * Parse a primary expression.

   414      */

   415     protected Expression parseTerm() throws SyntaxError, IOException {

   416         switch (token) {

   417           case CHARVAL: {

   418             char v = scanner.charValue;

   419             return new CharExpression(scan(), v);

   420           }

   421           case INTVAL: {

   422             int v = scanner.intValue;

   423             long q = scan();

   424             if (v < 0 && radix == 10) env.error(q, "overflow.int.dec");

   425             return new IntExpression(q, v);

   426           }

   427           case LONGVAL: {

   428             long v = scanner.longValue;

   429             long q = scan();

   430             if (v < 0 && radix == 10) env.error(q, "overflow.long.dec");

   431             return new LongExpression(q, v);

   432           }

   433           case FLOATVAL: {

   434             float v = scanner.floatValue;

   435             return new FloatExpression(scan(), v);

   436           }

   437           case DOUBLEVAL: {

   438             double v = scanner.doubleValue;

   439             return new DoubleExpression(scan(), v);

   440           }

   441           case STRINGVAL: {

   442             String v = scanner.stringValue;

   443             return new StringExpression(scan(), v);

   444           }

   445           case IDENT: {

   446             Identifier v = scanner.idValue;

   447             long p = scan();

   448             return (token == LPAREN) ?

   449                         parseMethodExpression(null, v) : new IdentifierExpression(p, v);

   450           }

   451 

   452           case TRUE:

   453             return new BooleanExpression(scan(), true);

   454           case FALSE:

   455             return new BooleanExpression(scan(), false);

   456           case NULL:

   457             return new NullExpression(scan());

   458 

   459           case THIS: {

   460             Expression e = new ThisExpression(scan());

   461             return (token == LPAREN) ? parseMethodExpression(e, idInit) : e;

   462           }

   463           case SUPER: {

   464             Expression e = new SuperExpression(scan());

   465             return (token == LPAREN) ? parseMethodExpression(e, idInit) : e;

   466           }

   467 

   468           case VOID:

   469           case BOOLEAN:

   470           case BYTE:

   471           case CHAR:

   472           case SHORT:

   473           case INT:

   474           case LONG:

   475           case FLOAT:

   476           case DOUBLE:

   477             return parseTypeExpression();

   478 

   479           case ADD: {

   480             long p = scan();

   481             switch (token) {

   482               case INTVAL: {

   483                 int v = scanner.intValue;

   484                 long q = scan();

   485                 if (v < 0 && radix == 10) env.error(q, "overflow.int.dec");

   486                 return new IntExpression(q, v);

   487               }

   488               case LONGVAL: {

   489                 long v = scanner.longValue;

   490                 long q = scan();

   491                 if (v < 0 && radix == 10) env.error(q, "overflow.long.dec");

   492                 return new LongExpression(q, v);

   493               }

   494               case FLOATVAL: {

   495                 float v = scanner.floatValue;

   496                 return new FloatExpression(scan(), v);

   497               }

   498               case DOUBLEVAL: {

   499                 double v = scanner.doubleValue;

   500                 return new DoubleExpression(scan(), v);

   501               }

   502             }

   503             return new PositiveExpression(p, parseTerm());

   504           }

   505           case SUB: {

   506             long p = scan();

   507             switch (token) {

   508               case INTVAL: {

   509                 int v = -scanner.intValue;

   510                 return new IntExpression(scan(), v);

   511               }

   512               case LONGVAL: {

   513                 long v = -scanner.longValue;

   514                 return new LongExpression(scan(), v);

   515               }

   516               case FLOATVAL: {

   517                 float v = -scanner.floatValue;

   518                 return new FloatExpression(scan(), v);

   519               }

   520               case DOUBLEVAL: {

   521                 double v = -scanner.doubleValue;

   522                 return new DoubleExpression(scan(), v);

   523               }

   524             }

   525             return new NegativeExpression(p, parseTerm());

   526           }

   527           case NOT:

   528             return new NotExpression(scan(), parseTerm());

   529           case BITNOT:

   530             return new BitNotExpression(scan(), parseTerm());

   531           case INC:

   532             return new PreIncExpression(scan(), parseTerm());

   533           case DEC:

   534             return new PreDecExpression(scan(), parseTerm());

   535 

   536           case LPAREN: {

   537             // bracketed-expr: (expr)

   538             long p = scan();

   539             Expression e = parseExpression();

   540             expect(RPAREN);

   541 

   542             if (e.getOp() == TYPE) {

   543                 // cast-expr: (simple-type) expr

   544                 return new CastExpression(p, e, parseTerm());

   545             }

   546 

   547             switch (token) {

   548 

   549                 // We handle INC and DEC specially.

   550                 // See the discussion in JLS section 15.14.1.

   551                 // (Part of fix for 4044502.)

   552 

   553               case INC:

   554                   // We know this must be a postfix increment.

   555                   return new PostIncExpression(scan(), e);

   556 

   557               case DEC:

   558                   // We know this must be a postfix decrement.

   559                   return new PostDecExpression(scan(), e);

   560 

   561               case LPAREN:

   562               case CHARVAL:

   563               case INTVAL:

   564               case LONGVAL:

   565               case FLOATVAL:

   566               case DOUBLEVAL:

   567               case STRINGVAL:

   568               case IDENT:

   569               case TRUE:

   570               case FALSE:

   571               case NOT:

   572               case BITNOT:

   573               case THIS:

   574               case SUPER:

   575               case NULL:

   576               case NEW:

   577                 // cast-expr: (expr) expr

   578                 return new CastExpression(p, e, parseTerm());

   579             }

   580             return new ExprExpression(p, e);

   581           }

   582 

   583           case LBRACE: {

   584             // array initializer: {expr1, expr2, ... exprn}

   585             long p = scan();

   586             int i = argIndex;

   587             if (token != RBRACE) {

   588                 addArgument(parseExpression());

   589                 while (token == COMMA) {

   590                     scan();

   591                     if (token == RBRACE) {

   592                         break;

   593                     }

   594                     addArgument(parseExpression());

   595                 }

   596             }

   597             expect(RBRACE);

   598             return new ArrayExpression(p, exprArgs(i));

   599           }

   600 

   601           case NEW: {

   602             long p = scan();

   603             int i = argIndex;

   604 

   605             if (token == LPAREN) {

   606                 scan();

   607                 Expression e = parseExpression();

   608                 expect(RPAREN);

   609                 env.error(p, "not.supported", "new(...)");

   610                 return new NullExpression(p);

   611             }

   612 

   613             Expression e = parseTypeExpression();

   614 

   615             if (token == LSQBRACKET) {

   616                 while (token == LSQBRACKET) {

   617                     scan();

   618                     addArgument((token != RSQBRACKET) ? parseExpression() : null);

   619                     expect(RSQBRACKET);

   620                 }

   621                 Expression[] dims = exprArgs(i);

   622                 if (token == LBRACE) {

   623                     return new NewArrayExpression(p, e, dims, parseTerm());

   624                 }

   625                 return new NewArrayExpression(p, e, dims);

   626             } else {

   627                 return parseNewInstanceExpression(p, null, e);

   628             }

   629           }

   630         }

   631 

   632         // System.err.println("NEAR: " + opNames[token]);

   633         env.error(scanner.prevPos, "missing.term");

   634         return new IntExpression(pos, 0);

   635     }

   636 

   637     /**

   638      * Parse an expression.

   639      */

   640     protected Expression parseExpression() throws SyntaxError, IOException {

   641         for (Expression e = parseTerm() ; e != null ; e = e.order()) {

   642             Expression more = parseBinaryExpression(e);

   643             if (more == null)

   644                 return e;

   645             e = more;

   646         }

   647         // this return is bogus

   648         return null;

   649     }

   650 

   651     /**

   652      * Given a left-hand term, parse an operator and right-hand term.

   653      */

   654     protected Expression parseBinaryExpression(Expression e) throws SyntaxError, IOException {

   655         if (e != null) {

   656             switch (token) {

   657               case LSQBRACKET: {

   658                 // index: expr1[expr2]

   659                 long p = scan();

   660                 Expression index = (token != RSQBRACKET) ? parseExpression() : null;

   661                 expect(RSQBRACKET);

   662                 e = new ArrayAccessExpression(p, e, index);

   663                 break;

   664               }

   665 

   666               case INC:

   667                 e = new PostIncExpression(scan(), e);

   668                 break;

   669               case DEC:

   670                 e = new PostDecExpression(scan(), e);

   671                 break;

   672               case FIELD: {

   673                 long p = scan();

   674                 if (token == THIS) {

   675                     // class C { class N { ... C.this ... } }

   676                     // class C { class N { N(C c){ ... c.this() ... } } }

   677                     long q = scan();

   678                     if (token == LPAREN) {

   679                         e = new ThisExpression(q, e);

   680                         e = parseMethodExpression(e, idInit);

   681                     } else {

   682                         e = new FieldExpression(p, e, idThis);

   683                     }

   684                     break;

   685                 }

   686                 if (token == SUPER) {

   687                     // class D extends C.N { D(C.N n) { n.super(); } }

   688                     // Also, 'C.super', as in:

   689                     // class C extends CS { class N { ... C.super.foo ... } }

   690                     // class C extends CS { class N { ... C.super.foo() ... } }

   691                     long q = scan();

   692                     if (token == LPAREN) {

   693                         e = new SuperExpression(q, e);

   694                         e = parseMethodExpression(e, idInit);

   695                     } else {

   696                         // We must check elsewhere that this expression

   697                         // does not stand alone, but qualifies a member name.

   698                         e = new FieldExpression(p, e, idSuper);

   699                     }

   700                     break;

   701                 }

   702                 if (token == NEW) {

   703                     // new C().new N()

   704                     scan();

   705                     if (token != IDENT)

   706                         expect(IDENT);

   707                     e = parseNewInstanceExpression(p, e, parseTypeExpression());

   708                     break;

   709                 }

   710                 if (token == CLASS) {

   711                     // just class literals, really

   712                     // Class c = C.class;

   713                     scan();

   714                     e = new FieldExpression(p, e, idClass);

   715                     break;

   716                 }

   717                 Identifier id = scanner.idValue;

   718                 expect(IDENT);

   719                 if (token == LPAREN) {

   720                     e = parseMethodExpression(e, id);

   721                 } else {

   722                     e = new FieldExpression(p, e, id);

   723                 }

   724                 break;

   725               }

   726               case INSTANCEOF:

   727                 e = new InstanceOfExpression(scan(), e, parseTerm());

   728                 break;

   729               case ADD:

   730                 e = new AddExpression(scan(), e, parseTerm());

   731                 break;

   732               case SUB:

   733                 e = new SubtractExpression(scan(), e, parseTerm());

   734                 break;

   735               case MUL:

   736                 e = new MultiplyExpression(scan(), e, parseTerm());

   737                 break;

   738               case DIV:

   739                 e = new DivideExpression(scan(), e, parseTerm());

   740                 break;

   741               case REM:

   742                 e = new RemainderExpression(scan(), e, parseTerm());

   743                 break;

   744               case LSHIFT:

   745                 e = new ShiftLeftExpression(scan(), e, parseTerm());

   746                 break;

   747               case RSHIFT:

   748                 e = new ShiftRightExpression(scan(), e, parseTerm());

   749                 break;

   750               case URSHIFT:

   751                 e = new UnsignedShiftRightExpression(scan(), e, parseTerm());

   752                 break;

   753               case LT:

   754                 e = new LessExpression(scan(), e, parseTerm());

   755                 break;

   756               case LE:

   757                 e = new LessOrEqualExpression(scan(), e, parseTerm());

   758                 break;

   759               case GT:

   760                 e = new GreaterExpression(scan(), e, parseTerm());

   761                 break;

   762               case GE:

   763                 e = new GreaterOrEqualExpression(scan(), e, parseTerm());

   764                 break;

   765               case EQ:

   766                 e = new EqualExpression(scan(), e, parseTerm());

   767                 break;

   768               case NE:

   769                 e = new NotEqualExpression(scan(), e, parseTerm());

   770                 break;

   771               case BITAND:

   772                 e = new BitAndExpression(scan(), e, parseTerm());

   773                 break;

   774               case BITXOR:

   775                 e = new BitXorExpression(scan(), e, parseTerm());

   776                 break;

   777               case BITOR:

   778                 e = new BitOrExpression(scan(), e, parseTerm());

   779                 break;

   780               case AND:

   781                 e = new AndExpression(scan(), e, parseTerm());

   782                 break;

   783               case OR:

   784                 e = new OrExpression(scan(), e, parseTerm());

   785                 break;

   786               case ASSIGN:

   787                 e = new AssignExpression(scan(), e, parseTerm());

   788                 break;

   789               case ASGMUL:

   790                 e = new AssignMultiplyExpression(scan(), e, parseTerm());

   791                 break;

   792               case ASGDIV:

   793                 e = new AssignDivideExpression(scan(), e, parseTerm());

   794                 break;

   795               case ASGREM:

   796                 e = new AssignRemainderExpression(scan(), e, parseTerm());

   797                 break;

   798               case ASGADD:

   799                 e = new AssignAddExpression(scan(), e, parseTerm());

   800                 break;

   801               case ASGSUB:

   802                 e = new AssignSubtractExpression(scan(), e, parseTerm());

   803                 break;

   804               case ASGLSHIFT:

   805                 e = new AssignShiftLeftExpression(scan(), e, parseTerm());

   806                 break;

   807               case ASGRSHIFT:

   808                 e = new AssignShiftRightExpression(scan(), e, parseTerm());

   809                 break;

   810               case ASGURSHIFT:

   811                 e = new AssignUnsignedShiftRightExpression(scan(), e, parseTerm());

   812                 break;

   813               case ASGBITAND:

   814                 e = new AssignBitAndExpression(scan(), e, parseTerm());

   815                 break;

   816               case ASGBITOR:

   817                 e = new AssignBitOrExpression(scan(), e, parseTerm());

   818                 break;

   819               case ASGBITXOR:

   820                 e = new AssignBitXorExpression(scan(), e, parseTerm());

   821                 break;

   822               case QUESTIONMARK: {

   823                 long p = scan();

   824                 Expression second = parseExpression();

   825                 expect(COLON);

   826                 Expression third = parseExpression();

   827 

   828                 // The grammar in the JLS does not allow assignment

   829                 // expressions as the third part of a ?: expression.

   830                 // Even though javac has no trouble parsing this,

   831                 // check for this case and signal an error.

   832                 // (fix for bug 4092958)

   833                 if (third instanceof AssignExpression

   834                     || third instanceof AssignOpExpression) {

   835                     env.error(third.getWhere(), "assign.in.conditionalexpr");

   836                 }

   837 

   838                 e = new ConditionalExpression(p, e, second, third);

   839                 break;

   840               }

   841 

   842               default:

   843                 return null; // mark end of binary expressions

   844             }

   845         }

   846         return e;           // return more binary expression stuff

   847     }

   848 

   849     /**

   850      * Recover after a syntax error in a statement. This involves

   851      * discarding tokens until EOF or a possible continuation is

   852      * encountered.

   853      */

   854     protected boolean recoverStatement() throws SyntaxError, IOException {

   855         while (true) {

   856             switch (token) {

   857               case EOF:

   858               case RBRACE:

   859               case LBRACE:

   860               case IF:

   861               case FOR:

   862               case WHILE:

   863               case DO:

   864               case TRY:

   865               case CATCH:

   866               case FINALLY:

   867               case BREAK:

   868               case CONTINUE:

   869               case RETURN:

   870                 // begin of a statement, return

   871                 return true;

   872 

   873               case VOID:

   874               case STATIC:

   875               case PUBLIC:

   876               case PRIVATE:

   877               case SYNCHRONIZED:

   878               case INTERFACE:

   879               case CLASS:

   880               case TRANSIENT:

   881                 // begin of something outside a statement, panic some more

   882                 expect(RBRACE);

   883                 return false;

   884 

   885               case LPAREN:

   886                 match(LPAREN, RPAREN);

   887                 scan();

   888                 break;

   889 

   890               case LSQBRACKET:

   891                 match(LSQBRACKET, RSQBRACKET);

   892                 scan();

   893                 break;

   894 

   895               default:

   896                 // don't know what to do, skip

   897                 scan();

   898                 break;

   899             }

   900         }

   901     }

   902 

   903     /**

   904      * Parse declaration, called after the type expression

   905      * has been parsed and the current token is IDENT.

   906      */

   907     protected Statement parseDeclaration(long p, int mod, Expression type) throws SyntaxError, IOException {

   908         int i = argIndex;

   909         if (token == IDENT) {

   910             addArgument(new VarDeclarationStatement(pos, parseExpression()));

   911             while (token == COMMA) {

   912                 scan();

   913                 addArgument(new VarDeclarationStatement(pos, parseExpression()));

   914             }

   915         }

   916         return new DeclarationStatement(p, mod, type, statArgs(i));

   917     }

   918 

   919     /**

   920      * Check if an expression is a legal toplevel expression.

   921      * Only method, inc, dec, and new expression are allowed.

   922      */

   923     protected void topLevelExpression(Expression e) {

   924         switch (e.getOp()) {

   925           case ASSIGN:

   926           case ASGMUL:

   927           case ASGDIV:

   928           case ASGREM:

   929           case ASGADD:

   930           case ASGSUB:

   931           case ASGLSHIFT:

   932           case ASGRSHIFT:

   933           case ASGURSHIFT:

   934           case ASGBITAND:

   935           case ASGBITOR:

   936           case ASGBITXOR:

   937           case PREINC:

   938           case PREDEC:

   939           case POSTINC:

   940           case POSTDEC:

   941           case METHOD:

   942           case NEWINSTANCE:

   943             return;

   944         }

   945         env.error(e.getWhere(), "invalid.expr");

   946     }

   947 

   948     /**

   949      * Parse a statement.

   950      */

   951     protected Statement parseStatement() throws SyntaxError, IOException {

   952         switch (token) {

   953           case SEMICOLON:

   954             return new CompoundStatement(scan(), new Statement[0]);

   955 

   956           case LBRACE:

   957               return parseBlockStatement();

   958 

   959           case IF: {

   960             // if-statement: if (expr) stat

   961             // if-statement: if (expr) stat else stat

   962             long p = scan();

   963 

   964             expect(LPAREN);

   965             Expression c = parseExpression();

   966             expect(RPAREN);

   967             Statement t = parseStatement();

   968             if (token == ELSE) {

   969                 scan();

   970                 return new IfStatement(p, c, t, parseStatement());

   971             } else {

   972                 return new IfStatement(p, c, t, null);

   973             }

   974           }

   975 

   976           case ELSE: {

   977             // else-statement: else stat

   978             env.error(scan(), "else.without.if");

   979             return parseStatement();

   980           }

   981 

   982           case FOR: {

   983             // for-statement: for (decl-expr? ; expr? ; expr?) stat

   984             long p = scan();

   985             Statement init = null;

   986             Expression cond = null, inc = null;

   987 

   988             expect(LPAREN);

   989             if (token != SEMICOLON) {

   990                 long p2 = pos;

   991                 int mod = parseModifiers(M_FINAL);

   992                 Expression e = parseExpression();

   993 

   994                 if (token == IDENT) {

   995                     init = parseDeclaration(p2, mod, e);

   996                 } else {

   997                     if (mod != 0) {

   998                         expect(IDENT); // should have been a declaration

   999                     }

  1000                     topLevelExpression(e);

  1001                     while (token == COMMA) {

  1002                         long p3 = scan();

  1003                         Expression e2 = parseExpression();

  1004                         topLevelExpression(e2);

  1005                         e = new CommaExpression(p3, e, e2);

  1006                     }

  1007                     init = new ExpressionStatement(p2, e);

  1008                 }

  1009             }

  1010             expect(SEMICOLON);

  1011             if (token != SEMICOLON) {

  1012                 cond = parseExpression();

  1013             }

  1014             expect(SEMICOLON);

  1015             if (token != RPAREN) {

  1016                 inc = parseExpression();

  1017                 topLevelExpression(inc);

  1018                 while (token == COMMA) {

  1019                     long p2 = scan();

  1020                     Expression e2 = parseExpression();

  1021                     topLevelExpression(e2);

  1022                     inc = new CommaExpression(p2, inc, e2);

  1023                 }

  1024             }

  1025             expect(RPAREN);

  1026             return new ForStatement(p, init, cond, inc, parseStatement());

  1027           }

  1028 

  1029           case WHILE: {

  1030             // while-statement: while (expr) stat

  1031             long p = scan();

  1032 

  1033             expect(LPAREN);

  1034             Expression cond = parseExpression();

  1035             expect(RPAREN);

  1036             return new WhileStatement(p, cond, parseStatement());

  1037           }

  1038 

  1039           case DO: {

  1040             // do-statement: do stat while (expr)

  1041             long p = scan();

  1042 

  1043             Statement body = parseStatement();

  1044             expect(WHILE);

  1045             expect(LPAREN);

  1046             Expression cond = parseExpression();

  1047             expect(RPAREN);

  1048             expect(SEMICOLON);

  1049             return new DoStatement(p, body, cond);

  1050           }

  1051 

  1052           case BREAK: {

  1053             // break-statement: break ;

  1054             long p = scan();

  1055             Identifier label = null;

  1056 

  1057             if (token == IDENT) {

  1058                 label = scanner.idValue;

  1059                 scan();

  1060             }

  1061             expect(SEMICOLON);

  1062             return new BreakStatement(p, label);

  1063           }

  1064 

  1065           case CONTINUE: {

  1066             // continue-statement: continue ;

  1067             long p = scan();

  1068             Identifier label = null;

  1069 

  1070             if (token == IDENT) {

  1071                 label = scanner.idValue;

  1072                 scan();

  1073             }

  1074             expect(SEMICOLON);

  1075             return new ContinueStatement(p, label);

  1076           }

  1077 

  1078           case RETURN: {

  1079             // return-statement: return ;

  1080             // return-statement: return expr ;

  1081             long p = scan();

  1082             Expression e = null;

  1083 

  1084             if (token != SEMICOLON) {

  1085                 e = parseExpression();

  1086             }

  1087             expect(SEMICOLON);

  1088             return new ReturnStatement(p, e);

  1089           }

  1090 

  1091           case SWITCH: {

  1092             // switch statement: switch ( expr ) stat

  1093             long p = scan();

  1094             int i = argIndex;

  1095 

  1096             expect(LPAREN);

  1097             Expression e = parseExpression();

  1098             expect(RPAREN);

  1099             expect(LBRACE);

  1100 

  1101             while ((token != EOF) && (token != RBRACE)) {

  1102                 int j = argIndex;

  1103                 try {

  1104                     switch (token) {

  1105                       case CASE:

  1106                         // case-statement: case expr:

  1107                         addArgument(new CaseStatement(scan(), parseExpression()));

  1108                         expect(COLON);

  1109                         break;

  1110 

  1111                       case DEFAULT:

  1112                         // default-statement: default:

  1113                         addArgument(new CaseStatement(scan(), null));

  1114                         expect(COLON);

  1115                         break;

  1116 

  1117                       default:

  1118                         addArgument(parseStatement());

  1119                         break;

  1120                     }

  1121                 } catch (SyntaxError ee) {

  1122                     argIndex = j;

  1123                     if (!recoverStatement()) {

  1124                         throw ee;

  1125                     }

  1126                 }

  1127             }

  1128             expect(RBRACE);

  1129             return new SwitchStatement(p, e, statArgs(i));

  1130           }

  1131 

  1132           case CASE: {

  1133             // case-statement: case expr : stat

  1134             env.error(pos, "case.without.switch");

  1135             while (token == CASE) {