| /* |
| * Copyright (c) 1994, 2004, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.tools.java; |
| |
| import sun.tools.tree.*; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.Enumeration; |
| import java.util.Vector; |
| |
| /** |
| * This class is used to parse Java statements and expressions. |
| * The result is a parse tree.<p> |
| * |
| * This class implements an operator precedence parser. Errors are |
| * reported to the Environment object, if the error can't be |
| * resolved immediately, a SyntaxError exception is thrown.<p> |
| * |
| * Error recovery is implemented by catching SyntaxError exceptions |
| * and discarding input tokens until an input token is reached that |
| * is possibly a legal continuation.<p> |
| * |
| * The parse tree that is constructed represents the input |
| * exactly (no rewrites to simpler forms). This is important |
| * if the resulting tree is to be used for code formatting in |
| * a programming environment. Currently only documentation comments |
| * are retained.<p> |
| * |
| * The parsing algorithm does NOT use any type information. Changes |
| * in the type system do not affect the structure of the parse tree. |
| * This restriction does introduce an ambiguity an expression of the |
| * form: (e1) e2 is assumed to be a cast if e2 does not start with |
| * an operator. That means that (a) - b is interpreted as subtract |
| * b from a and not cast negative b to type a. However, if a is a |
| * simple type (byte, int, ...) then it is assumed to be a cast.<p> |
| * |
| * WARNING: The contents of this source file are not part of any |
| * supported API. Code that depends on them does so at its own risk: |
| * they are subject to change or removal without notice. |
| * |
| * @author Arthur van Hoff |
| */ |
| |
| public |
| class Parser extends Scanner implements ParserActions, Constants { |
| /** |
| * Create a parser |
| */ |
| protected Parser(Environment env, InputStream in) throws IOException { |
| super(env, in); |
| this.scanner = this; |
| this.actions = this; |
| } |
| |
| /** |
| * Create a parser, given a scanner. |
| */ |
| protected Parser(Scanner scanner) throws IOException { |
| super(scanner.env); |
| this.scanner = scanner; |
| ((Scanner)this).env = scanner.env; |
| ((Scanner)this).token = scanner.token; |
| ((Scanner)this).pos = scanner.pos; |
| this.actions = this; |
| } |
| |
| /** |
| * Create a parser, given a scanner and the semantic callback. |
| */ |
| public Parser(Scanner scanner, ParserActions actions) throws IOException { |
| this(scanner); |
| this.actions = actions; |
| } |
| |
| /** |
| * Usually <code>this.actions == (ParserActions)this</code>. |
| * However, a delegate scanner can produce tokens for this parser, |
| * in which case <code>(Scanner)this</code> is unused, |
| * except for <code>this.token</code> and <code>this.pos</code> |
| * instance variables which are filled from the real scanner |
| * by <code>this.scan()</code> and the constructor. |
| */ |
| ParserActions actions; |
| |
| // Note: The duplication of methods allows pre-1.1 classes to |
| // be binary compatible with the new version of the parser, |
| // which now passes IdentifierTokens to the semantics phase, |
| // rather than just Identifiers. This change is necessary, |
| // since the parser is no longer responsible for managing the |
| // resolution of type names. (That caused the "Vector" bug.) |
| // |
| // In a future release, the old "plain-Identifier" methods will |
| // go away, and the corresponding "IdentifierToken" methods |
| // may become abstract. |
| |
| /** |
| * package declaration |
| * @deprecated |
| */ |
| @Deprecated |
| public void packageDeclaration(long off, IdentifierToken nm) { |
| // By default, call the deprecated version. |
| // Any application must override one of the packageDeclaration methods. |
| packageDeclaration(off, nm.id); |
| } |
| /** |
| * @deprecated |
| */ |
| @Deprecated |
| protected void packageDeclaration(long off, Identifier nm) { |
| throw new RuntimeException("beginClass method is abstract"); |
| } |
| |
| /** |
| * import class |
| * @deprecated |
| */ |
| @Deprecated |
| public void importClass(long off, IdentifierToken nm) { |
| // By default, call the deprecated version. |
| // Any application must override one of the packageDeclaration methods. |
| importClass(off, nm.id); |
| } |
| /** |
| * @deprecated Use the version with the IdentifierToken arguments. |
| */ |
| @Deprecated |
| protected void importClass(long off, Identifier nm) { |
| throw new RuntimeException("importClass method is abstract"); |
| } |
| |
| /** |
| * import package |
| * @deprecated |
| */ |
| @Deprecated |
| public void importPackage(long off, IdentifierToken nm) { |
| // By default, call the deprecated version. |
| // Any application must override one of the importPackage methods. |
| importPackage(off, nm.id); |
| } |
| /** |
| * @deprecated Use the version with the IdentifierToken arguments. |
| */ |
| @Deprecated |
| protected void importPackage(long off, Identifier nm) { |
| throw new RuntimeException("importPackage method is abstract"); |
| } |
| |
| /** |
| * Define class |
| * @deprecated |
| */ |
| @Deprecated |
| public ClassDefinition beginClass(long off, String doc, |
| int mod, IdentifierToken nm, |
| IdentifierToken sup, |
| IdentifierToken impl[]) { |
| // By default, call the deprecated version. |
| // Any application must override one of the beginClass methods. |
| Identifier supId = (sup == null) ? null : sup.id; |
| Identifier implIds[] = null; |
| if (impl != null) { |
| implIds = new Identifier[impl.length]; |
| for (int i = 0; i < impl.length; i++) { |
| implIds[i] = impl[i].id; |
| } |
| } |
| beginClass(off, doc, mod, nm.id, supId, implIds); |
| return getCurrentClass(); |
| } |
| /** |
| * @deprecated Use the version with the IdentifierToken arguments. |
| */ |
| @Deprecated |
| protected void beginClass(long off, String doc, int mod, Identifier nm, |
| Identifier sup, Identifier impl[]) { |
| throw new RuntimeException("beginClass method is abstract"); |
| } |
| |
| /** |
| * Report the current class under construction. |
| * By default, it's a no-op which returns null. |
| * It may only be called before the corresponding endClass(). |
| */ |
| protected ClassDefinition getCurrentClass() { |
| return null; |
| } |
| |
| /** |
| * End class |
| * @deprecated |
| */ |
| @Deprecated |
| public void endClass(long off, ClassDefinition c) { |
| // By default, call the deprecated version. |
| // Any application must override one of the beginClass methods. |
| endClass(off, c.getName().getFlatName().getName()); |
| } |
| /** |
| * @deprecated Use the version with the IdentifierToken arguments. |
| */ |
| @Deprecated |
| protected void endClass(long off, Identifier nm) { |
| throw new RuntimeException("endClass method is abstract"); |
| } |
| |
| /** |
| * Define a field |
| * @deprecated |
| */ |
| @Deprecated |
| public void defineField(long where, ClassDefinition c, |
| String doc, int mod, Type t, |
| IdentifierToken nm, IdentifierToken args[], |
| IdentifierToken exp[], Node val) { |
| // By default, call the deprecated version. |
| // Any application must override one of the defineField methods. |
| Identifier argIds[] = null; |
| Identifier expIds[] = null; |
| if (args != null) { |
| argIds = new Identifier[args.length]; |
| for (int i = 0; i < args.length; i++) { |
| argIds[i] = args[i].id; |
| } |
| } |
| if (exp != null) { |
| expIds = new Identifier[exp.length]; |
| for (int i = 0; i < exp.length; i++) { |
| expIds[i] = exp[i].id; |
| } |
| } |
| defineField(where, doc, mod, t, nm.id, argIds, expIds, val); |
| } |
| |
| /** |
| * @deprecated Use the version with the IdentifierToken arguments. |
| */ |
| @Deprecated |
| protected void defineField(long where, String doc, int mod, Type t, |
| Identifier nm, Identifier args[], |
| Identifier exp[], Node val) { |
| throw new RuntimeException("defineField method is abstract"); |
| } |
| |
| /* |
| * A growable array of nodes. It is used as a growable |
| * buffer to hold argument lists and expression lists. |
| * I'm not using Vector to make it more efficient. |
| */ |
| private Node args[] = new Node[32]; |
| protected int argIndex = 0; |
| |
| protected final void addArgument(Node n) { |
| if (argIndex == args.length) { |
| Node newArgs[] = new Node[args.length * 2]; |
| System.arraycopy(args, 0, newArgs, 0, args.length); |
| args = newArgs; |
| } |
| args[argIndex++] = n; |
| } |
| protected final Expression exprArgs(int index)[] { |
| Expression e[] = new Expression[argIndex - index]; |
| System.arraycopy(args, index, e, 0, argIndex - index); |
| argIndex = index; |
| return e; |
| } |
| protected final Statement statArgs(int index)[] { |
| Statement s[] = new Statement[argIndex - index]; |
| System.arraycopy(args, index, s, 0, argIndex - index); |
| argIndex = index; |
| return s; |
| } |
| |
| /** |
| * Expect a token, return its value, scan the next token or |
| * throw an exception. |
| */ |
| protected void expect(int t) throws SyntaxError, IOException { |
| if (token != t) { |
| switch (t) { |
| case IDENT: |
| env.error(scanner.prevPos, "identifier.expected"); |
| break; |
| default: |
| env.error(scanner.prevPos, "token.expected", opNames[t]); |
| break; |
| } |
| throw new SyntaxError(); |
| } |
| scan(); |
| } |
| |
| /** |
| * Parse a type expression. Does not parse the []'s. |
| */ |
| protected Expression parseTypeExpression() throws SyntaxError, IOException { |
| switch (token) { |
| case VOID: |
| return new TypeExpression(scan(), Type.tVoid); |
| case BOOLEAN: |
| return new TypeExpression(scan(), Type.tBoolean); |
| case BYTE: |
| return new TypeExpression(scan(), Type.tByte); |
| case CHAR: |
| return new TypeExpression(scan(), Type.tChar); |
| case SHORT: |
| return new TypeExpression(scan(), Type.tShort); |
| case INT: |
| return new TypeExpression(scan(), Type.tInt); |
| case LONG: |
| return new TypeExpression(scan(), Type.tLong); |
| case FLOAT: |
| return new TypeExpression(scan(), Type.tFloat); |
| case DOUBLE: |
| return new TypeExpression(scan(), Type.tDouble); |
| case IDENT: |
| Expression e = new IdentifierExpression(pos, scanner.idValue); |
| scan(); |
| while (token == FIELD) { |
| e = new FieldExpression(scan(), e, scanner.idValue); |
| expect(IDENT); |
| } |
| return e; |
| } |
| |
| env.error(pos, "type.expected"); |
| throw new SyntaxError(); |
| } |
| |
| /** |
| * Parse a method invocation. Should be called when the current |
| * then is the '(' of the argument list. |
| */ |
| protected Expression parseMethodExpression(Expression e, Identifier id) throws SyntaxError, IOException { |
| long p = scan(); |
| int i = argIndex; |
| if (token != RPAREN) { |
| addArgument(parseExpression()); |
| while (token == COMMA) { |
| scan(); |
| addArgument(parseExpression()); |
| } |
| } |
| expect(RPAREN); |
| return new MethodExpression(p, e, id, exprArgs(i)); |
| } |
| |
| /** |
| * Parse a new instance expression. Should be called when the current |
| * token is the '(' of the argument list. |
| */ |
| protected Expression parseNewInstanceExpression(long p, Expression outerArg, Expression type) throws SyntaxError, IOException { |
| int i = argIndex; |
| expect(LPAREN); |
| if (token != RPAREN) { |
| addArgument(parseExpression()); |
| while (token == COMMA) { |
| scan(); |
| addArgument(parseExpression()); |
| } |
| } |
| expect(RPAREN); |
| ClassDefinition body = null; |
| if (token == LBRACE && !(type instanceof TypeExpression)) { |
| long tp = pos; |
| // x = new Type(arg) { subclass body ... } |
| Identifier superName = FieldExpression.toIdentifier(type); |
| if (superName == null) { |
| env.error(type.getWhere(), "type.expected"); |
| } |
| Vector ext = new Vector(1); |
| Vector impl = new Vector(0); |
| ext.addElement(new IdentifierToken(idNull)); |
| if (token == IMPLEMENTS || token == EXTENDS) { |
| env.error(pos, "anonymous.extends"); |
| parseInheritance(ext, impl); // error recovery |
| } |
| body = parseClassBody(new IdentifierToken(tp, idNull), |
| M_ANONYMOUS | M_LOCAL, EXPR, null, |
| ext, impl, type.getWhere()); |
| } |
| if (outerArg == null && body == null) { |
| return new NewInstanceExpression(p, type, exprArgs(i)); |
| } |
| return new NewInstanceExpression(p, type, exprArgs(i), outerArg, body); |
| } |
| |
| /** |
| * Parse a primary expression. |
| */ |
| protected Expression parseTerm() throws SyntaxError, IOException { |
| switch (token) { |
| case CHARVAL: { |
| char v = scanner.charValue; |
| return new CharExpression(scan(), v); |
| } |
| case INTVAL: { |
| int v = scanner.intValue; |
| long q = scan(); |
| if (v < 0 && radix == 10) env.error(q, "overflow.int.dec"); |
| return new IntExpression(q, v); |
| } |
| case LONGVAL: { |
| long v = scanner.longValue; |
| long q = scan(); |
| if (v < 0 && radix == 10) env.error(q, "overflow.long.dec"); |
| return new LongExpression(q, v); |
| } |
| case FLOATVAL: { |
| float v = scanner.floatValue; |
| return new FloatExpression(scan(), v); |
| } |
| case DOUBLEVAL: { |
| double v = scanner.doubleValue; |
| return new DoubleExpression(scan(), v); |
| } |
| case STRINGVAL: { |
| String v = scanner.stringValue; |
| return new StringExpression(scan(), v); |
| } |
| case IDENT: { |
| Identifier v = scanner.idValue; |
| long p = scan(); |
| return (token == LPAREN) ? |
| parseMethodExpression(null, v) : new IdentifierExpression(p, v); |
| } |
| |
| case TRUE: |
| return new BooleanExpression(scan(), true); |
| case FALSE: |
| return new BooleanExpression(scan(), false); |
| case NULL: |
| return new NullExpression(scan()); |
| |
| case THIS: { |
| Expression e = new ThisExpression(scan()); |
| return (token == LPAREN) ? parseMethodExpression(e, idInit) : e; |
| } |
| case SUPER: { |
| Expression e = new SuperExpression(scan()); |
| return (token == LPAREN) ? parseMethodExpression(e, idInit) : e; |
| } |
| |
| case VOID: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case SHORT: |
| case INT: |
| case LONG: |
| case FLOAT: |
| case DOUBLE: |
| return parseTypeExpression(); |
| |
| case ADD: { |
| long p = scan(); |
| switch (token) { |
| case INTVAL: { |
| int v = scanner.intValue; |
| long q = scan(); |
| if (v < 0 && radix == 10) env.error(q, "overflow.int.dec"); |
| return new IntExpression(q, v); |
| } |
| case LONGVAL: { |
| long v = scanner.longValue; |
| long q = scan(); |
| if (v < 0 && radix == 10) env.error(q, "overflow.long.dec"); |
| return new LongExpression(q, v); |
| } |
| case FLOATVAL: { |
| float v = scanner.floatValue; |
| return new FloatExpression(scan(), v); |
| } |
| case DOUBLEVAL: { |
| double v = scanner.doubleValue; |
| return new DoubleExpression(scan(), v); |
| } |
| } |
| return new PositiveExpression(p, parseTerm()); |
| } |
| case SUB: { |
| long p = scan(); |
| switch (token) { |
| case INTVAL: { |
| int v = -scanner.intValue; |
| return new IntExpression(scan(), v); |
| } |
| case LONGVAL: { |
| long v = -scanner.longValue; |
| return new LongExpression(scan(), v); |
| } |
| case FLOATVAL: { |
| float v = -scanner.floatValue; |
| return new FloatExpression(scan(), v); |
| } |
| case DOUBLEVAL: { |
| double v = -scanner.doubleValue; |
| return new DoubleExpression(scan(), v); |
| } |
| } |
| return new NegativeExpression(p, parseTerm()); |
| } |
| case NOT: |
| return new NotExpression(scan(), parseTerm()); |
| case BITNOT: |
| return new BitNotExpression(scan(), parseTerm()); |
| case INC: |
| return new PreIncExpression(scan(), parseTerm()); |
| case DEC: |
| return new PreDecExpression(scan(), parseTerm()); |
| |
| case LPAREN: { |
| // bracketed-expr: (expr) |
| long p = scan(); |
| Expression e = parseExpression(); |
| expect(RPAREN); |
| |
| if (e.getOp() == TYPE) { |
| // cast-expr: (simple-type) expr |
| return new CastExpression(p, e, parseTerm()); |
| } |
| |
| switch (token) { |
| |
| // We handle INC and DEC specially. |
| // See the discussion in JLS section 15.14.1. |
| // (Part of fix for 4044502.) |
| |
| case INC: |
| // We know this must be a postfix increment. |
| return new PostIncExpression(scan(), e); |
| |
| case DEC: |
| // We know this must be a postfix decrement. |
| return new PostDecExpression(scan(), e); |
| |
| case LPAREN: |
| case CHARVAL: |
| case INTVAL: |
| case LONGVAL: |
| case FLOATVAL: |
| case DOUBLEVAL: |
| case STRINGVAL: |
| case IDENT: |
| case TRUE: |
| case FALSE: |
| case NOT: |
| case BITNOT: |
| case THIS: |
| case SUPER: |
| case NULL: |
| case NEW: |
| // cast-expr: (expr) expr |
| return new CastExpression(p, e, parseTerm()); |
| } |
| return new ExprExpression(p, e); |
| } |
| |
| case LBRACE: { |
| // array initializer: {expr1, expr2, ... exprn} |
| long p = scan(); |
| int i = argIndex; |
| if (token != RBRACE) { |
| addArgument(parseExpression()); |
| while (token == COMMA) { |
| scan(); |
| if (token == RBRACE) { |
| break; |
| } |
| addArgument(parseExpression()); |
| } |
| } |
| expect(RBRACE); |
| return new ArrayExpression(p, exprArgs(i)); |
| } |
| |
| case NEW: { |
| long p = scan(); |
| int i = argIndex; |
| |
| if (token == LPAREN) { |
| scan(); |
| Expression e = parseExpression(); |
| expect(RPAREN); |
| env.error(p, "not.supported", "new(...)"); |
| return new NullExpression(p); |
| } |
| |
| Expression e = parseTypeExpression(); |
| |
| if (token == LSQBRACKET) { |
| while (token == LSQBRACKET) { |
| scan(); |
| addArgument((token != RSQBRACKET) ? parseExpression() : null); |
| expect(RSQBRACKET); |
| } |
| Expression[] dims = exprArgs(i); |
| if (token == LBRACE) { |
| return new NewArrayExpression(p, e, dims, parseTerm()); |
| } |
| return new NewArrayExpression(p, e, dims); |
| } else { |
| return parseNewInstanceExpression(p, null, e); |
| } |
| } |
| } |
| |
| // System.err.println("NEAR: " + opNames[token]); |
| env.error(scanner.prevPos, "missing.term"); |
| return new IntExpression(pos, 0); |
| } |
| |
| /** |
| * Parse an expression. |
| */ |
| protected Expression parseExpression() throws SyntaxError, IOException { |
| for (Expression e = parseTerm() ; e != null ; e = e.order()) { |
| Expression more = parseBinaryExpression(e); |
| if (more == null) |
| return e; |
| e = more; |
| } |
| // this return is bogus |
| return null; |
| } |
| |
| /** |
| * Given a left-hand term, parse an operator and right-hand term. |
| */ |
| protected Expression parseBinaryExpression(Expression e) throws SyntaxError, IOException { |
| if (e != null) { |
| switch (token) { |
| case LSQBRACKET: { |
| // index: expr1[expr2] |
| long p = scan(); |
| Expression index = (token != RSQBRACKET) ? parseExpression() : null; |
| expect(RSQBRACKET); |
| e = new ArrayAccessExpression(p, e, index); |
| break; |
| } |
| |
| case INC: |
| e = new PostIncExpression(scan(), e); |
| break; |
| case DEC: |
| e = new PostDecExpression(scan(), e); |
| break; |
| case FIELD: { |
| long p = scan(); |
| if (token == THIS) { |
| // class C { class N { ... C.this ... } } |
| // class C { class N { N(C c){ ... c.this() ... } } } |
| long q = scan(); |
| if (token == LPAREN) { |
| e = new ThisExpression(q, e); |
| e = parseMethodExpression(e, idInit); |
| } else { |
| e = new FieldExpression(p, e, idThis); |
| } |
| break; |
| } |
| if (token == SUPER) { |
| // class D extends C.N { D(C.N n) { n.super(); } } |
| // Also, 'C.super', as in: |
| // class C extends CS { class N { ... C.super.foo ... } } |
| // class C extends CS { class N { ... C.super.foo() ... } } |
| long q = scan(); |
| if (token == LPAREN) { |
| e = new SuperExpression(q, e); |
| e = parseMethodExpression(e, idInit); |
| } else { |
| // We must check elsewhere that this expression |
| // does not stand alone, but qualifies a member name. |
| e = new FieldExpression(p, e, idSuper); |
| } |
| break; |
| } |
| if (token == NEW) { |
| // new C().new N() |
| scan(); |
| if (token != IDENT) |
| expect(IDENT); |
| e = parseNewInstanceExpression(p, e, parseTypeExpression()); |
| break; |
| } |
| if (token == CLASS) { |
| // just class literals, really |
| // Class c = C.class; |
| scan(); |
| e = new FieldExpression(p, e, idClass); |
| break; |
| } |
| Identifier id = scanner.idValue; |
| expect(IDENT); |
| if (token == LPAREN) { |
| e = parseMethodExpression(e, id); |
| } else { |
| e = new FieldExpression(p, e, id); |
| } |
| break; |
| } |
| case INSTANCEOF: |
| e = new InstanceOfExpression(scan(), e, parseTerm()); |
| break; |
| case ADD: |
| e = new AddExpression(scan(), e, parseTerm()); |
| break; |
| case SUB: |
| e = new SubtractExpression(scan(), e, parseTerm()); |
| break; |
| case MUL: |
| e = new MultiplyExpression(scan(), e, parseTerm()); |
| break; |
| case DIV: |
| e = new DivideExpression(scan(), e, parseTerm()); |
| break; |
| case REM: |
| e = new RemainderExpression(scan(), e, parseTerm()); |
| break; |
| case LSHIFT: |
| e = new ShiftLeftExpression(scan(), e, parseTerm()); |
| break; |
| case RSHIFT: |
| e = new ShiftRightExpression(scan(), e, parseTerm()); |
| break; |
| case URSHIFT: |
| e = new UnsignedShiftRightExpression(scan(), e, parseTerm()); |
| break; |
| case LT: |
| e = new LessExpression(scan(), e, parseTerm()); |
| break; |
| case LE: |
| e = new LessOrEqualExpression(scan(), e, parseTerm()); |
| break; |
| case GT: |
| e = new GreaterExpression(scan(), e, parseTerm()); |
| break; |
| case GE: |
| e = new GreaterOrEqualExpression(scan(), e, parseTerm()); |
| break; |
| case EQ: |
| e = new EqualExpression(scan(), e, parseTerm()); |
| break; |
| case NE: |
| e = new NotEqualExpression(scan(), e, parseTerm()); |
| break; |
| case BITAND: |
| e = new BitAndExpression(scan(), e, parseTerm()); |
| break; |
| case BITXOR: |
| e = new BitXorExpression(scan(), e, parseTerm()); |
| break; |
| case BITOR: |
| e = new BitOrExpression(scan(), e, parseTerm()); |
| break; |
| case AND: |
| e = new AndExpression(scan(), e, parseTerm()); |
| break; |
| case OR: |
| e = new OrExpression(scan(), e, parseTerm()); |
| break; |
| case ASSIGN: |
| e = new AssignExpression(scan(), e, parseTerm()); |
| break; |
| case ASGMUL: |
| e = new AssignMultiplyExpression(scan(), e, parseTerm()); |
| break; |
| case ASGDIV: |
| e = new AssignDivideExpression(scan(), e, parseTerm()); |
| break; |
| case ASGREM: |
| e = new AssignRemainderExpression(scan(), e, parseTerm()); |
| break; |
| case ASGADD: |
| e = new AssignAddExpression(scan(), e, parseTerm()); |
| break; |
| case ASGSUB: |
| e = new AssignSubtractExpression(scan(), e, parseTerm()); |
| break; |
| case ASGLSHIFT: |
| e = new AssignShiftLeftExpression(scan(), e, parseTerm()); |
| break; |
| case ASGRSHIFT: |
| e = new AssignShiftRightExpression(scan(), e, parseTerm()); |
| break; |
| case ASGURSHIFT: |
| e = new AssignUnsignedShiftRightExpression(scan(), e, parseTerm()); |
| break; |
| case ASGBITAND: |
| e = new AssignBitAndExpression(scan(), e, parseTerm()); |
| break; |
| case ASGBITOR: |
| e = new AssignBitOrExpression(scan(), e, parseTerm()); |
| break; |
| case ASGBITXOR: |
| e = new AssignBitXorExpression(scan(), e, parseTerm()); |
| break; |
| case QUESTIONMARK: { |
| long p = scan(); |
| Expression second = parseExpression(); |
| expect(COLON); |
| Expression third = parseExpression(); |
| |
| // The grammar in the JLS does not allow assignment |
| // expressions as the third part of a ?: expression. |
| // Even though javac has no trouble parsing this, |
| // check for this case and signal an error. |
| // (fix for bug 4092958) |
| if (third instanceof AssignExpression |
| || third instanceof AssignOpExpression) { |
| env.error(third.getWhere(), "assign.in.conditionalexpr"); |
| } |
| |
| e = new ConditionalExpression(p, e, second, third); |
| break; |
| } |
| |
| default: |
| return null; // mark end of binary expressions |
| } |
| } |
| return e; // return more binary expression stuff |
| } |
| |
| /** |
| * Recover after a syntax error in a statement. This involves |
| * discarding tokens until EOF or a possible continuation is |
| * encountered. |
| */ |
| protected boolean recoverStatement() throws SyntaxError, IOException { |
| while (true) { |
| switch (token) { |
| case EOF: |
| case RBRACE: |
| case LBRACE: |
| case IF: |
| case FOR: |
| case WHILE: |
| case DO: |
| case TRY: |
| case CATCH: |
| case FINALLY: |
| case BREAK: |
| case CONTINUE: |
| case RETURN: |
| // begin of a statement, return |
| return true; |
| |
| case VOID: |
| case STATIC: |
| case PUBLIC: |
| case PRIVATE: |
| case SYNCHRONIZED: |
| case INTERFACE: |
| case CLASS: |
| case TRANSIENT: |
| // begin of something outside a statement, panic some more |
| expect(RBRACE); |
| return false; |
| |
| case LPAREN: |
| match(LPAREN, RPAREN); |
| scan(); |
| break; |
| |
| case LSQBRACKET: |
| match(LSQBRACKET, RSQBRACKET); |
| scan(); |
| break; |
| |
| default: |
| // don't know what to do, skip |
| scan(); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Parse declaration, called after the type expression |
| * has been parsed and the current token is IDENT. |
| */ |
| protected Statement parseDeclaration(long p, int mod, Expression type) throws SyntaxError, IOException { |
| int i = argIndex; |
| if (token == IDENT) { |
| addArgument(new VarDeclarationStatement(pos, parseExpression())); |
| while (token == COMMA) { |
| scan(); |
| addArgument(new VarDeclarationStatement(pos, parseExpression())); |
| } |
| } |
| return new DeclarationStatement(p, mod, type, statArgs(i)); |
| } |
| |
| /** |
| * Check if an expression is a legal toplevel expression. |
| * Only method, inc, dec, and new expression are allowed. |
| */ |
| protected void topLevelExpression(Expression e) { |
| switch (e.getOp()) { |
| case ASSIGN: |
| case ASGMUL: |
| case ASGDIV: |
| case ASGREM: |
| case ASGADD: |
| case ASGSUB: |
| case ASGLSHIFT: |
| case ASGRSHIFT: |
| case ASGURSHIFT: |
| case ASGBITAND: |
| case ASGBITOR: |
| case ASGBITXOR: |
| case PREINC: |
| case PREDEC: |
| case POSTINC: |
| case POSTDEC: |
| case METHOD: |
| case NEWINSTANCE: |
| return; |
| } |
| env.error(e.getWhere(), "invalid.expr"); |
| } |
| |
| /** |
| * Parse a statement. |
| */ |
| protected Statement parseStatement() throws SyntaxError, IOException { |
| switch (token) { |
| case SEMICOLON: |
| return new CompoundStatement(scan(), new Statement[0]); |
| |
| case LBRACE: |
| return parseBlockStatement(); |
| |
| case IF: { |
| // if-statement: if (expr) stat |
| // if-statement: if (expr) stat else stat |
| long p = scan(); |
| |
| expect(LPAREN); |
| Expression c = parseExpression(); |
| expect(RPAREN); |
| Statement t = parseStatement(); |
| if (token == ELSE) { |
| scan(); |
| return new IfStatement(p, c, t, parseStatement()); |
| } else { |
| return new IfStatement(p, c, t, null); |
| } |
| } |
| |
| case ELSE: { |
| // else-statement: else stat |
| env.error(scan(), "else.without.if"); |
| return parseStatement(); |
| } |
| |
| case FOR: { |
| // for-statement: for (decl-expr? ; expr? ; expr?) stat |
| long p = scan(); |
| Statement init = null; |
| Expression cond = null, inc = null; |
| |
| expect(LPAREN); |
| if (token != SEMICOLON) { |
| long p2 = pos; |
| int mod = parseModifiers(M_FINAL); |
| Expression e = parseExpression(); |
| |
| if (token == IDENT) { |
| init = parseDeclaration(p2, mod, e); |
| } else { |
| if (mod != 0) { |
| expect(IDENT); // should have been a declaration |
| } |
| topLevelExpression(e); |
| while (token == COMMA) { |
| long p3 = scan(); |
| Expression e2 = parseExpression(); |
| topLevelExpression(e2); |
| e = new CommaExpression(p3, e, e2); |
| } |
| init = new ExpressionStatement(p2, e); |
| } |
| } |
| expect(SEMICOLON); |
| if (token != SEMICOLON) { |
| cond = parseExpression(); |
| } |
| expect(SEMICOLON); |
| if (token != RPAREN) { |
| inc = parseExpression(); |
| topLevelExpression(inc); |
| while (token == COMMA) { |
| long p2 = scan(); |
| Expression e2 = parseExpression(); |
| topLevelExpression(e2); |
| inc = new CommaExpression(p2, inc, e2); |
| } |
| } |
| expect(RPAREN); |
| return new ForStatement(p, init, cond, inc, parseStatement()); |
| } |
| |
| case WHILE: { |
| // while-statement: while (expr) stat |
| long p = scan(); |
| |
| expect(LPAREN); |
| Expression cond = parseExpression(); |
| expect(RPAREN); |
| return new WhileStatement(p, cond, parseStatement()); |
| } |
| |
| case DO: { |
| // do-statement: do stat while (expr) |
| long p = scan(); |
| |
| Statement body = parseStatement(); |
| expect(WHILE); |
| expect(LPAREN); |
| Expression cond = parseExpression(); |
| expect(RPAREN); |
| expect(SEMICOLON); |
| return new DoStatement(p, body, cond); |
| } |
| |
| case BREAK: { |
| // break-statement: break ; |
| long p = scan(); |
| Identifier label = null; |
| |
| if (token == IDENT) { |
| label = scanner.idValue; |
| scan(); |
| } |
| expect(SEMICOLON); |
| return new BreakStatement(p, label); |
| } |
| |
| case CONTINUE: { |
| // continue-statement: continue ; |
| long p = scan(); |
| Identifier label = null; |
| |
| if (token == IDENT) { |
| label = scanner.idValue; |
| scan(); |
| } |
| expect(SEMICOLON); |
| return new ContinueStatement(p, label); |
| } |
| |
| case RETURN: { |
| // return-statement: return ; |
| // return-statement: return expr ; |
| long p = scan(); |
| Expression e = null; |
| |
| if (token != SEMICOLON) { |
| e = parseExpression(); |
| } |
| expect(SEMICOLON); |
| return new ReturnStatement(p, e); |
| } |
| |
| case SWITCH: { |
| // switch statement: switch ( expr ) stat |
| long p = scan(); |
| int i = argIndex; |
| |
| expect(LPAREN); |
| Expression e = parseExpression(); |
| expect(RPAREN); |
| expect(LBRACE); |
| |
| while ((token != EOF) && (token != RBRACE)) { |
| int j = argIndex; |
| try { |
| switch (token) { |
| case CASE: |
| // case-statement: case expr: |
| addArgument(new CaseStatement(scan(), parseExpression())); |
| expect(COLON); |
| break; |
| |
| case DEFAULT: |
| // default-statement: default: |
| addArgument(new CaseStatement(scan(), null)); |
| expect(COLON); |
| break; |
| |
| default: |
| addArgument(parseStatement()); |
| break; |
| } |
| } catch (SyntaxError ee) { |
| argIndex = j; |
| if (!recoverStatement()) { |
| throw ee; |
| } |
| } |
| } |
| expect(RBRACE); |
| return new SwitchStatement(p, e, statArgs(i)); |
| } |
| |
| case CASE: { |
| // case-statement: case expr : stat |
| env.error(pos, "case.without.switch"); |
| while (token == CASE) { |
| scan(); |
| parseExpression(); |
| expect(COLON); |
| } |
| return parseStatement(); |
| } |
| |
| case DEFAULT: { |
| // default-statement: default : stat |
| env.error(pos, "default.without.switch"); |
| scan(); |
| expect(COLON); |
| return parseStatement(); |
| } |
| |
| case TRY: { |
| // try-statement: try stat catch (type-expr ident) stat finally stat |
| long p = scan(); |
| Statement init = null; // try-object specification |
| int i = argIndex; |
| boolean catches = false; |
| |
| if (false && token == LPAREN) { |
| expect(LPAREN); |
| long p2 = pos; |
| int mod = parseModifiers(M_FINAL); |
| Expression e = parseExpression(); |
| |
| if (token == IDENT) { |
| init = parseDeclaration(p2, mod, e); |
| // leave check for try (T x, y) for semantic phase |
| } else { |
| if (mod != 0) { |
| expect(IDENT); // should have been a declaration |
| } |
| init = new ExpressionStatement(p2, e); |
| } |
| expect(RPAREN); |
| } |
| |
| Statement s = parseBlockStatement(); |
| |
| if (init != null) { |
| // s = new FinallyStatement(p, init, s, 0); |
| } |
| |
| while (token == CATCH) { |
| long pp = pos; |
| expect(CATCH); |
| expect(LPAREN); |
| int mod = parseModifiers(M_FINAL); |
| Expression t = parseExpression(); |
| IdentifierToken id = scanner.getIdToken(); |
| expect(IDENT); |
| id.modifiers = mod; |
| // We only catch Throwable's, so this is no longer required |
| // while (token == LSQBRACKET) { |
| // t = new ArrayAccessExpression(scan(), t, null); |
| // expect(RSQBRACKET); |
| // } |
| expect(RPAREN); |
| addArgument(new CatchStatement(pp, t, id, parseBlockStatement())); |
| catches = true; |
| } |
| |
| if (catches) |
| s = new TryStatement(p, s, statArgs(i)); |
| |
| if (token == FINALLY) { |
| scan(); |
| return new FinallyStatement(p, s, parseBlockStatement()); |
| } else if (catches || init != null) { |
| return s; |
| } else { |
| env.error(pos, "try.without.catch.finally"); |
| return new TryStatement(p, s, null); |
| } |
| } |
| |
| case CATCH: { |
| // catch-statement: catch (expr ident) stat finally stat |
| env.error(pos, "catch.without.try"); |
| |
| Statement s; |
| do { |
| scan(); |
| expect(LPAREN); |
| parseModifiers(M_FINAL); |
| parseExpression(); |
| expect(IDENT); |
| expect(RPAREN); |
| s = parseBlockStatement(); |
| } while (token == CATCH); |
| |
| if (token == FINALLY) { |
| scan(); |
| s = parseBlockStatement(); |
| } |
| return s; |
| } |
| |
| case FINALLY: { |
| // finally-statement: finally stat |
| env.error(pos, "finally.without.try"); |
| scan(); |
| return parseBlockStatement(); |
| } |
| |
| case THROW: { |
| // throw-statement: throw expr; |
| long p = scan(); |
| Expression e = parseExpression(); |
| expect(SEMICOLON); |
| return new ThrowStatement(p, e); |
| } |
| |
| case GOTO: { |
| long p = scan(); |
| expect(IDENT); |
| expect(SEMICOLON); |
| env.error(p, "not.supported", "goto"); |
| return new CompoundStatement(p, new Statement[0]); |
| } |
| |
| case SYNCHRONIZED: { |
| // synchronized-statement: synchronized (expr) stat |
| long p = scan(); |
| expect(LPAREN); |
| Expression e = parseExpression(); |
| expect(RPAREN); |
| return new SynchronizedStatement(p, e, parseBlockStatement()); |
| } |
| |
| case INTERFACE: |
| case CLASS: |
| // Inner class. |
| return parseLocalClass(0); |
| |
| case CONST: |
| case ABSTRACT: |
| case FINAL: |
| case STRICTFP: { |
| // a declaration of some sort |
| long p = pos; |
| |
| // A class which is local to a block is not a member, and so |
| // cannot be public, private, protected, or static. It is in |
| // effect private to the block, since it cannot be used outside |
| // its scope. |
| // |
| // However, any class (if it has a name) can be declared final, |
| // abstract, or strictfp. |
| int mod = parseModifiers(M_FINAL | M_ABSTRACT |
| | M_STRICTFP ); |
| |
| switch (token) { |
| case INTERFACE: |
| case CLASS: |
| return parseLocalClass(mod); |
| |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case SHORT: |
| case INT: |
| case LONG: |
| case FLOAT: |
| case DOUBLE: |
| case IDENT: { |
| if ((mod & (M_ABSTRACT | M_STRICTFP )) != 0) { |
| mod &= ~ (M_ABSTRACT | M_STRICTFP ); |
| expect(CLASS); |
| } |
| Expression e = parseExpression(); |
| if (token != IDENT) { |
| expect(IDENT); |
| } |
| // declaration: final expr expr |
| Statement s = parseDeclaration(p, mod, e); |
| expect(SEMICOLON); |
| return s; |
| } |
| |
| default: |
| env.error(pos, "type.expected"); |
| throw new SyntaxError(); |
| } |
| } |
| |
| case VOID: |
| case STATIC: |
| case PUBLIC: |
| case PRIVATE: |
| case TRANSIENT: |
| // This is the start of something outside a statement |
| env.error(pos, "statement.expected"); |
| throw new SyntaxError(); |
| } |
| |
| long p = pos; |
| Expression e = parseExpression(); |
| |
| if (token == IDENT) { |
| // declaration: expr expr |
| Statement s = parseDeclaration(p, 0, e); |
| expect(SEMICOLON); |
| return s; |
| } |
| if (token == COLON) { |
| // label: id: stat |
| scan(); |
| Statement s = parseStatement(); |
| s.setLabel(env, e); |
| return s; |
| } |
| |
| // it was just an expression... |
| topLevelExpression(e); |
| expect(SEMICOLON); |
| return new ExpressionStatement(p, e); |
| } |
| |
| protected Statement parseBlockStatement() throws SyntaxError, IOException { |
| // compound statement: { stat1 stat2 ... statn } |
| if (token != LBRACE) { |
| // We're expecting a block statement. But we'll probably do the |
| // least damage if we try to parse a normal statement instead. |
| env.error(scanner.prevPos, "token.expected", opNames[LBRACE]); |
| return parseStatement(); |
| } |
| long p = scan(); |
| int i = argIndex; |
| while ((token != EOF) && (token != RBRACE)) { |
| int j = argIndex; |
| try { |
| addArgument(parseStatement()); |
| } catch (SyntaxError e) { |
| argIndex = j; |
| if (!recoverStatement()) { |
| throw e; |
| } |
| } |
| } |
| |
| expect(RBRACE); |
| return new CompoundStatement(p, statArgs(i)); |
| } |
| |
| |
| /** |
| * Parse an identifier. ie: a.b.c returns "a.b.c" |
| * If star is true then "a.b.*" is allowed. |
| * The return value encodes both the identifier and its location. |
| */ |
| protected IdentifierToken parseName(boolean star) throws SyntaxError, IOException { |
| IdentifierToken res = scanner.getIdToken(); |
| expect(IDENT); |
| |
| if (token != FIELD) { |
| return res; |
| } |
| |
| StringBuffer buf = new StringBuffer(res.id.toString()); |
| |
| while (token == FIELD) { |
| scan(); |
| if ((token == MUL) && star) { |
| scan(); |
| buf.append(".*"); |
| break; |
| } |
| |
| buf.append('.'); |
| if (token == IDENT) { |
| buf.append(scanner.idValue); |
| } |
| expect(IDENT); |
| } |
| |
| res.id = Identifier.lookup(buf.toString()); |
| return res; |
| } |
| /** |
| * @deprecated |
| * @see #parseName |
| */ |
| @Deprecated |
| protected Identifier parseIdentifier(boolean star) throws SyntaxError, IOException { |
| return parseName(star).id; |
| } |
| |
| /** |
| * Parse a type expression, this results in a Type. |
| * The parse includes trailing array brackets. |
| */ |
| protected Type parseType() throws SyntaxError, IOException { |
| Type t; |
| |
| switch (token) { |
| case IDENT: |
| t = Type.tClass(parseName(false).id); |
| break; |
| case VOID: |
| scan(); |
| t = Type.tVoid; |
| break; |
| case BOOLEAN: |
| scan(); |
| t = Type.tBoolean; |
| break; |
| case BYTE: |
| scan(); |
| t = Type.tByte; |
| break; |
| case CHAR: |
| scan(); |
| t = Type.tChar; |
| break; |
| case SHORT: |
| scan(); |
| t = Type.tShort; |
| break; |
| case INT: |
| scan(); |
| t = Type.tInt; |
| break; |
| case FLOAT: |
| scan(); |
| t = Type.tFloat; |
| break; |
| case LONG: |
| scan(); |
| t = Type.tLong; |
| break; |
| case DOUBLE: |
| scan(); |
| t = Type.tDouble; |
| break; |
| default: |
| env.error(pos, "type.expected"); |
| throw new SyntaxError(); |
| } |
| return parseArrayBrackets(t); |
| } |
| |
| /** |
| * Parse the tail of a type expression, which might be array brackets. |
| * Return the given type, as possibly modified by the suffix. |
| */ |
| protected Type parseArrayBrackets(Type t) throws SyntaxError, IOException { |
| |
| // Parse []'s |
| while (token == LSQBRACKET) { |
| scan(); |
| if (token != RSQBRACKET) { |
| env.error(pos, "array.dim.in.decl"); |
| parseExpression(); |
| } |
| expect(RSQBRACKET); |
| t = Type.tArray(t); |
| } |
| return t; |
| } |
| |
| /* |
| * Dealing with argument lists, I'm not using |
| * Vector for efficiency. |
| */ |
| |
| private int aCount = 0; |
| private Type aTypes[] = new Type[8]; |
| private IdentifierToken aNames[] = new IdentifierToken[aTypes.length]; |
| |
| private void addArgument(int mod, Type t, IdentifierToken nm) { |
| nm.modifiers = mod; |
| if (aCount >= aTypes.length) { |
| Type newATypes[] = new Type[aCount * 2]; |
| System.arraycopy(aTypes, 0, newATypes, 0, aCount); |
| aTypes = newATypes; |
| IdentifierToken newANames[] = new IdentifierToken[aCount * 2]; |
| System.arraycopy(aNames, 0, newANames, 0, aCount); |
| aNames = newANames; |
| } |
| aTypes[aCount] = t; |
| aNames[aCount++] = nm; |
| } |
| |
| /** |
| * Parse a possibly-empty sequence of modifier keywords. |
| * Return the resulting bitmask. |
| * Diagnose repeated modifiers, but make no other checks. |
| * Only modifiers mentioned in the given bitmask are scanned; |
| * an unmatched modifier must be handled by the caller. |
| */ |
| protected int parseModifiers(int mask) throws IOException { |
| int mod = 0; |
| while (true) { |
| if (token==CONST) { |
| // const isn't in java, but handle a common C++ usage gently |
| env.error(pos, "not.supported", "const"); |
| scan(); |
| } |
| int nextmod = 0; |
| switch (token) { |
| case PRIVATE: nextmod = M_PRIVATE; break; |
| case PUBLIC: nextmod = M_PUBLIC; break; |
| case PROTECTED: nextmod = M_PROTECTED; break; |
| case STATIC: nextmod = M_STATIC; break; |
| case TRANSIENT: nextmod = M_TRANSIENT; break; |
| case FINAL: nextmod = M_FINAL; break; |
| case ABSTRACT: nextmod = M_ABSTRACT; break; |
| case NATIVE: nextmod = M_NATIVE; break; |
| case VOLATILE: nextmod = M_VOLATILE; break; |
| case SYNCHRONIZED: nextmod = M_SYNCHRONIZED; break; |
| case STRICTFP: nextmod = M_STRICTFP; break; |
| } |
| if ((nextmod & mask) == 0) { |
| break; |
| } |
| if ((nextmod & mod) != 0) { |
| env.error(pos, "repeated.modifier"); |
| } |
| mod |= nextmod; |
| scan(); |
| } |
| return mod; |
| } |
| |
| private ClassDefinition curClass; |
| |
| /** |
| * Parse a field. |
| */ |
| protected void parseField() throws SyntaxError, IOException { |
| |
| // Empty fields are not allowed by the JLS but are accepted by |
| // the compiler, and much code has come to rely on this. It has |
| // been decided that the language will be extended to legitimize them. |
| if (token == SEMICOLON) { |
| // empty field |
| scan(); |
| return; |
| } |
| |
| // Optional doc comment |
| String doc = scanner.docComment; |
| |
| // The start of the field |
| long p = pos; |
| |
| // Parse the modifiers |
| int mod = parseModifiers(MM_FIELD | MM_METHOD); |
| |
| // Check for static initializer |
| // ie: static { ... } |
| // or an instance initializer (w/o the static). |
| if ((mod == (mod & M_STATIC)) && (token == LBRACE)) { |
| // static initializer |
| actions.defineField(p, curClass, doc, mod, |
| Type.tMethod(Type.tVoid), |
| new IdentifierToken(idClassInit), null, null, |
| parseStatement()); |
| return; |
| } |
| |
| // Check for inner class |
| if (token == CLASS || token == INTERFACE) { |
| parseNamedClass(mod, CLASS, doc); |
| return; |
| } |
| |
| // Parse the type |
| p = pos; |
| Type t = parseType(); |
| IdentifierToken id = null; |
| |
| // Check that the type is followed by an Identifier |
| // (the name of the method or the first variable), |
| // otherwise it is a constructor. |
| switch (token) { |
| case IDENT: |
| id = scanner.getIdToken(); |
| p = scan(); |
| break; |
| |
| case LPAREN: |
| // It is a constructor |
| id = new IdentifierToken(idInit); |
| if ((mod & M_STRICTFP) != 0) |
| env.error(pos, "bad.constructor.modifier"); |
| break; |
| |
| default: |
| expect(IDENT); |
| } |
| |
| // If the next token is a left-bracket then we |
| // are dealing with a method or constructor, otherwise it is |
| // a list of variables |
| if (token == LPAREN) { |
| // It is a method or constructor declaration |
| scan(); |
| aCount = 0; |
| |
| if (token != RPAREN) { |
| // Parse argument type and identifier |
| // (arguments (like locals) are allowed to be final) |
| int am = parseModifiers(M_FINAL); |
| Type at = parseType(); |
| IdentifierToken an = scanner.getIdToken(); |
| expect(IDENT); |
| |
| // Parse optional array specifier, ie: a[][] |
| at = parseArrayBrackets(at); |
| addArgument(am, at, an); |
| |
| // If the next token is a comma then there are |
| // more arguments |
| while (token == COMMA) { |
| // Parse argument type and identifier |
| scan(); |
| am = parseModifiers(M_FINAL); |
| at = parseType(); |
| an = scanner.getIdToken(); |
| expect(IDENT); |
| |
| // Parse optional array specifier, ie: a[][] |
| at = parseArrayBrackets(at); |
| addArgument(am, at, an); |
| } |
| } |
| expect(RPAREN); |
| |
| // Parse optional array sepecifier, ie: foo()[][] |
| t = parseArrayBrackets(t); |
| |
| // copy arguments |
| Type atypes[] = new Type[aCount]; |
| System.arraycopy(aTypes, 0, atypes, 0, aCount); |
| |
| IdentifierToken anames[] = new IdentifierToken[aCount]; |
| System.arraycopy(aNames, 0, anames, 0, aCount); |
| |
| // Construct the type signature |
| t = Type.tMethod(t, atypes); |
| |
| // Parse and ignore throws clause |
| IdentifierToken exp[] = null; |
| if (token == THROWS) { |
| Vector v = new Vector(); |
| scan(); |
| v.addElement(parseName(false)); |
| while (token == COMMA) { |
| scan(); |
| v.addElement(parseName(false)); |
| } |
| |
| exp = new IdentifierToken[v.size()]; |
| v.copyInto(exp); |
| } |
| |
| // Check if it is a method definition or a method declaration |
| // ie: foo() {...} or foo(); |
| switch (token) { |
| case LBRACE: // It's a method definition |
| |
| // Set the state of FP strictness for the body of the method |
| int oldFPstate = FPstate; |
| if ((mod & M_STRICTFP)!=0) { |
| FPstate = M_STRICTFP; |
| } else { |
| mod |= FPstate & M_STRICTFP; |
| } |
| |
| actions.defineField(p, curClass, doc, mod, t, id, |
| anames, exp, parseStatement()); |
| |
| FPstate = oldFPstate; |
| |
| break; |
| |
| case SEMICOLON: |
| scan(); |
| actions.defineField(p, curClass, doc, mod, t, id, |
| anames, exp, null); |
| break; |
| |
| default: |
| // really expected a statement body here |
| if ((mod & (M_NATIVE | M_ABSTRACT)) == 0) { |
| expect(LBRACE); |
| } else { |
| expect(SEMICOLON); |
| } |
| } |
| return; |
| } |
| |
| // It is a list of instance variables |
| while (true) { |
| p = pos; // get the current position |
| // parse the array brackets (if any) |
| // ie: var[][][] |
| Type vt = parseArrayBrackets(t); |
| |
| // Parse the optional initializer |
| Node init = null; |
| if (token == ASSIGN) { |
| scan(); |
| init = parseExpression(); |
| } |
| |
| // Define the variable |
| actions.defineField(p, curClass, doc, mod, vt, id, |
| null, null, init); |
| |
| // If the next token is a comma, then there is more |
| if (token != COMMA) { |
| expect(SEMICOLON); |
| return; |
| } |
| scan(); |
| |
| // The next token must be an identifier |
| id = scanner.getIdToken(); |
| expect(IDENT); |
| } |
| } |
| |
| /** |
| * Recover after a syntax error in a field. This involves |
| * discarding tokens until an EOF or a possible legal |
| * continuation is encountered. |
| */ |
| protected void recoverField(ClassDefinition newClass) throws SyntaxError, IOException { |
| while (true) { |
| switch (token) { |
| case EOF: |
| case STATIC: |
| case FINAL: |
| case PUBLIC: |
| case PRIVATE: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| |
| case VOID: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case SHORT: |
| case INT: |
| case FLOAT: |
| case LONG: |
| case DOUBLE: |
| // possible begin of a field, continue |
| return; |
| |
| case LBRACE: |
| match(LBRACE, RBRACE); |
| scan(); |
| break; |
| |
| case LPAREN: |
| match(LPAREN, RPAREN); |
| scan(); |
| break; |
| |
| case LSQBRACKET: |
| match(LSQBRACKET, RSQBRACKET); |
| scan(); |
| break; |
| |
| case RBRACE: |
| case INTERFACE: |
| case CLASS: |
| case IMPORT: |
| case PACKAGE: |
| // begin of something outside a class, panic more |
| actions.endClass(pos, newClass); |
| throw new SyntaxError(); |
| |
| default: |
| // don't know what to do, skip |
| scan(); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Parse a top-level class or interface declaration. |
| */ |
| protected void parseClass() throws SyntaxError, IOException { |
| String doc = scanner.docComment; |
| |
| // Parse the modifiers. |
| int mod = parseModifiers(MM_CLASS | MM_MEMBER); |
| |
| parseNamedClass(mod, PACKAGE, doc); |
| } |
| |
| // Current strict/default state of floating point. This is |
| // set and reset with a stack discipline around methods and named |
| // classes. Only M_STRICTFP may be set in this word. try... |
| // finally is not needed to protect setting and resetting because |
| // there are no error messages based on FPstate. |
| private int FPstate = 0; |
| |
| /** |
| * Parse a block-local class or interface declaration. |
| */ |
| protected Statement parseLocalClass(int mod) throws SyntaxError, IOException { |
| long p = pos; |
| ClassDefinition body = parseNamedClass(M_LOCAL | mod, STAT, null); |
| Statement ds[] = { |
| new VarDeclarationStatement(p, new LocalMember(body), null) |
| }; |
| Expression type = new TypeExpression(p, body.getType()); |
| return new DeclarationStatement(p, 0, type, ds); |
| } |
| |
| /** |
| * Parse a named class or interface declaration, |
| * starting at "class" or "interface". |
| * @arg ctx Syntactic context of the class, one of {PACKAGE CLASS STAT EXPR}. |
| */ |
| protected ClassDefinition parseNamedClass(int mod, int ctx, String doc) throws SyntaxError, IOException { |
| // Parse class/interface |
| switch (token) { |
| case INTERFACE: |
| scan(); |
| mod |= M_INTERFACE; |
| break; |
| |
| case CLASS: |
| scan(); |
| break; |
| |
| default: |
| env.error(pos, "class.expected"); |
| break; |
| } |
| |
| int oldFPstate = FPstate; |
| if ((mod & M_STRICTFP)!=0) { |
| FPstate = M_STRICTFP; |
| } else { |
| // The & (...) isn't really necessary here because we do maintain |
| // the invariant that FPstate has no extra bits set. |
| mod |= FPstate & M_STRICTFP; |
| } |
| |
| // Parse the class name |
| IdentifierToken nm = scanner.getIdToken(); |
| long p = pos; |
| expect(IDENT); |
| |
| Vector ext = new Vector(); |
| Vector impl = new Vector(); |
| parseInheritance(ext, impl); |
| |
| ClassDefinition tmp = parseClassBody(nm, mod, ctx, doc, ext, impl, p); |
| |
| FPstate = oldFPstate; |
| |
| return tmp; |
| } |
| |
| protected void parseInheritance(Vector ext, Vector impl) throws SyntaxError, IOException { |
| // Parse extends clause |
| if (token == EXTENDS) { |
| scan(); |
| ext.addElement(parseName(false)); |
| while (token == COMMA) { |
| scan(); |
| ext.addElement(parseName(false)); |
| } |
| } |
| |
| // Parse implements clause |
| if (token == IMPLEMENTS) { |
| scan(); |
| impl.addElement(parseName(false)); |
| while (token == COMMA) { |
| scan(); |
| impl.addElement(parseName(false)); |
| } |
| } |
| } |
| |
| /** |
| * Parse the body of a class or interface declaration, |
| * starting at the left brace. |
| */ |
| protected ClassDefinition parseClassBody(IdentifierToken nm, int mod, |
| int ctx, String doc, |
| Vector ext, Vector impl, long p |
| ) throws SyntaxError, IOException { |
| // Decide which is the super class |
| IdentifierToken sup = null; |
| if ((mod & M_INTERFACE) != 0) { |
| if (impl.size() > 0) { |
| env.error(((IdentifierToken)impl.elementAt(0)).getWhere(), |
| "intf.impl.intf"); |
| } |
| impl = ext; |
| } else { |
| if (ext.size() > 0) { |
| if (ext.size() > 1) { |
| env.error(((IdentifierToken)ext.elementAt(1)).getWhere(), |
| "multiple.inherit"); |
| } |
| sup = (IdentifierToken)ext.elementAt(0); |
| } |
| } |
| |
| ClassDefinition oldClass = curClass; |
| |
| // Begin a new class |
| IdentifierToken implids[] = new IdentifierToken[impl.size()]; |
| impl.copyInto(implids); |
| ClassDefinition newClass = |
| actions.beginClass(p, doc, mod, nm, sup, implids); |
| |
| // Parse fields |
| expect(LBRACE); |
| while ((token != EOF) && (token != RBRACE)) { |
| try { |
| curClass = newClass; |
| parseField(); |
| } catch (SyntaxError e) { |
| recoverField(newClass); |
| } finally { |
| curClass = oldClass; |
| } |
| } |
| expect(RBRACE); |
| |
| // End the class |
| actions.endClass(scanner.prevPos, newClass); |
| return newClass; |
| } |
| |
| /** |
| * Recover after a syntax error in the file. |
| * This involves discarding tokens until an EOF |
| * or a possible legal continuation is encountered. |
| */ |
| protected void recoverFile() throws IOException { |
| while (true) { |
| switch (token) { |
| case CLASS: |
| case INTERFACE: |
| // Start of a new source file statement, continue |
| return; |
| |
| case LBRACE: |
| match(LBRACE, RBRACE); |
| scan(); |
| break; |
| |
| case LPAREN: |
| match(LPAREN, RPAREN); |
| scan(); |
| break; |
| |
| case LSQBRACKET: |
| match(LSQBRACKET, RSQBRACKET); |
| scan(); |
| break; |
| |
| case EOF: |
| return; |
| |
| default: |
| // Don't know what to do, skip |
| scan(); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Parse an Java file. |
| */ |
| public void parseFile() { |
| try { |
| try { |
| if (token == PACKAGE) { |
| // Package statement |
| long p = scan(); |
| IdentifierToken id = parseName(false); |
| expect(SEMICOLON); |
| actions.packageDeclaration(p, id); |
| } |
| } catch (SyntaxError e) { |
| recoverFile(); |
| } |
| while (token == IMPORT) { |
| try{ |
| // Import statement |
| long p = scan(); |
| IdentifierToken id = parseName(true); |
| expect(SEMICOLON); |
| if (id.id.getName().equals(idStar)) { |
| id.id = id.id.getQualifier(); |
| actions.importPackage(p, id); |
| } else { |
| actions.importClass(p, id); |
| } |
| } catch (SyntaxError e) { |
| recoverFile(); |
| } |
| } |
| |
| while (token != EOF) { |
| try { |
| switch (token) { |
| case FINAL: |
| case PUBLIC: |
| case PRIVATE: |
| case ABSTRACT: |
| case CLASS: |
| case INTERFACE: |
| case STRICTFP: |
| // Start of a class |
| parseClass(); |
| break; |
| |
| case SEMICOLON: |
| // Bogus semicolon. |
| // According to the JLS (7.6,19.6), a TypeDeclaration |
| // may consist of a single semicolon, however, this |
| // usage is discouraged (JLS 7.6). In contrast, |
| // a FieldDeclaration may not be empty, and is flagged |
| // as an error. See parseField above. |
| scan(); |
| break; |
| |
| case EOF: |
| // The end |
| return; |
| |
| default: |
| // Oops |
| env.error(pos, "toplevel.expected"); |
| throw new SyntaxError(); |
| } |
| } catch (SyntaxError e) { |
| recoverFile(); |
| } |
| } |
| } catch (IOException e) { |
| env.error(pos, "io.exception", env.getSource()); |
| return; |
| } |
| } |
| |
| /** |
| * Usually <code>this.scanner == (Scanner)this</code>. |
| * However, a delegate scanner can produce tokens for this parser, |
| * in which case <code>(Scanner)this</code> is unused, |
| * except for <code>this.token</code> and <code>this.pos</code> |
| * instance variables which are filled from the real scanner |
| * by <code>this.scan()</code> and the constructor. |
| */ |
| protected Scanner scanner; |
| |
| // Design Note: We ought to disinherit Parser from Scanner. |
| // We also should split out the interface ParserActions from |
| // Parser, and make BatchParser implement ParserActions, |
| // not extend Parser. This would split scanning, parsing, |
| // and class building into distinct responsibility areas. |
| // (Perhaps tree building could be virtualized too.) |
| |
| public long scan() throws IOException { |
| if (scanner != this && scanner != null) { |
| long result = scanner.scan(); |
| ((Scanner)this).token = scanner.token; |
| ((Scanner)this).pos = scanner.pos; |
| return result; |
| } |
| return super.scan(); |
| } |
| |
| public void match(int open, int close) throws IOException { |
| if (scanner != this) { |
| scanner.match(open, close); |
| ((Scanner)this).token = scanner.token; |
| ((Scanner)this).pos = scanner.pos; |
| return; |
| } |
| super.match(open, close); |
| } |
| } |
