My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/tools/java/Parser.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/tools/java/Parser.java+2130−0

@@ -0,0 +1,2130 @@
	1	+/*
	2	+ * Copyright (c) 1994, 2004, Oracle and/or its affiliates. All rights reserved.
	3	+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	+ *
	5	+ * This code is free software; you can redistribute it and/or modify it
	6	+ * under the terms of the GNU General Public License version 2 only, as
	7	+ * published by the Free Software Foundation. Oracle designates this
	8	+ * particular file as subject to the "Classpath" exception as provided
	9	+ * by Oracle in the LICENSE file that accompanied this code.
	10	+ *
	11	+ * This code is distributed in the hope that it will be useful, but WITHOUT
	12	+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	+ * version 2 for more details (a copy is included in the LICENSE file that
	15	+ * accompanied this code).
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License version
	18	+ * 2 along with this work; if not, write to the Free Software Foundation,
	19	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	+ *
	21	+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	+ * or visit www.oracle.com if you need additional information or have any
	23	+ * questions.
	24	+ */
	25	+
	26	+package sun.tools.java;
	27	+
	28	+import sun.tools.tree.*;
	29	+import java.io.IOException;
	30	+import java.io.InputStream;
	31	+import java.util.Enumeration;
	32	+import java.util.Vector;
	33	+
	34	+/**
	35	+ * This class is used to parse Java statements and expressions.
	36	+ * The result is a parse tree.<p>
	37	+ *
	38	+ * This class implements an operator precedence parser. Errors are
	39	+ * reported to the Environment object, if the error can't be
	40	+ * resolved immediately, a SyntaxError exception is thrown.<p>
	41	+ *
	42	+ * Error recovery is implemented by catching SyntaxError exceptions
	43	+ * and discarding input tokens until an input token is reached that
	44	+ * is possibly a legal continuation.<p>
	45	+ *
	46	+ * The parse tree that is constructed represents the input
	47	+ * exactly (no rewrites to simpler forms). This is important
	48	+ * if the resulting tree is to be used for code formatting in
	49	+ * a programming environment. Currently only documentation comments
	50	+ * are retained.<p>
	51	+ *
	52	+ * The parsing algorithm does NOT use any type information. Changes
	53	+ * in the type system do not affect the structure of the parse tree.
	54	+ * This restriction does introduce an ambiguity an expression of the
	55	+ * form: (e1) e2 is assumed to be a cast if e2 does not start with
	56	+ * an operator. That means that (a) - b is interpreted as subtract
	57	+ * b from a and not cast negative b to type a. However, if a is a
	58	+ * simple type (byte, int, ...) then it is assumed to be a cast.<p>
	59	+ *
	60	+ * WARNING: The contents of this source file are not part of any
	61	+ * supported API. Code that depends on them does so at its own risk:
	62	+ * they are subject to change or removal without notice.
	63	+ *
	64	+ * @author Arthur van Hoff
	65	+ */
	66	+
	67	+public
	68	+class Parser extends Scanner implements ParserActions, Constants {
	69	+ /**
	70	+ * Create a parser
	71	+ */
	72	+ protected Parser(Environment env, InputStream in) throws IOException {
	73	+ super(env, in);
	74	+ this.scanner = this;
	75	+ this.actions = this;
	76	+ }
	77	+
	78	+ /**
	79	+ * Create a parser, given a scanner.
	80	+ */
	81	+ protected Parser(Scanner scanner) throws IOException {
	82	+ super(scanner.env);
	83	+ this.scanner = scanner;
	84	+ ((Scanner)this).env = scanner.env;
	85	+ ((Scanner)this).token = scanner.token;
	86	+ ((Scanner)this).pos = scanner.pos;
	87	+ this.actions = this;
	88	+ }
	89	+
	90	+ /**
	91	+ * Create a parser, given a scanner and the semantic callback.
	92	+ */
	93	+ public Parser(Scanner scanner, ParserActions actions) throws IOException {
	94	+ this(scanner);
	95	+ this.actions = actions;
	96	+ }
	97	+
	98	+ /**
	99	+ * Usually <code>this.actions == (ParserActions)this</code>.
	100	+ * However, a delegate scanner can produce tokens for this parser,
	101	+ * in which case <code>(Scanner)this</code> is unused,
	102	+ * except for <code>this.token</code> and <code>this.pos</code>
	103	+ * instance variables which are filled from the real scanner
	104	+ * by <code>this.scan()</code> and the constructor.
	105	+ */
	106	+ ParserActions actions;
	107	+
	108	+ // Note: The duplication of methods allows pre-1.1 classes to
	109	+ // be binary compatible with the new version of the parser,
	110	+ // which now passes IdentifierTokens to the semantics phase,
	111	+ // rather than just Identifiers. This change is necessary,
	112	+ // since the parser is no longer responsible for managing the
	113	+ // resolution of type names. (That caused the "Vector" bug.)
	114	+ //
	115	+ // In a future release, the old "plain-Identifier" methods will
	116	+ // go away, and the corresponding "IdentifierToken" methods
	117	+ // may become abstract.
	118	+
	119	+ /**
	120	+ * package declaration
	121	+ * @deprecated
	122	+ */
	123	+ @Deprecated
	124	+ public void packageDeclaration(long off, IdentifierToken nm) {
	125	+ // By default, call the deprecated version.
	126	+ // Any application must override one of the packageDeclaration methods.
	127	+ packageDeclaration(off, nm.id);
	128	+ }
	129	+ /**
	130	+ * @deprecated
	131	+ */
	132	+ @Deprecated
	133	+ protected void packageDeclaration(long off, Identifier nm) {
	134	+ throw new RuntimeException("beginClass method is abstract");
	135	+ }
	136	+
	137	+ /**
	138	+ * import class
	139	+ * @deprecated
	140	+ */
	141	+ @Deprecated
	142	+ public void importClass(long off, IdentifierToken nm) {
	143	+ // By default, call the deprecated version.
	144	+ // Any application must override one of the packageDeclaration methods.
	145	+ importClass(off, nm.id);
	146	+ }
	147	+ /**
	148	+ * @deprecated Use the version with the IdentifierToken arguments.
	149	+ */
	150	+ @Deprecated
	151	+ protected void importClass(long off, Identifier nm) {
	152	+ throw new RuntimeException("importClass method is abstract");
	153	+ }
	154	+
	155	+ /**
	156	+ * import package
	157	+ * @deprecated
	158	+ */
	159	+ @Deprecated
	160	+ public void importPackage(long off, IdentifierToken nm) {
	161	+ // By default, call the deprecated version.
	162	+ // Any application must override one of the importPackage methods.
	163	+ importPackage(off, nm.id);
	164	+ }
	165	+ /**
	166	+ * @deprecated Use the version with the IdentifierToken arguments.
	167	+ */
	168	+ @Deprecated
	169	+ protected void importPackage(long off, Identifier nm) {
	170	+ throw new RuntimeException("importPackage method is abstract");
	171	+ }
	172	+
	173	+ /**
	174	+ * Define class
	175	+ * @deprecated
	176	+ */
	177	+ @Deprecated
	178	+ public ClassDefinition beginClass(long off, String doc,
	179	+ int mod, IdentifierToken nm,
	180	+ IdentifierToken sup,
	181	+ IdentifierToken impl[]) {
	182	+ // By default, call the deprecated version.
	183	+ // Any application must override one of the beginClass methods.
	184	+ Identifier supId = (sup == null) ? null : sup.id;
	185	+ Identifier implIds[] = null;
	186	+ if (impl != null) {
	187	+ implIds = new Identifier[impl.length];
	188	+ for (int i = 0; i < impl.length; i++) {
	189	+ implIds[i] = impl[i].id;
	190	+ }
	191	+ }
	192	+ beginClass(off, doc, mod, nm.id, supId, implIds);
	193	+ return getCurrentClass();
	194	+ }
	195	+ /**
	196	+ * @deprecated Use the version with the IdentifierToken arguments.
	197	+ */
	198	+ @Deprecated
	199	+ protected void beginClass(long off, String doc, int mod, Identifier nm,
	200	+ Identifier sup, Identifier impl[]) {
	201	+ throw new RuntimeException("beginClass method is abstract");
	202	+ }
	203	+
	204	+ /**
	205	+ * Report the current class under construction.
	206	+ * By default, it's a no-op which returns null.
	207	+ * It may only be called before the corresponding endClass().
	208	+ */
	209	+ protected ClassDefinition getCurrentClass() {
	210	+ return null;
	211	+ }
	212	+
	213	+ /**
	214	+ * End class
	215	+ * @deprecated
	216	+ */
	217	+ @Deprecated
	218	+ public void endClass(long off, ClassDefinition c) {
	219	+ // By default, call the deprecated version.
	220	+ // Any application must override one of the beginClass methods.
	221	+ endClass(off, c.getName().getFlatName().getName());
	222	+ }
	223	+ /**
	224	+ * @deprecated Use the version with the IdentifierToken arguments.
	225	+ */
	226	+ @Deprecated
	227	+ protected void endClass(long off, Identifier nm) {
	228	+ throw new RuntimeException("endClass method is abstract");
	229	+ }
	230	+
	231	+ /**
	232	+ * Define a field
	233	+ * @deprecated
	234	+ */
	235	+ @Deprecated
	236	+ public void defineField(long where, ClassDefinition c,
	237	+ String doc, int mod, Type t,
	238	+ IdentifierToken nm, IdentifierToken args[],
	239	+ IdentifierToken exp[], Node val) {
	240	+ // By default, call the deprecated version.
	241	+ // Any application must override one of the defineField methods.
	242	+ Identifier argIds[] = null;
	243	+ Identifier expIds[] = null;
	244	+ if (args != null) {
	245	+ argIds = new Identifier[args.length];
	246	+ for (int i = 0; i < args.length; i++) {
	247	+ argIds[i] = args[i].id;
	248	+ }
	249	+ }
	250	+ if (exp != null) {
	251	+ expIds = new Identifier[exp.length];
	252	+ for (int i = 0; i < exp.length; i++) {
	253	+ expIds[i] = exp[i].id;
	254	+ }
	255	+ }
	256	+ defineField(where, doc, mod, t, nm.id, argIds, expIds, val);
	257	+ }
	258	+
	259	+ /**
	260	+ * @deprecated Use the version with the IdentifierToken arguments.
	261	+ */
	262	+ @Deprecated
	263	+ protected void defineField(long where, String doc, int mod, Type t,
	264	+ Identifier nm, Identifier args[],
	265	+ Identifier exp[], Node val) {
	266	+ throw new RuntimeException("defineField method is abstract");
	267	+ }
	268	+
	269	+ /*
	270	+ * A growable array of nodes. It is used as a growable
	271	+ * buffer to hold argument lists and expression lists.
	272	+ * I'm not using Vector to make it more efficient.
	273	+ */
	274	+ private Node args[] = new Node[32];
	275	+ protected int argIndex = 0;
	276	+
	277	+ protected final void addArgument(Node n) {
	278	+ if (argIndex == args.length) {
	279	+ Node newArgs[] = new Node[args.length * 2];
	280	+ System.arraycopy(args, 0, newArgs, 0, args.length);
	281	+ args = newArgs;
	282	+ }
	283	+ args[argIndex++] = n;
	284	+ }
	285	+ protected final Expression exprArgs(int index)[] {
	286	+ Expression e[] = new Expression[argIndex - index];
	287	+ System.arraycopy(args, index, e, 0, argIndex - index);
	288	+ argIndex = index;
	289	+ return e;
	290	+ }
	291	+ protected final Statement statArgs(int index)[] {
	292	+ Statement s[] = new Statement[argIndex - index];
	293	+ System.arraycopy(args, index, s, 0, argIndex - index);
	294	+ argIndex = index;
	295	+ return s;
	296	+ }
	297	+
	298	+ /**
	299	+ * Expect a token, return its value, scan the next token or
	300	+ * throw an exception.
	301	+ */
	302	+ protected void expect(int t) throws SyntaxError, IOException {
	303	+ if (token != t) {
	304	+ switch (t) {
	305	+ case IDENT:
	306	+ env.error(scanner.prevPos, "identifier.expected");
	307	+ break;
	308	+ default:
	309	+ env.error(scanner.prevPos, "token.expected", opNames[t]);
	310	+ break;
	311	+ }
	312	+ throw new SyntaxError();
	313	+ }
	314	+ scan();
	315	+ }
	316	+
	317	+ /**
	318	+ * Parse a type expression. Does not parse the []'s.
	319	+ */
	320	+ protected Expression parseTypeExpression() throws SyntaxError, IOException {
	321	+ switch (token) {
	322	+ case VOID:
	323	+ return new TypeExpression(scan(), Type.tVoid);
	324	+ case BOOLEAN:
	325	+ return new TypeExpression(scan(), Type.tBoolean);
	326	+ case BYTE:
	327	+ return new TypeExpression(scan(), Type.tByte);
	328	+ case CHAR:
	329	+ return new TypeExpression(scan(), Type.tChar);
	330	+ case SHORT:
	331	+ return new TypeExpression(scan(), Type.tShort);
	332	+ case INT:
	333	+ return new TypeExpression(scan(), Type.tInt);
	334	+ case LONG:
	335	+ return new TypeExpression(scan(), Type.tLong);
	336	+ case FLOAT:
	337	+ return new TypeExpression(scan(), Type.tFloat);
	338	+ case DOUBLE:
	339	+ return new TypeExpression(scan(), Type.tDouble);
	340	+ case IDENT:
	341	+ Expression e = new IdentifierExpression(pos, scanner.idValue);
	342	+ scan();
	343	+ while (token == FIELD) {
	344	+ e = new FieldExpression(scan(), e, scanner.idValue);
	345	+ expect(IDENT);
	346	+ }
	347	+ return e;
	348	+ }
	349	+
	350	+ env.error(pos, "type.expected");
	351	+ throw new SyntaxError();
	352	+ }
	353	+
	354	+ /**
	355	+ * Parse a method invocation. Should be called when the current
	356	+ * then is the '(' of the argument list.
	357	+ */
	358	+ protected Expression parseMethodExpression(Expression e, Identifier id) throws SyntaxError, IOException {
	359	+ long p = scan();
	360	+ int i = argIndex;
	361	+ if (token != RPAREN) {
	362	+ addArgument(parseExpression());
	363	+ while (token == COMMA) {
	364	+ scan();
	365	+ addArgument(parseExpression());
	366	+ }
	367	+ }
	368	+ expect(RPAREN);
	369	+ return new MethodExpression(p, e, id, exprArgs(i));
	370	+ }
	371	+
	372	+ /**
	373	+ * Parse a new instance expression. Should be called when the current
	374	+ * token is the '(' of the argument list.
	375	+ */
	376	+ protected Expression parseNewInstanceExpression(long p, Expression outerArg, Expression type) throws SyntaxError, IOException {
	377	+ int i = argIndex;
	378	+ expect(LPAREN);
	379	+ if (token != RPAREN) {
	380	+ addArgument(parseExpression());
	381	+ while (token == COMMA) {
	382	+ scan();
	383	+ addArgument(parseExpression());
	384	+ }
	385	+ }
	386	+ expect(RPAREN);
	387	+ ClassDefinition body = null;
	388	+ if (token == LBRACE && !(type instanceof TypeExpression)) {
	389	+ long tp = pos;
	390	+ // x = new Type(arg) { subclass body ... }
	391	+ Identifier superName = FieldExpression.toIdentifier(type);
	392	+ if (superName == null) {
	393	+ env.error(type.getWhere(), "type.expected");
	394	+ }
	395	+ Vector ext = new Vector(1);
	396	+ Vector impl = new Vector(0);
	397	+ ext.addElement(new IdentifierToken(idNull));
	398	+ if (token == IMPLEMENTS \|\| token == EXTENDS) {
	399	+ env.error(pos, "anonymous.extends");
	400	+ parseInheritance(ext, impl); // error recovery
	401	+ }
	402	+ body = parseClassBody(new IdentifierToken(tp, idNull),
	403	+ M_ANONYMOUS \| M_LOCAL, EXPR, null,
	404	+ ext, impl, type.getWhere());
	405	+ }
	406	+ if (outerArg == null && body == null) {
	407	+ return new NewInstanceExpression(p, type, exprArgs(i));
	408	+ }
	409	+ return new NewInstanceExpression(p, type, exprArgs(i), outerArg, body);
	410	+ }
	411	+
	412	+ /**
	413	+ * Parse a primary expression.
	414	+ */
	415	+ protected Expression parseTerm() throws SyntaxError, IOException {
	416	+ switch (token) {
	417	+ case CHARVAL: {
	418	+ char v = scanner.charValue;
	419	+ return new CharExpression(scan(), v);
	420	+ }
	421	+ case INTVAL: {
	422	+ int v = scanner.intValue;
	423	+ long q = scan();
	424	+ if (v < 0 && radix == 10) env.error(q, "overflow.int.dec");
	425	+ return new IntExpression(q, v);
	426	+ }
	427	+ case LONGVAL: {
	428	+ long v = scanner.longValue;
	429	+ long q = scan();
	430	+ if (v < 0 && radix == 10) env.error(q, "overflow.long.dec");
	431	+ return new LongExpression(q, v);
	432	+ }
	433	+ case FLOATVAL: {
	434	+ float v = scanner.floatValue;
	435	+ return new FloatExpression(scan(), v);
	436	+ }
	437	+ case DOUBLEVAL: {
	438	+ double v = scanner.doubleValue;
	439	+ return new DoubleExpression(scan(), v);
	440	+ }
	441	+ case STRINGVAL: {
	442	+ String v = scanner.stringValue;
	443	+ return new StringExpression(scan(), v);
	444	+ }
	445	+ case IDENT: {
	446	+ Identifier v = scanner.idValue;
	447	+ long p = scan();
	448	+ return (token == LPAREN) ?
	449	+ parseMethodExpression(null, v) : new IdentifierExpression(p, v);
	450	+ }
	451	+
	452	+ case TRUE:
	453	+ return new BooleanExpression(scan(), true);
	454	+ case FALSE:
	455	+ return new BooleanExpression(scan(), false);
	456	+ case NULL:
	457	+ return new NullExpression(scan());
	458	+
	459	+ case THIS: {
	460	+ Expression e = new ThisExpression(scan());
	461	+ return (token == LPAREN) ? parseMethodExpression(e, idInit) : e;
	462	+ }
	463	+ case SUPER: {
	464	+ Expression e = new SuperExpression(scan());
	465	+ return (token == LPAREN) ? parseMethodExpression(e, idInit) : e;
	466	+ }
	467	+
	468	+ case VOID:
	469	+ case BOOLEAN:
	470	+ case BYTE:
	471	+ case CHAR:
	472	+ case SHORT:
	473	+ case INT:
	474	+ case LONG:
	475	+ case FLOAT:
	476	+ case DOUBLE:
	477	+ return parseTypeExpression();
	478	+
	479	+ case ADD: {
	480	+ long p = scan();
	481	+ switch (token) {
	482	+ case INTVAL: {
	483	+ int v = scanner.intValue;
	484	+ long q = scan();
	485	+ if (v < 0 && radix == 10) env.error(q, "overflow.int.dec");
	486	+ return new IntExpression(q, v);
	487	+ }
	488	+ case LONGVAL: {
	489	+ long v = scanner.longValue;
	490	+ long q = scan();
	491	+ if (v < 0 && radix == 10) env.error(q, "overflow.long.dec");
	492	+ return new LongExpression(q, v);
	493	+ }
	494	+ case FLOATVAL: {
	495	+ float v = scanner.floatValue;
	496	+ return new FloatExpression(scan(), v);
	497	+ }
	498	+ case DOUBLEVAL: {
	499	+ double v = scanner.doubleValue;
	500	+ return new DoubleExpression(scan(), v);
	501	+ }
	502	+ }
	503	+ return new PositiveExpression(p, parseTerm());
	504	+ }
	505	+ case SUB: {
	506	+ long p = scan();
	507	+ switch (token) {
	508	+ case INTVAL: {
	509	+ int v = -scanner.intValue;
	510	+ return new IntExpression(scan(), v);
	511	+ }
	512	+ case LONGVAL: {
	513	+ long v = -scanner.longValue;
	514	+ return new LongExpression(scan(), v);
	515	+ }
	516	+ case FLOATVAL: {
	517	+ float v = -scanner.floatValue;
	518	+ return new FloatExpression(scan(), v);
	519	+ }
	520	+ case DOUBLEVAL: {
	521	+ double v = -scanner.doubleValue;
	522	+ return new DoubleExpression(scan(), v);
	523	+ }
	524	+ }
	525	+ return new NegativeExpression(p, parseTerm());
	526	+ }
	527	+ case NOT:
	528	+ return new NotExpression(scan(), parseTerm());
	529	+ case BITNOT:
	530	+ return new BitNotExpression(scan(), parseTerm());
	531	+ case INC:
	532	+ return new PreIncExpression(scan(), parseTerm());
	533	+ case DEC:
	534	+ return new PreDecExpression(scan(), parseTerm());
	535	+
	536	+ case LPAREN: {
	537	+ // bracketed-expr: (expr)
	538	+ long p = scan();
	539	+ Expression e = parseExpression();
	540	+ expect(RPAREN);
	541	+
	542	+ if (e.getOp() == TYPE) {
	543	+ // cast-expr: (simple-type) expr
	544	+ return new CastExpression(p, e, parseTerm());
	545	+ }
	546	+
	547	+ switch (token) {
	548	+
	549	+ // We handle INC and DEC specially.
	550	+ // See the discussion in JLS section 15.14.1.
	551	+ // (Part of fix for 4044502.)
	552	+
	553	+ case INC:
	554	+ // We know this must be a postfix increment.
	555	+ return new PostIncExpression(scan(), e);
	556	+
	557	+ case DEC:
	558	+ // We know this must be a postfix decrement.
	559	+ return new PostDecExpression(scan(), e);
	560	+
	561	+ case LPAREN:
	562	+ case CHARVAL:
	563	+ case INTVAL:
	564	+ case LONGVAL:
	565	+ case FLOATVAL:
	566	+ case DOUBLEVAL:
	567	+ case STRINGVAL:
	568	+ case IDENT:
	569	+ case TRUE:
	570	+ case FALSE:
	571	+ case NOT:
	572	+ case BITNOT:
	573	+ case THIS:
	574	+ case SUPER:
	575	+ case NULL:
	576	+ case NEW:
	577	+ // cast-expr: (expr) expr
	578	+ return new CastExpression(p, e, parseTerm());
	579	+ }
	580	+ return new ExprExpression(p, e);
	581	+ }
	582	+
	583	+ case LBRACE: {
	584	+ // array initializer: {expr1, expr2, ... exprn}
	585	+ long p = scan();
	586	+ int i = argIndex;
	587	+ if (token != RBRACE) {
	588	+ addArgument(parseExpression());
	589	+ while (token == COMMA) {
	590	+ scan();
	591	+ if (token == RBRACE) {
	592	+ break;
	593	+ }
	594	+ addArgument(parseExpression());
	595	+ }
	596	+ }
	597	+ expect(RBRACE);
	598	+ return new ArrayExpression(p, exprArgs(i));
	599	+ }
	600	+
	601	+ case NEW: {
	602	+ long p = scan();
	603	+ int i = argIndex;
	604	+
	605	+ if (token == LPAREN) {
	606	+ scan();
	607	+ Expression e = parseExpression();
	608	+ expect(RPAREN);
	609	+ env.error(p, "not.supported", "new(...)");
	610	+ return new NullExpression(p);
	611	+ }
	612	+
	613	+ Expression e = parseTypeExpression();
	614	+
	615	+ if (token == LSQBRACKET) {
	616	+ while (token == LSQBRACKET) {
	617	+ scan();
	618	+ addArgument((token != RSQBRACKET) ? parseExpression() : null);
	619	+ expect(RSQBRACKET);
	620	+ }
	621	+ Expression[] dims = exprArgs(i);
	622	+ if (token == LBRACE) {
	623	+ return new NewArrayExpression(p, e, dims, parseTerm());
	624	+ }
	625	+ return new NewArrayExpression(p, e, dims);
	626	+ } else {
	627	+ return parseNewInstanceExpression(p, null, e);
	628	+ }
	629	+ }
	630	+ }
	631	+
	632	+ // System.err.println("NEAR: " + opNames[token]);
	633	+ env.error(scanner.prevPos, "missing.term");
	634	+ return new IntExpression(pos, 0);
	635	+ }
	636	+
	637	+ /**
	638	+ * Parse an expression.
	639	+ */
	640	+ protected Expression parseExpression() throws SyntaxError, IOException {
	641	+ for (Expression e = parseTerm() ; e != null ; e = e.order()) {
	642	+ Expression more = parseBinaryExpression(e);
	643	+ if (more == null)
	644	+ return e;
	645	+ e = more;
	646	+ }
	647	+ // this return is bogus
	648	+ return null;
	649	+ }
	650	+
	651	+ /**
	652	+ * Given a left-hand term, parse an operator and right-hand term.
	653	+ */
	654	+ protected Expression parseBinaryExpression(Expression e) throws SyntaxError, IOException {
	655	+ if (e != null) {
	656	+ switch (token) {
	657	+ case LSQBRACKET: {
	658	+ // index: expr1[expr2]
	659	+ long p = scan();
	660	+ Expression index = (token != RSQBRACKET) ? parseExpression() : null;
	661	+ expect(RSQBRACKET);
	662	+ e = new ArrayAccessExpression(p, e, index);
	663	+ break;
	664	+ }
	665	+
	666	+ case INC:
	667	+ e = new PostIncExpression(scan(), e);
	668	+ break;
	669	+ case DEC:
	670	+ e = new PostDecExpression(scan(), e);
	671	+ break;
	672	+ case FIELD: {
	673	+ long p = scan();
	674	+ if (token == THIS) {
	675	+ // class C { class N { ... C.this ... } }
	676	+ // class C { class N { N(C c){ ... c.this() ... } } }
	677	+ long q = scan();
	678	+ if (token == LPAREN) {
	679	+ e = new ThisExpression(q, e);
	680	+ e = parseMethodExpression(e, idInit);
	681	+ } else {
	682	+ e = new FieldExpression(p, e, idThis);
	683	+ }
	684	+ break;
	685	+ }
	686	+ if (token == SUPER) {
	687	+ // class D extends C.N { D(C.N n) { n.super(); } }
	688	+ // Also, 'C.super', as in:
	689	+ // class C extends CS { class N { ... C.super.foo ... } }
	690	+ // class C extends CS { class N { ... C.super.foo() ... } }
	691	+ long q = scan();
	692	+ if (token == LPAREN) {
	693	+ e = new SuperExpression(q, e);
	694	+ e = parseMethodExpression(e, idInit);
	695	+ } else {
	696	+ // We must check elsewhere that this expression
	697	+ // does not stand alone, but qualifies a member name.
	698	+ e = new FieldExpression(p, e, idSuper);
	699	+ }
	700	+ break;
	701	+ }
	702	+ if (token == NEW) {
	703	+ // new C().new N()
	704	+ scan();
	705	+ if (token != IDENT)
	706	+ expect(IDENT);
	707	+ e = parseNewInstanceExpression(p, e, parseTypeExpression());
	708	+ break;
	709	+ }
	710	+ if (token == CLASS) {
	711	+ // just class literals, really
	712	+ // Class c = C.class;
	713	+ scan();
	714	+ e = new FieldExpression(p, e, idClass);
	715	+ break;
	716	+ }
	717	+ Identifier id = scanner.idValue;
	718	+ expect(IDENT);
	719	+ if (token == LPAREN) {
	720	+ e = parseMethodExpression(e, id);
	721	+ } else {
	722	+ e = new FieldExpression(p, e, id);
	723	+ }
	724	+ break;
	725	+ }
	726	+ case INSTANCEOF:
	727	+ e = new InstanceOfExpression(scan(), e, parseTerm());
	728	+ break;
	729	+ case ADD:
	730	+ e = new AddExpression(scan(), e, parseTerm());
	731	+ break;
	732	+ case SUB:
	733	+ e = new SubtractExpression(scan(), e, parseTerm());
	734	+ break;
	735	+ case MUL:
	736	+ e = new MultiplyExpression(scan(), e, parseTerm());
	737	+ break;
	738	+ case DIV:
	739	+ e = new DivideExpression(scan(), e, parseTerm());
	740	+ break;
	741	+ case REM:
	742	+ e = new RemainderExpression(scan(), e, parseTerm());
	743	+ break;
	744	+ case LSHIFT:
	745	+ e = new ShiftLeftExpression(scan(), e, parseTerm());
	746	+ break;
	747	+ case RSHIFT:
	748	+ e = new ShiftRightExpression(scan(), e, parseTerm());
	749	+ break;
	750	+ case URSHIFT:
	751	+ e = new UnsignedShiftRightExpression(scan(), e, parseTerm());
	752	+ break;
	753	+ case LT:
	754	+ e = new LessExpression(scan(), e, parseTerm());
	755	+ break;
	756	+ case LE:
	757	+ e = new LessOrEqualExpression(scan(), e, parseTerm());
	758	+ break;
	759	+ case GT:
	760	+ e = new GreaterExpression(scan(), e, parseTerm());
	761	+ break;
	762	+ case GE:
	763	+ e = new GreaterOrEqualExpression(scan(), e, parseTerm());
	764	+ break;
	765	+ case EQ:
	766	+ e = new EqualExpression(scan(), e, parseTerm());
	767	+ break;
	768	+ case NE:
	769	+ e = new NotEqualExpression(scan(), e, parseTerm());
	770	+ break;
	771	+ case BITAND:
	772	+ e = new BitAndExpression(scan(), e, parseTerm());
	773	+ break;
	774	+ case BITXOR:
	775	+ e = new BitXorExpression(scan(), e, parseTerm());
	776	+ break;
	777	+ case BITOR:
	778	+ e = new BitOrExpression(scan(), e, parseTerm());
	779	+ break;
	780	+ case AND:
	781	+ e = new AndExpression(scan(), e, parseTerm());
	782	+ break;
	783	+ case OR:
	784	+ e = new OrExpression(scan(), e, parseTerm());
	785	+ break;
	786	+ case ASSIGN:
	787	+ e = new AssignExpression(scan(), e, parseTerm());
	788	+ break;
	789	+ case ASGMUL:
	790	+ e = new AssignMultiplyExpression(scan(), e, parseTerm());
	791	+ break;
	792	+ case ASGDIV:
	793	+ e = new AssignDivideExpression(scan(), e, parseTerm());
	794	+ break;
	795	+ case ASGREM:
	796	+ e = new AssignRemainderExpression(scan(), e, parseTerm());
	797	+ break;
	798	+ case ASGADD:
	799	+ e = new AssignAddExpression(scan(), e, parseTerm());
	800	+ break;
	801	+ case ASGSUB:
	802	+ e = new AssignSubtractExpression(scan(), e, parseTerm());
	803	+ break;
	804	+ case ASGLSHIFT:
	805	+ e = new AssignShiftLeftExpression(scan(), e, parseTerm());
	806	+ break;
	807	+ case ASGRSHIFT:
	808	+ e = new AssignShiftRightExpression(scan(), e, parseTerm());
	809	+ break;
	810	+ case ASGURSHIFT:
	811	+ e = new AssignUnsignedShiftRightExpression(scan(), e, parseTerm());
	812	+ break;
	813	+ case ASGBITAND:
	814	+ e = new AssignBitAndExpression(scan(), e, parseTerm());
	815	+ break;
	816	+ case ASGBITOR:
	817	+ e = new AssignBitOrExpression(scan(), e, parseTerm());
	818	+ break;
	819	+ case ASGBITXOR:
	820	+ e = new AssignBitXorExpression(scan(), e, parseTerm());
	821	+ break;
	822	+ case QUESTIONMARK: {
	823	+ long p = scan();
	824	+ Expression second = parseExpression();
	825	+ expect(COLON);
	826	+ Expression third = parseExpression();
	827	+
	828	+ // The grammar in the JLS does not allow assignment
	829	+ // expressions as the third part of a ?: expression.
	830	+ // Even though javac has no trouble parsing this,
	831	+ // check for this case and signal an error.
	832	+ // (fix for bug 4092958)
	833	+ if (third instanceof AssignExpression
	834	+ \|\| third instanceof AssignOpExpression) {
	835	+ env.error(third.getWhere(), "assign.in.conditionalexpr");
	836	+ }
	837	+
	838	+ e = new ConditionalExpression(p, e, second, third);
	839	+ break;
	840	+ }
	841	+
	842	+ default:
	843	+ return null; // mark end of binary expressions
	844	+ }
	845	+ }
	846	+ return e; // return more binary expression stuff
	847	+ }
	848	+
	849	+ /**
	850	+ * Recover after a syntax error in a statement. This involves
	851	+ * discarding tokens until EOF or a possible continuation is
	852	+ * encountered.
	853	+ */
	854	+ protected boolean recoverStatement() throws SyntaxError, IOException {
	855	+ while (true) {
	856	+ switch (token) {
	857	+ case EOF:
	858	+ case RBRACE:
	859	+ case LBRACE:
	860	+ case IF:
	861	+ case FOR:
	862	+ case WHILE:
	863	+ case DO:
	864	+ case TRY:
	865	+ case CATCH:
	866	+ case FINALLY:
	867	+ case BREAK:
	868	+ case CONTINUE:
	869	+ case RETURN:
	870	+ // begin of a statement, return
	871	+ return true;
	872	+
	873	+ case VOID:
	874	+ case STATIC:
	875	+ case PUBLIC:
	876	+ case PRIVATE:
	877	+ case SYNCHRONIZED:
	878	+ case INTERFACE:
	879	+ case CLASS:
	880	+ case TRANSIENT:
	881	+ // begin of something outside a statement, panic some more
	882	+ expect(RBRACE);
	883	+ return false;
	884	+
	885	+ case LPAREN:
	886	+ match(LPAREN, RPAREN);
	887	+ scan();
	888	+ break;
	889	+
	890	+ case LSQBRACKET:
	891	+ match(LSQBRACKET, RSQBRACKET);
	892	+ scan();
	893	+ break;
	894	+
	895	+ default:
	896	+ // don't know what to do, skip
	897	+ scan();
	898	+ break;
	899	+ }
	900	+ }
	901	+ }
	902	+
	903	+ /**
	904	+ * Parse declaration, called after the type expression
	905	+ * has been parsed and the current token is IDENT.
	906	+ */
	907	+ protected Statement parseDeclaration(long p, int mod, Expression type) throws SyntaxError, IOException {
	908	+ int i = argIndex;
	909	+ if (token == IDENT) {
	910	+ addArgument(new VarDeclarationStatement(pos, parseExpression()));
	911	+ while (token == COMMA) {
	912	+ scan();
	913	+ addArgument(new VarDeclarationStatement(pos, parseExpression()));
	914	+ }
	915	+ }
	916	+ return new DeclarationStatement(p, mod, type, statArgs(i));
	917	+ }
	918	+
	919	+ /**
	920	+ * Check if an expression is a legal toplevel expression.
	921	+ * Only method, inc, dec, and new expression are allowed.
	922	+ */
	923	+ protected void topLevelExpression(Expression e) {
	924	+ switch (e.getOp()) {
	925	+ case ASSIGN:
	926	+ case ASGMUL:
	927	+ case ASGDIV:
	928	+ case ASGREM:
	929	+ case ASGADD:
	930	+ case ASGSUB:
	931	+ case ASGLSHIFT:
	932	+ case ASGRSHIFT:
	933	+ case ASGURSHIFT:
	934	+ case ASGBITAND:
	935	+ case ASGBITOR:
	936	+ case ASGBITXOR:
	937	+ case PREINC:
	938	+ case PREDEC:
	939	+ case POSTINC:
	940	+ case POSTDEC:
	941	+ case METHOD:
	942	+ case NEWINSTANCE:
	943	+ return;
	944	+ }
	945	+ env.error(e.getWhere(), "invalid.expr");
	946	+ }
	947	+
	948	+ /**
	949	+ * Parse a statement.
	950	+ */
	951	+ protected Statement parseStatement() throws SyntaxError, IOException {
	952	+ switch (token) {
	953	+ case SEMICOLON:
	954	+ return new CompoundStatement(scan(), new Statement[0]);
	955	+
	956	+ case LBRACE:
	957	+ return parseBlockStatement();
	958	+
	959	+ case IF: {
	960	+ // if-statement: if (expr) stat
	961	+ // if-statement: if (expr) stat else stat
	962	+ long p = scan();
	963	+
	964	+ expect(LPAREN);
	965	+ Expression c = parseExpression();
	966	+ expect(RPAREN);
	967	+ Statement t = parseStatement();
	968	+ if (token == ELSE) {
	969	+ scan();
	970	+ return new IfStatement(p, c, t, parseStatement());
	971	+ } else {
	972	+ return new IfStatement(p, c, t, null);
	973	+ }
	974	+ }
	975	+
	976	+ case ELSE: {
	977	+ // else-statement: else stat
	978	+ env.error(scan(), "else.without.if");
	979	+ return parseStatement();
	980	+ }
	981	+
	982	+ case FOR: {
	983	+ // for-statement: for (decl-expr? ; expr? ; expr?) stat
	984	+ long p = scan();
	985	+ Statement init = null;
	986	+ Expression cond = null, inc = null;
	987	+
	988	+ expect(LPAREN);
	989	+ if (token != SEMICOLON) {
	990	+ long p2 = pos;
	991	+ int mod = parseModifiers(M_FINAL);
	992	+ Expression e = parseExpression();
	993	+
	994	+ if (token == IDENT) {
	995	+ init = parseDeclaration(p2, mod, e);
	996	+ } else {
	997	+ if (mod != 0) {
	998	+ expect(IDENT); // should have been a declaration
	999	+ }
	1000	+ topLevelExpression(e);
	1001	+ while (token == COMMA) {
	1002	+ long p3 = scan();
	1003	+ Expression e2 = parseExpression();
	1004	+ topLevelExpression(e2);
	1005	+ e = new CommaExpression(p3, e, e2);
	1006	+ }
	1007	+ init = new ExpressionStatement(p2, e);
	1008	+ }
	1009	+ }
	1010	+ expect(SEMICOLON);
	1011	+ if (token != SEMICOLON) {
	1012	+ cond = parseExpression();
	1013	+ }
	1014	+ expect(SEMICOLON);
	1015	+ if (token != RPAREN) {
	1016	+ inc = parseExpression();
	1017	+ topLevelExpression(inc);
	1018	+ while (token == COMMA) {
	1019	+ long p2 = scan();
	1020	+ Expression e2 = parseExpression();
	1021	+ topLevelExpression(e2);
	1022	+ inc = new CommaExpression(p2, inc, e2);
	1023	+ }
	1024	+ }
	1025	+ expect(RPAREN);
	1026	+ return new ForStatement(p, init, cond, inc, parseStatement());
	1027	+ }
	1028	+
	1029	+ case WHILE: {
	1030	+ // while-statement: while (expr) stat
	1031	+ long p = scan();
	1032	+
	1033	+ expect(LPAREN);
	1034	+ Expression cond = parseExpression();
	1035	+ expect(RPAREN);
	1036	+ return new WhileStatement(p, cond, parseStatement());
	1037	+ }
	1038	+
	1039	+ case DO: {
	1040	+ // do-statement: do stat while (expr)
	1041	+ long p = scan();
	1042	+
	1043	+ Statement body = parseStatement();
	1044	+ expect(WHILE);
	1045	+ expect(LPAREN);
	1046	+ Expression cond = parseExpression();
	1047	+ expect(RPAREN);
	1048	+ expect(SEMICOLON);
	1049	+ return new DoStatement(p, body, cond);
	1050	+ }
	1051	+
	1052	+ case BREAK: {
	1053	+ // break-statement: break ;
	1054	+ long p = scan();
	1055	+ Identifier label = null;
	1056	+
	1057	+ if (token == IDENT) {
	1058	+ label = scanner.idValue;
	1059	+ scan();
	1060	+ }
	1061	+ expect(SEMICOLON);
	1062	+ return new BreakStatement(p, label);
	1063	+ }
	1064	+
	1065	+ case CONTINUE: {
	1066	+ // continue-statement: continue ;
	1067	+ long p = scan();
	1068	+ Identifier label = null;
	1069	+
	1070	+ if (token == IDENT) {
	1071	+ label = scanner.idValue;
	1072	+ scan();
	1073	+ }
	1074	+ expect(SEMICOLON);
	1075	+ return new ContinueStatement(p, label);
	1076	+ }
	1077	+
	1078	+ case RETURN: {
	1079	+ // return-statement: return ;
	1080	+ // return-statement: return expr ;
	1081	+ long p = scan();
	1082	+ Expression e = null;
	1083	+
	1084	+ if (token != SEMICOLON) {
	1085	+ e = parseExpression();
	1086	+ }
	1087	+ expect(SEMICOLON);
	1088	+ return new ReturnStatement(p, e);
	1089	+ }
	1090	+
	1091	+ case SWITCH: {
	1092	+ // switch statement: switch ( expr ) stat
	1093	+ long p = scan();
	1094	+ int i = argIndex;
	1095	+
	1096	+ expect(LPAREN);
	1097	+ Expression e = parseExpression();
	1098	+ expect(RPAREN);
	1099	+ expect(LBRACE);
	1100	+
	1101	+ while ((token != EOF) && (token != RBRACE)) {
	1102	+ int j = argIndex;
	1103	+ try {
	1104	+ switch (token) {
	1105	+ case CASE:
	1106	+ // case-statement: case expr:
	1107	+ addArgument(new CaseStatement(scan(), parseExpression()));
	1108	+ expect(COLON);
	1109	+ break;
	1110	+
	1111	+ case DEFAULT:
	1112	+ // default-statement: default:
	1113	+ addArgument(new CaseStatement(scan(), null));
	1114	+ expect(COLON);
	1115	+ break;
	1116	+
	1117	+ default:
	1118	+ addArgument(parseStatement());
	1119	+ break;
	1120	+ }
	1121	+ } catch (SyntaxError ee) {
	1122	+ argIndex = j;
	1123	+ if (!recoverStatement()) {
	1124	+ throw ee;
	1125	+ }
	1126	+ }
	1127	+ }
	1128	+ expect(RBRACE);
	1129	+ return new SwitchStatement(p, e, statArgs(i));
	1130	+ }
	1131	+
	1132	+ case CASE: {
	1133	+ // case-statement: case expr : stat
	1134	+ env.error(pos, "case.without.switch");
	1135	+ while (token == CASE) {
	1136	+ scan();
	1137	+ parseExpression();
	1138	+ expect(COLON);
	1139	+ }
	1140	+ return parseStatement();
	1141	+ }
	1142	+
	1143	+ case DEFAULT: {
	1144	+ // default-statement: default : stat
	1145	+ env.error(pos, "default.without.switch");
	1146	+ scan();
	1147	+ expect(COLON);
	1148	+ return parseStatement();
	1149	+ }
	1150	+
	1151	+ case TRY: {
	1152	+ // try-statement: try stat catch (type-expr ident) stat finally stat
	1153	+ long p = scan();
	1154	+ Statement init = null; // try-object specification
	1155	+ int i = argIndex;
	1156	+ boolean catches = false;
	1157	+
	1158	+ if (false && token == LPAREN) {
	1159	+ expect(LPAREN);
	1160	+ long p2 = pos;
	1161	+ int mod = parseModifiers(M_FINAL);
	1162	+ Expression e = parseExpression();
	1163	+
	1164	+ if (token == IDENT) {
	1165	+ init = parseDeclaration(p2, mod, e);
	1166	+ // leave check for try (T x, y) for semantic phase
	1167	+ } else {
	1168	+ if (mod != 0) {
	1169	+ expect(IDENT); // should have been a declaration
	1170	+ }
	1171	+ init = new ExpressionStatement(p2, e);
	1172	+ }
	1173	+ expect(RPAREN);
	1174	+ }
	1175	+
	1176	+ Statement s = parseBlockStatement();
	1177	+
	1178	+ if (init != null) {
	1179	+ // s = new FinallyStatement(p, init, s, 0);
	1180	+ }
	1181	+
	1182	+ while (token == CATCH) {
	1183	+ long pp = pos;
	1184	+ expect(CATCH);
	1185	+ expect(LPAREN);
	1186	+ int mod = parseModifiers(M_FINAL);
	1187	+ Expression t = parseExpression();
	1188	+ IdentifierToken id = scanner.getIdToken();
	1189	+ expect(IDENT);
	1190	+ id.modifiers = mod;
	1191	+ // We only catch Throwable's, so this is no longer required
	1192	+ // while (token == LSQBRACKET) {
	1193	+ // t = new ArrayAccessExpression(scan(), t, null);
	1194	+ // expect(RSQBRACKET);
	1195	+ // }
	1196	+ expect(RPAREN);
	1197	+ addArgument(new CatchStatement(pp, t, id, parseBlockStatement()));
	1198	+ catches = true;
	1199	+ }
	1200	+
	1201	+ if (catches)
	1202	+ s = new TryStatement(p, s, statArgs(i));
	1203	+
	1204	+ if (token == FINALLY) {
	1205	+ scan();
	1206	+ return new FinallyStatement(p, s, parseBlockStatement());
	1207	+ } else if (catches \|\| init != null) {
	1208	+ return s;
	1209	+ } else {
	1210	+ env.error(pos, "try.without.catch.finally");
	1211	+ return new TryStatement(p, s, null);
	1212	+ }
	1213	+ }
	1214	+
	1215	+ case CATCH: {
	1216	+ // catch-statement: catch (expr ident) stat finally stat
	1217	+ env.error(pos, "catch.without.try");
	1218	+
	1219	+ Statement s;
	1220	+ do {
	1221	+ scan();
	1222	+ expect(LPAREN);
	1223	+ parseModifiers(M_FINAL);
	1224	+ parseExpression();
	1225	+ expect(IDENT);
	1226	+ expect(RPAREN);
	1227	+ s = parseBlockStatement();
	1228	+ } while (token == CATCH);
	1229	+
	1230	+ if (token == FINALLY) {
	1231	+ scan();
	1232	+ s = parseBlockStatement();
	1233	+ }
	1234	+ return s;
	1235	+ }
	1236	+
	1237	+ case FINALLY: {
	1238	+ // finally-statement: finally stat
	1239	+ env.error(pos, "finally.without.try");
	1240	+ scan();
	1241	+ return parseBlockStatement();
	1242	+ }
	1243	+
	1244	+ case THROW: {
	1245	+ // throw-statement: throw expr;
	1246	+ long p = scan();
	1247	+ Expression e = parseExpression();
	1248	+ expect(SEMICOLON);
	1249	+ return new ThrowStatement(p, e);
	1250	+ }
	1251	+
	1252	+ case GOTO: {
	1253	+ long p = scan();
	1254	+ expect(IDENT);
	1255	+ expect(SEMICOLON);
	1256	+ env.error(p, "not.supported", "goto");
	1257	+ return new CompoundStatement(p, new Statement[0]);
	1258	+ }
	1259	+
	1260	+ case SYNCHRONIZED: {
	1261	+ // synchronized-statement: synchronized (expr) stat
	1262	+ long p = scan();
	1263	+ expect(LPAREN);
	1264	+ Expression e = parseExpression();
	1265	+ expect(RPAREN);
	1266	+ return new SynchronizedStatement(p, e, parseBlockStatement());
	1267	+ }
	1268	+
	1269	+ case INTERFACE:
	1270	+ case CLASS:
	1271	+ // Inner class.
	1272	+ return parseLocalClass(0);
	1273	+
	1274	+ case CONST:
	1275	+ case ABSTRACT:
	1276	+ case FINAL:
	1277	+ case STRICTFP: {
	1278	+ // a declaration of some sort
	1279	+ long p = pos;
	1280	+
	1281	+ // A class which is local to a block is not a member, and so
	1282	+ // cannot be public, private, protected, or static. It is in
	1283	+ // effect private to the block, since it cannot be used outside
	1284	+ // its scope.
	1285	+ //
	1286	+ // However, any class (if it has a name) can be declared final,
	1287	+ // abstract, or strictfp.
	1288	+ int mod = parseModifiers(M_FINAL \| M_ABSTRACT
	1289	+ \| M_STRICTFP );
	1290	+
	1291	+ switch (token) {
	1292	+ case INTERFACE:
	1293	+ case CLASS:
	1294	+ return parseLocalClass(mod);
	1295	+
	1296	+ case BOOLEAN:
	1297	+ case BYTE:
	1298	+ case CHAR:
	1299	+ case SHORT:
	1300	+ case INT:
	1301	+ case LONG:
	1302	+ case FLOAT:
	1303	+ case DOUBLE:
	1304	+ case IDENT: {
	1305	+ if ((mod & (M_ABSTRACT \| M_STRICTFP )) != 0) {
	1306	+ mod &= ~ (M_ABSTRACT \| M_STRICTFP );
	1307	+ expect(CLASS);
	1308	+ }
	1309	+ Expression e = parseExpression();
	1310	+ if (token != IDENT) {
	1311	+ expect(IDENT);
	1312	+ }
	1313	+ // declaration: final expr expr
	1314	+ Statement s = parseDeclaration(p, mod, e);
	1315	+ expect(SEMICOLON);
	1316	+ return s;
	1317	+ }
	1318	+
	1319	+ default:
	1320	+ env.error(pos, "type.expected");
	1321	+ throw new SyntaxError();
	1322	+ }
	1323	+ }
	1324	+
	1325	+ case VOID:
	1326	+ case STATIC:
	1327	+ case PUBLIC:
	1328	+ case PRIVATE:
	1329	+ case TRANSIENT:
	1330	+ // This is the start of something outside a statement
	1331	+ env.error(pos, "statement.expected");
	1332	+ throw new SyntaxError();
	1333	+ }
	1334	+
	1335	+ long p = pos;
	1336	+ Expression e = parseExpression();
	1337	+
	1338	+ if (token == IDENT) {
	1339	+ // declaration: expr expr
	1340	+ Statement s = parseDeclaration(p, 0, e);
	1341	+ expect(SEMICOLON);
	1342	+ return s;
	1343	+ }
	1344	+ if (token == COLON) {
	1345	+ // label: id: stat
	1346	+ scan();
	1347	+ Statement s = parseStatement();
	1348	+ s.setLabel(env, e);
	1349	+ return s;
	1350	+ }
	1351	+
	1352	+ // it was just an expression...
	1353	+ topLevelExpression(e);
	1354	+ expect(SEMICOLON);
	1355	+ return new ExpressionStatement(p, e);
	1356	+ }
	1357	+
	1358	+ protected Statement parseBlockStatement() throws SyntaxError, IOException {
	1359	+ // compound statement: { stat1 stat2 ... statn }
	1360	+ if (token != LBRACE) {
	1361	+ // We're expecting a block statement. But we'll probably do the
	1362	+ // least damage if we try to parse a normal statement instead.
	1363	+ env.error(scanner.prevPos, "token.expected", opNames[LBRACE]);
	1364	+ return parseStatement();
	1365	+ }
	1366	+ long p = scan();
	1367	+ int i = argIndex;
	1368	+ while ((token != EOF) && (token != RBRACE)) {
	1369	+ int j = argIndex;
	1370	+ try {
	1371	+ addArgument(parseStatement());
	1372	+ } catch (SyntaxError e) {
	1373	+ argIndex = j;
	1374	+ if (!recoverStatement()) {
	1375	+ throw e;
	1376	+ }
	1377	+ }
	1378	+ }
	1379	+
	1380	+ expect(RBRACE);
	1381	+ return new CompoundStatement(p, statArgs(i));
	1382	+ }
	1383	+
	1384	+
	1385	+ /**
	1386	+ * Parse an identifier. ie: a.b.c returns "a.b.c"
	1387	+ * If star is true then "a.b.*" is allowed.
	1388	+ * The return value encodes both the identifier and its location.
	1389	+ */
	1390	+ protected IdentifierToken parseName(boolean star) throws SyntaxError, IOException {
	1391	+ IdentifierToken res = scanner.getIdToken();
	1392	+ expect(IDENT);
	1393	+
	1394	+ if (token != FIELD) {
	1395	+ return res;
	1396	+ }
	1397	+
	1398	+ StringBuffer buf = new StringBuffer(res.id.toString());
	1399	+
	1400	+ while (token == FIELD) {
	1401	+ scan();
	1402	+ if ((token == MUL) && star) {
	1403	+ scan();
	1404	+ buf.append(".*");
	1405	+ break;
	1406	+ }
	1407	+
	1408	+ buf.append('.');
	1409	+ if (token == IDENT) {
	1410	+ buf.append(scanner.idValue);
	1411	+ }
	1412	+ expect(IDENT);
	1413	+ }
	1414	+
	1415	+ res.id = Identifier.lookup(buf.toString());
	1416	+ return res;
	1417	+ }
	1418	+ /**
	1419	+ * @deprecated
	1420	+ * @see #parseName
	1421	+ */
	1422	+ @Deprecated
	1423	+ protected Identifier parseIdentifier(boolean star) throws SyntaxError, IOException {
	1424	+ return parseName(star).id;
	1425	+ }
	1426	+
	1427	+ /**
	1428	+ * Parse a type expression, this results in a Type.
	1429	+ * The parse includes trailing array brackets.
	1430	+ */
	1431	+ protected Type parseType() throws SyntaxError, IOException {
	1432	+ Type t;
	1433	+
	1434	+ switch (token) {
	1435	+ case IDENT:
	1436	+ t = Type.tClass(parseName(false).id);
	1437	+ break;
	1438	+ case VOID:
	1439	+ scan();
	1440	+ t = Type.tVoid;
	1441	+ break;
	1442	+ case BOOLEAN:
	1443	+ scan();
	1444	+ t = Type.tBoolean;
	1445	+ break;
	1446	+ case BYTE:
	1447	+ scan();
	1448	+ t = Type.tByte;
	1449	+ break;
	1450	+ case CHAR:
	1451	+ scan();
	1452	+ t = Type.tChar;
	1453	+ break;
	1454	+ case SHORT:
	1455	+ scan();
	1456	+ t = Type.tShort;
	1457	+ break;
	1458	+ case INT:
	1459	+ scan();
	1460	+ t = Type.tInt;
	1461	+ break;
	1462	+ case FLOAT:
	1463	+ scan();
	1464	+ t = Type.tFloat;
	1465	+ break;
	1466	+ case LONG:
	1467	+ scan();
	1468	+ t = Type.tLong;
	1469	+ break;
	1470	+ case DOUBLE:
	1471	+ scan();
	1472	+ t = Type.tDouble;
	1473	+ break;
	1474	+ default:
	1475	+ env.error(pos, "type.expected");
	1476	+ throw new SyntaxError();
	1477	+ }
	1478	+ return parseArrayBrackets(t);
	1479	+ }
	1480	+
	1481	+ /**
	1482	+ * Parse the tail of a type expression, which might be array brackets.
	1483	+ * Return the given type, as possibly modified by the suffix.
	1484	+ */
	1485	+ protected Type parseArrayBrackets(Type t) throws SyntaxError, IOException {
	1486	+
	1487	+ // Parse []'s
	1488	+ while (token == LSQBRACKET) {
	1489	+ scan();
	1490	+ if (token != RSQBRACKET) {
	1491	+ env.error(pos, "array.dim.in.decl");
	1492	+ parseExpression();
	1493	+ }
	1494	+ expect(RSQBRACKET);
	1495	+ t = Type.tArray(t);
	1496	+ }
	1497	+ return t;
	1498	+ }
	1499	+
	1500	+ /*
	1501	+ * Dealing with argument lists, I'm not using
	1502	+ * Vector for efficiency.
	1503	+ */
	1504	+
	1505	+ private int aCount = 0;
	1506	+ private Type aTypes[] = new Type[8];
	1507	+ private IdentifierToken aNames[] = new IdentifierToken[aTypes.length];
	1508	+
	1509	+ private void addArgument(int mod, Type t, IdentifierToken nm) {
	1510	+ nm.modifiers = mod;
	1511	+ if (aCount >= aTypes.length) {
	1512	+ Type newATypes[] = new Type[aCount * 2];
	1513	+ System.arraycopy(aTypes, 0, newATypes, 0, aCount);
	1514	+ aTypes = newATypes;
	1515	+ IdentifierToken newANames[] = new IdentifierToken[aCount * 2];
	1516	+ System.arraycopy(aNames, 0, newANames, 0, aCount);
	1517	+ aNames = newANames;
	1518	+ }
	1519	+ aTypes[aCount] = t;
	1520	+ aNames[aCount++] = nm;
	1521	+ }
	1522	+
	1523	+ /**
	1524	+ * Parse a possibly-empty sequence of modifier keywords.
	1525	+ * Return the resulting bitmask.
	1526	+ * Diagnose repeated modifiers, but make no other checks.
	1527	+ * Only modifiers mentioned in the given bitmask are scanned;
	1528	+ * an unmatched modifier must be handled by the caller.
	1529	+ */
	1530	+ protected int parseModifiers(int mask) throws IOException {
	1531	+ int mod = 0;
	1532	+ while (true) {
	1533	+ if (token==CONST) {
	1534	+ // const isn't in java, but handle a common C++ usage gently
	1535	+ env.error(pos, "not.supported", "const");
	1536	+ scan();
	1537	+ }
	1538	+ int nextmod = 0;
	1539	+ switch (token) {
	1540	+ case PRIVATE: nextmod = M_PRIVATE; break;
	1541	+ case PUBLIC: nextmod = M_PUBLIC; break;
	1542	+ case PROTECTED: nextmod = M_PROTECTED; break;
	1543	+ case STATIC: nextmod = M_STATIC; break;
	1544	+ case TRANSIENT: nextmod = M_TRANSIENT; break;
	1545	+ case FINAL: nextmod = M_FINAL; break;
	1546	+ case ABSTRACT: nextmod = M_ABSTRACT; break;
	1547	+ case NATIVE: nextmod = M_NATIVE; break;
	1548	+ case VOLATILE: nextmod = M_VOLATILE; break;
	1549	+ case SYNCHRONIZED: nextmod = M_SYNCHRONIZED; break;
	1550	+ case STRICTFP: nextmod = M_STRICTFP; break;
	1551	+ }
	1552	+ if ((nextmod & mask) == 0) {
	1553	+ break;
	1554	+ }
	1555	+ if ((nextmod & mod) != 0) {
	1556	+ env.error(pos, "repeated.modifier");
	1557	+ }
	1558	+ mod \|= nextmod;
	1559	+ scan();
	1560	+ }
	1561	+ return mod;
	1562	+ }
	1563	+
	1564	+ private ClassDefinition curClass;
	1565	+
	1566	+ /**
	1567	+ * Parse a field.
	1568	+ */
	1569	+ protected void parseField() throws SyntaxError, IOException {
	1570	+
	1571	+ // Empty fields are not allowed by the JLS but are accepted by
	1572	+ // the compiler, and much code has come to rely on this. It has
	1573	+ // been decided that the language will be extended to legitimize them.
	1574	+ if (token == SEMICOLON) {
	1575	+ // empty field
	1576	+ scan();
	1577	+ return;
	1578	+ }
	1579	+
	1580	+ // Optional doc comment
	1581	+ String doc = scanner.docComment;
	1582	+
	1583	+ // The start of the field
	1584	+ long p = pos;
	1585	+
	1586	+ // Parse the modifiers
	1587	+ int mod = parseModifiers(MM_FIELD \| MM_METHOD);
	1588	+
	1589	+ // Check for static initializer
	1590	+ // ie: static { ... }
	1591	+ // or an instance initializer (w/o the static).
	1592	+ if ((mod == (mod & M_STATIC)) && (token == LBRACE)) {
	1593	+ // static initializer
	1594	+ actions.defineField(p, curClass, doc, mod,
	1595	+ Type.tMethod(Type.tVoid),
	1596	+ new IdentifierToken(idClassInit), null, null,
	1597	+ parseStatement());
	1598	+ return;
	1599	+ }
	1600	+
	1601	+ // Check for inner class
	1602	+ if (token == CLASS \|\| token == INTERFACE) {
	1603	+ parseNamedClass(mod, CLASS, doc);
	1604	+ return;
	1605	+ }
	1606	+
	1607	+ // Parse the type
	1608	+ p = pos;
	1609	+ Type t = parseType();
	1610	+ IdentifierToken id = null;
	1611	+
	1612	+ // Check that the type is followed by an Identifier
	1613	+ // (the name of the method or the first variable),
	1614	+ // otherwise it is a constructor.
	1615	+ switch (token) {
	1616	+ case IDENT:
	1617	+ id = scanner.getIdToken();
	1618	+ p = scan();
	1619	+ break;
	1620	+
	1621	+ case LPAREN:
	1622	+ // It is a constructor
	1623	+ id = new IdentifierToken(idInit);
	1624	+ if ((mod & M_STRICTFP) != 0)
	1625	+ env.error(pos, "bad.constructor.modifier");
	1626	+ break;
	1627	+
	1628	+ default:
	1629	+ expect(IDENT);
	1630	+ }
	1631	+
	1632	+ // If the next token is a left-bracket then we
	1633	+ // are dealing with a method or constructor, otherwise it is
	1634	+ // a list of variables
	1635	+ if (token == LPAREN) {
	1636	+ // It is a method or constructor declaration
	1637	+ scan();
	1638	+ aCount = 0;
	1639	+
	1640	+ if (token != RPAREN) {
	1641	+ // Parse argument type and identifier
	1642	+ // (arguments (like locals) are allowed to be final)
	1643	+ int am = parseModifiers(M_FINAL);
	1644	+ Type at = parseType();
	1645	+ IdentifierToken an = scanner.getIdToken();
	1646	+ expect(IDENT);
	1647	+
	1648	+ // Parse optional array specifier, ie: a[][]
	1649	+ at = parseArrayBrackets(at);
	1650	+ addArgument(am, at, an);
	1651	+
	1652	+ // If the next token is a comma then there are
	1653	+ // more arguments
	1654	+ while (token == COMMA) {
	1655	+ // Parse argument type and identifier
	1656	+ scan();
	1657	+ am = parseModifiers(M_FINAL);
	1658	+ at = parseType();
	1659	+ an = scanner.getIdToken();
	1660	+ expect(IDENT);
	1661	+
	1662	+ // Parse optional array specifier, ie: a[][]
	1663	+ at = parseArrayBrackets(at);
	1664	+ addArgument(am, at, an);
	1665	+ }
	1666	+ }
	1667	+ expect(RPAREN);
	1668	+
	1669	+ // Parse optional array sepecifier, ie: foo()[][]
	1670	+ t = parseArrayBrackets(t);
	1671	+
	1672	+ // copy arguments
	1673	+ Type atypes[] = new Type[aCount];
	1674	+ System.arraycopy(aTypes, 0, atypes, 0, aCount);
	1675	+
	1676	+ IdentifierToken anames[] = new IdentifierToken[aCount];
	1677	+ System.arraycopy(aNames, 0, anames, 0, aCount);
	1678	+
	1679	+ // Construct the type signature
	1680	+ t = Type.tMethod(t, atypes);
	1681	+
	1682	+ // Parse and ignore throws clause
	1683	+ IdentifierToken exp[] = null;
	1684	+ if (token == THROWS) {
	1685	+ Vector v = new Vector();
	1686	+ scan();
	1687	+ v.addElement(parseName(false));
	1688	+ while (token == COMMA) {
	1689	+ scan();
	1690	+ v.addElement(parseName(false));
	1691	+ }
	1692	+
	1693	+ exp = new IdentifierToken[v.size()];
	1694	+ v.copyInto(exp);
	1695	+ }
	1696	+
	1697	+ // Check if it is a method definition or a method declaration
	1698	+ // ie: foo() {...} or foo();
	1699	+ switch (token) {
	1700	+ case LBRACE: // It's a method definition
	1701	+
	1702	+ // Set the state of FP strictness for the body of the method
	1703	+ int oldFPstate = FPstate;
	1704	+ if ((mod & M_STRICTFP)!=0) {
	1705	+ FPstate = M_STRICTFP;
	1706	+ } else {
	1707	+ mod \|= FPstate & M_STRICTFP;
	1708	+ }
	1709	+
	1710	+ actions.defineField(p, curClass, doc, mod, t, id,
	1711	+ anames, exp, parseStatement());
	1712	+
	1713	+ FPstate = oldFPstate;
	1714	+
	1715	+ break;
	1716	+
	1717	+ case SEMICOLON:
	1718	+ scan();
	1719	+ actions.defineField(p, curClass, doc, mod, t, id,
	1720	+ anames, exp, null);
	1721	+ break;
	1722	+
	1723	+ default:
	1724	+ // really expected a statement body here
	1725	+ if ((mod & (M_NATIVE \| M_ABSTRACT)) == 0) {
	1726	+ expect(LBRACE);
	1727	+ } else {
	1728	+ expect(SEMICOLON);
	1729	+ }
	1730	+ }
	1731	+ return;
	1732	+ }
	1733	+
	1734	+ // It is a list of instance variables
	1735	+ while (true) {
	1736	+ p = pos; // get the current position
	1737	+ // parse the array brackets (if any)
	1738	+ // ie: var[][][]
	1739	+ Type vt = parseArrayBrackets(t);
	1740	+
	1741	+ // Parse the optional initializer
	1742	+ Node init = null;
	1743	+ if (token == ASSIGN) {
	1744	+ scan();
	1745	+ init = parseExpression();
	1746	+ }
	1747	+
	1748	+ // Define the variable
	1749	+ actions.defineField(p, curClass, doc, mod, vt, id,
	1750	+ null, null, init);
	1751	+
	1752	+ // If the next token is a comma, then there is more
	1753	+ if (token != COMMA) {
	1754	+ expect(SEMICOLON);
	1755	+ return;
	1756	+ }
	1757	+ scan();
	1758	+
	1759	+ // The next token must be an identifier
	1760	+ id = scanner.getIdToken();
	1761	+ expect(IDENT);
	1762	+ }
	1763	+ }
	1764	+
	1765	+ /**
	1766	+ * Recover after a syntax error in a field. This involves
	1767	+ * discarding tokens until an EOF or a possible legal
	1768	+ * continuation is encountered.
	1769	+ */
	1770	+ protected void recoverField(ClassDefinition newClass) throws SyntaxError, IOException {
	1771	+ while (true) {
	1772	+ switch (token) {
	1773	+ case EOF:
	1774	+ case STATIC:
	1775	+ case FINAL:
	1776	+ case PUBLIC:
	1777	+ case PRIVATE:
	1778	+ case SYNCHRONIZED:
	1779	+ case TRANSIENT:
	1780	+
	1781	+ case VOID:
	1782	+ case BOOLEAN:
	1783	+ case BYTE:
	1784	+ case CHAR:
	1785	+ case SHORT:
	1786	+ case INT:
	1787	+ case FLOAT:
	1788	+ case LONG:
	1789	+ case DOUBLE:
	1790	+ // possible begin of a field, continue
	1791	+ return;
	1792	+
	1793	+ case LBRACE:
	1794	+ match(LBRACE, RBRACE);
	1795	+ scan();
	1796	+ break;
	1797	+
	1798	+ case LPAREN:
	1799	+ match(LPAREN, RPAREN);
	1800	+ scan();
	1801	+ break;
	1802	+
	1803	+ case LSQBRACKET:
	1804	+ match(LSQBRACKET, RSQBRACKET);
	1805	+ scan();
	1806	+ break;
	1807	+
	1808	+ case RBRACE:
	1809	+ case INTERFACE:
	1810	+ case CLASS:
	1811	+ case IMPORT:
	1812	+ case PACKAGE:
	1813	+ // begin of something outside a class, panic more
	1814	+ actions.endClass(pos, newClass);
	1815	+ throw new SyntaxError();
	1816	+
	1817	+ default:
	1818	+ // don't know what to do, skip
	1819	+ scan();
	1820	+ break;
	1821	+ }
	1822	+ }
	1823	+ }
	1824	+
	1825	+ /**
	1826	+ * Parse a top-level class or interface declaration.
	1827	+ */
	1828	+ protected void parseClass() throws SyntaxError, IOException {
	1829	+ String doc = scanner.docComment;
	1830	+
	1831	+ // Parse the modifiers.
	1832	+ int mod = parseModifiers(MM_CLASS \| MM_MEMBER);
	1833	+
	1834	+ parseNamedClass(mod, PACKAGE, doc);
	1835	+ }
	1836	+
	1837	+ // Current strict/default state of floating point. This is
	1838	+ // set and reset with a stack discipline around methods and named
	1839	+ // classes. Only M_STRICTFP may be set in this word. try...
	1840	+ // finally is not needed to protect setting and resetting because
	1841	+ // there are no error messages based on FPstate.
	1842	+ private int FPstate = 0;
	1843	+
	1844	+ /**
	1845	+ * Parse a block-local class or interface declaration.
	1846	+ */
	1847	+ protected Statement parseLocalClass(int mod) throws SyntaxError, IOException {
	1848	+ long p = pos;
	1849	+ ClassDefinition body = parseNamedClass(M_LOCAL \| mod, STAT, null);
	1850	+ Statement ds[] = {
	1851	+ new VarDeclarationStatement(p, new LocalMember(body), null)
	1852	+ };
	1853	+ Expression type = new TypeExpression(p, body.getType());
	1854	+ return new DeclarationStatement(p, 0, type, ds);
	1855	+ }
	1856	+
	1857	+ /**
	1858	+ * Parse a named class or interface declaration,
	1859	+ * starting at "class" or "interface".
	1860	+ * @arg ctx Syntactic context of the class, one of {PACKAGE CLASS STAT EXPR}.
	1861	+ */
	1862	+ protected ClassDefinition parseNamedClass(int mod, int ctx, String doc) throws SyntaxError, IOException {
	1863	+ // Parse class/interface
	1864	+ switch (token) {
	1865	+ case INTERFACE:
	1866	+ scan();
	1867	+ mod \|= M_INTERFACE;
	1868	+ break;
	1869	+
	1870	+ case CLASS:
	1871	+ scan();
	1872	+ break;
	1873	+
	1874	+ default:
	1875	+ env.error(pos, "class.expected");
	1876	+ break;
	1877	+ }
	1878	+
	1879	+ int oldFPstate = FPstate;
	1880	+ if ((mod & M_STRICTFP)!=0) {
	1881	+ FPstate = M_STRICTFP;
	1882	+ } else {
	1883	+ // The & (...) isn't really necessary here because we do maintain
	1884	+ // the invariant that FPstate has no extra bits set.
	1885	+ mod \|= FPstate & M_STRICTFP;
	1886	+ }
	1887	+
	1888	+ // Parse the class name
	1889	+ IdentifierToken nm = scanner.getIdToken();
	1890	+ long p = pos;
	1891	+ expect(IDENT);
	1892	+
	1893	+ Vector ext = new Vector();
	1894	+ Vector impl = new Vector();
	1895	+ parseInheritance(ext, impl);
	1896	+
	1897	+ ClassDefinition tmp = parseClassBody(nm, mod, ctx, doc, ext, impl, p);
	1898	+
	1899	+ FPstate = oldFPstate;
	1900	+
	1901	+ return tmp;
	1902	+ }
	1903	+
	1904	+ protected void parseInheritance(Vector ext, Vector impl) throws SyntaxError, IOException {
	1905	+ // Parse extends clause
	1906	+ if (token == EXTENDS) {
	1907	+ scan();
	1908	+ ext.addElement(parseName(false));
	1909	+ while (token == COMMA) {
	1910	+ scan();
	1911	+ ext.addElement(parseName(false));
	1912	+ }
	1913	+ }
	1914	+
	1915	+ // Parse implements clause
	1916	+ if (token == IMPLEMENTS) {
	1917	+ scan();
	1918	+ impl.addElement(parseName(false));
	1919	+ while (token == COMMA) {
	1920	+ scan();
	1921	+ impl.addElement(parseName(false));
	1922	+ }
	1923	+ }
	1924	+ }
	1925	+
	1926	+ /**
	1927	+ * Parse the body of a class or interface declaration,
	1928	+ * starting at the left brace.
	1929	+ */
	1930	+ protected ClassDefinition parseClassBody(IdentifierToken nm, int mod,
	1931	+ int ctx, String doc,
	1932	+ Vector ext, Vector impl, long p
	1933	+ ) throws SyntaxError, IOException {
	1934	+ // Decide which is the super class
	1935	+ IdentifierToken sup = null;
	1936	+ if ((mod & M_INTERFACE) != 0) {
	1937	+ if (impl.size() > 0) {
	1938	+ env.error(((IdentifierToken)impl.elementAt(0)).getWhere(),
	1939	+ "intf.impl.intf");
	1940	+ }
	1941	+ impl = ext;
	1942	+ } else {
	1943	+ if (ext.size() > 0) {
	1944	+ if (ext.size() > 1) {
	1945	+ env.error(((IdentifierToken)ext.elementAt(1)).getWhere(),
	1946	+ "multiple.inherit");
	1947	+ }
	1948	+ sup = (IdentifierToken)ext.elementAt(0);
	1949	+ }
	1950	+ }
	1951	+
	1952	+ ClassDefinition oldClass = curClass;
	1953	+
	1954	+ // Begin a new class
	1955	+ IdentifierToken implids[] = new IdentifierToken[impl.size()];
	1956	+ impl.copyInto(implids);
	1957	+ ClassDefinition newClass =
	1958	+ actions.beginClass(p, doc, mod, nm, sup, implids);
	1959	+
	1960	+ // Parse fields
	1961	+ expect(LBRACE);
	1962	+ while ((token != EOF) && (token != RBRACE)) {
	1963	+ try {
	1964	+ curClass = newClass;
	1965	+ parseField();
	1966	+ } catch (SyntaxError e) {
	1967	+ recoverField(newClass);
	1968	+ } finally {
	1969	+ curClass = oldClass;
	1970	+ }
	1971	+ }
	1972	+ expect(RBRACE);
	1973	+
	1974	+ // End the class
	1975	+ actions.endClass(scanner.prevPos, newClass);
	1976	+ return newClass;
	1977	+ }
	1978	+
	1979	+ /**
	1980	+ * Recover after a syntax error in the file.
	1981	+ * This involves discarding tokens until an EOF
	1982	+ * or a possible legal continuation is encountered.
	1983	+ */
	1984	+ protected void recoverFile() throws IOException {
	1985	+ while (true) {
	1986	+ switch (token) {
	1987	+ case CLASS:
	1988	+ case INTERFACE:
	1989	+ // Start of a new source file statement, continue
	1990	+ return;
	1991	+
	1992	+ case LBRACE:
	1993	+ match(LBRACE, RBRACE);
	1994	+ scan();
	1995	+ break;
	1996	+
	1997	+ case LPAREN:
	1998	+ match(LPAREN, RPAREN);
	1999	+ scan();
	2000	+ break;
	2001	+
	2002	+ case LSQBRACKET:
	2003	+ match(LSQBRACKET, RSQBRACKET);
	2004	+ scan();
	2005	+ break;
	2006	+
	2007	+ case EOF:
	2008	+ return;
	2009	+
	2010	+ default:
	2011	+ // Don't know what to do, skip
	2012	+ scan();
	2013	+ break;
	2014	+ }
	2015	+ }
	2016	+ }
	2017	+
	2018	+ /**
	2019	+ * Parse an Java file.
	2020	+ */
	2021	+ public void parseFile() {
	2022	+ try {
	2023	+ try {
	2024	+ if (token == PACKAGE) {
	2025	+ // Package statement
	2026	+ long p = scan();
	2027	+ IdentifierToken id = parseName(false);
	2028	+ expect(SEMICOLON);
	2029	+ actions.packageDeclaration(p, id);
	2030	+ }
	2031	+ } catch (SyntaxError e) {
	2032	+ recoverFile();
	2033	+ }
	2034	+ while (token == IMPORT) {
	2035	+ try{
	2036	+ // Import statement
	2037	+ long p = scan();
	2038	+ IdentifierToken id = parseName(true);
	2039	+ expect(SEMICOLON);
	2040	+ if (id.id.getName().equals(idStar)) {
	2041	+ id.id = id.id.getQualifier();
	2042	+ actions.importPackage(p, id);
	2043	+ } else {
	2044	+ actions.importClass(p, id);
	2045	+ }
	2046	+ } catch (SyntaxError e) {
	2047	+ recoverFile();
	2048	+ }
	2049	+ }
	2050	+
	2051	+ while (token != EOF) {
	2052	+ try {
	2053	+ switch (token) {
	2054	+ case FINAL:
	2055	+ case PUBLIC:
	2056	+ case PRIVATE:
	2057	+ case ABSTRACT:
	2058	+ case CLASS:
	2059	+ case INTERFACE:
	2060	+ case STRICTFP:
	2061	+ // Start of a class
	2062	+ parseClass();
	2063	+ break;
	2064	+
	2065	+ case SEMICOLON:
	2066	+ // Bogus semicolon.
	2067	+ // According to the JLS (7.6,19.6), a TypeDeclaration
	2068	+ // may consist of a single semicolon, however, this
	2069	+ // usage is discouraged (JLS 7.6). In contrast,
	2070	+ // a FieldDeclaration may not be empty, and is flagged
	2071	+ // as an error. See parseField above.
	2072	+ scan();
	2073	+ break;
	2074	+
	2075	+ case EOF:
	2076	+ // The end
	2077	+ return;
	2078	+
	2079	+ default:
	2080	+ // Oops
	2081	+ env.error(pos, "toplevel.expected");
	2082	+ throw new SyntaxError();
	2083	+ }
	2084	+ } catch (SyntaxError e) {
	2085	+ recoverFile();
	2086	+ }
	2087	+ }
	2088	+ } catch (IOException e) {
	2089	+ env.error(pos, "io.exception", env.getSource());
	2090	+ return;
	2091	+ }
	2092	+ }
	2093	+
	2094	+ /**
	2095	+ * Usually <code>this.scanner == (Scanner)this</code>.
	2096	+ * However, a delegate scanner can produce tokens for this parser,
	2097	+ * in which case <code>(Scanner)this</code> is unused,
	2098	+ * except for <code>this.token</code> and <code>this.pos</code>
	2099	+ * instance variables which are filled from the real scanner
	2100	+ * by <code>this.scan()</code> and the constructor.
	2101	+ */
	2102	+ protected Scanner scanner;
	2103	+
	2104	+ // Design Note: We ought to disinherit Parser from Scanner.
	2105	+ // We also should split out the interface ParserActions from
	2106	+ // Parser, and make BatchParser implement ParserActions,
	2107	+ // not extend Parser. This would split scanning, parsing,
	2108	+ // and class building into distinct responsibility areas.
	2109	+ // (Perhaps tree building could be virtualized too.)
	2110	+
	2111	+ public long scan() throws IOException {
	2112	+ if (scanner != this && scanner != null) {
	2113	+ long result = scanner.scan();
	2114	+ ((Scanner)this).token = scanner.token;
	2115	+ ((Scanner)this).pos = scanner.pos;
	2116	+ return result;
	2117	+ }
	2118	+ return super.scan();
	2119	+ }
	2120	+
	2121	+ public void match(int open, int close) throws IOException {
	2122	+ if (scanner != this) {
	2123	+ scanner.match(open, close);
	2124	+ ((Scanner)this).token = scanner.token;
	2125	+ ((Scanner)this).pos = scanner.pos;
	2126	+ return;
	2127	+ }
	2128	+ super.match(open, close);
	2129	+ }
	2130	+}