Back to index...

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

Back to index...