/*
* 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);
}
}