DynamicJava Test Coverage (dynamicjava-20120303-r5436)

Clover coverage report - DynamicJava Test Coverage (dynamicjava-20120303-r5436)

Coverage timestamp: Sat Mar 3 2012 03:02:19 CST

FRAMES NO FRAMES

file stats:	LOC:	7,853		Methods:	521
	NCLOC:	6,967		Classes:	30

Source file

Conditionals

Statements

Methods

TOTAL

Parser.java

50.6%

52.7%

77.2%

53.9%

1		/* Generated By:JavaCC: Do not edit this line. Parser.java */
2		package koala.dynamicjava.parser.impl;
3
4		import java.util.*;
5		import java.io.File;
6
7		import edu.rice.cs.plt.tuple.Option;
8		import edu.rice.cs.plt.tuple.Pair;
9		import edu.rice.cs.plt.collect.ConsList;
10		import edu.rice.cs.plt.collect.CollectUtil;
11
12		import koala.dynamicjava.parser.wrapper.*;
13		import koala.dynamicjava.tree.*;
14		import koala.dynamicjava.tree.ModifierSet.Modifier;
15		import koala.dynamicjava.tree.visitor.*;
16		import koala.dynamicjava.util.*;
17		import koala.dynamicjava.tree.tiger.*;
18		import edu.rice.cs.dynamicjava.Options;
19
20		/**
21		* This class represents a (interpreted) Java 1.1 language parser
22		* adapted for 1.5 language extensions.
23		*/
24
25		public class Parser implements ParserConstants {
26		/** The name of the file currently interpreted; null by default */
27		private File file = null;
28
29		/** DynamicJava options */
30		private Options opt = Options.DEFAULT;
31
32		/**
33		* A flag to use in semantic lookaheads. Declared here as a workaround because
34		* lookahead can't access local variables or production parameters.
35		*/
36		private boolean lookaheadFlag;
37
38		/** Hack to pass the fact that a formal parameter was varargs back to the method/constructor production. */
39		boolean lastFormalParameterIsVarArgs = false;
40
41		/**
42		* The message reader
43		*/
44		private LocalizedMessageReader reader =
45		new LocalizedMessageReader("koala.dynamicjava.parser.resources.messages");
46
47		/** Sets the current file */
48	0	public void setFile(File f) { file = f; }
49
50	732	public void setOptions(Options o) { opt = o; }
51
52	4966	private SourceInfo _range(Token first, Token last) {
53	4966	return SourceInfo.range(file, first.beginLine, first.beginColumn, last.endLine, last.endColumn);
54		}
55
56	1074	private SourceInfo _range(Token first, SourceInfo.Wrapper last) {
57	1074	return SourceInfo.prepend(first.beginLine, first.beginColumn, last);
58		}
59
60	4733	private SourceInfo _range(SourceInfo.Wrapper first, Token last) {
61	4733	return SourceInfo.extend(first, last.beginLine, last.beginColumn);
62		}
63
64	0	private SourceInfo _range(Token first, SourceInfo last) {
65	0	return SourceInfo.prepend(first.beginLine, first.beginColumn, last);
66		}
67
68	0	private SourceInfo _range(SourceInfo first, Token last) {
69	0	return SourceInfo.extend(first, last.beginLine, last.beginColumn);
70		}
71
72	1346	private SourceInfo _range(SourceInfo.Wrapper first, SourceInfo.Wrapper last) {
73	1346	return SourceInfo.span(first, last);
74		}
75
76	4	private SourceInfo _range(SourceInfo first, SourceInfo last) {
77	4	return SourceInfo.span(first, last);
78		}
79
80		/**
81		* Throws a parse exception with the given message at the current (last consumed) token
82		* @param message - the message to be thrown
83		*/
84
85	0	private <T> T _throwParseException(String message) throws ParseException {
86	0	ParseException pe = new ParseException(message);
87	0	pe.currentToken = token;
88	0	throw pe;
89		}
90
91		/**
92		* Throws a parse exception with the given message at the current token, if the given
93		* parse exception was one auto generated by the parser (not one of ours), but not if the
94		* message is an <EOF> message, which is passed up to allow continuation of typing
95		* @param pe - the previous parse exception thrown
96		* @param message - the message to be thrown
97		*/
98	0	private <T> T _throwParseException(ParseException pe, String message) throws ParseException {
99	0	if (pe.expectedTokenSequences == null) { // has custom message
100	0	message = pe.getMessage();
101		}
102		else {
103	0	edu.rice.cs.plt.debug.DebugUtil.debug.log("Raw parse exception", pe);
104		}
105	0	if(pe.getMessage().indexOf("<EOF>\"") != -1) {
106	0	message = "Encountered Unexpected \"<EOF>\"";
107		}
108	0	return this.<T>_throwParseException(message);
109		}
110
111		public static enum DeclType { TOP, CLASS_MEMBER, INTERFACE_MEMBER, LOCAL, REPL };
112
113		/**
114		* Creates a field declaration
115		*/
116	23	private FieldDeclaration createFieldDeclaration(ModifierSet mods,
117		TypeName typ,
118		Token name,
119		Expression exp,
120		int dim) {
121	23	SourceInfo si = (exp == null) ? _range(mods, name) : _range(mods, exp);
122
123		// If the field is an array, create an array type node
124	23	if (dim > 0) {
125	0	typ = new ArrayTypeName(typ, dim, false, typ.getSourceInfo());
126		}
127
128	23	return new FieldDeclaration(mods, typ, name.image, exp, si);
129		}
130
131		/**
132		* Creates a variable declaration
133		*/
134	671	private VariableDeclaration createVariableDeclaration(ModifierSet mods,
135		TypeName typ,
136		Token name,
137		Expression exp,
138		int dim) {
139	671	SourceInfo si = (exp == null) ? _range(mods, name) : _range(mods, exp);
140
141		// If the variable contains an array, create an array type node
142	671	if (dim > 0) {
143	0	typ = new ArrayTypeName(typ, dim, false, typ.getSourceInfo());
144		}
145
146	671	return new VariableDeclaration(mods, typ, name.image, exp, si);
147		}
148
149
150	1623	private void checkModifiers(ModifierSet mods, ModifierSet.Modifier... allowed) throws ParseException {
151	1623	Set<ModifierSet.Modifier> copy = EnumSet.copyOf(mods.getFlags());
152	4074	for (ModifierSet.Modifier m : allowed) { copy.remove(m); }
153	1623	if (!copy.isEmpty()) {
154	0	ModifierSet.Modifier badMod = copy.iterator().next();
155	0	_throwParseException("Modifier " + badMod.getName() + " is not allowed here");
156		}
157		}
158
159
160		/** A hierarchy of helper classes for building primary expressions. */
161		abstract class Primary implements SourceInfo.Wrapper {
162		private final SourceInfo _si;
163	4652	protected Primary(SourceInfo si) { _si = si; }
164	3308	public SourceInfo getSourceInfo() { return _si; }
165
166	0	public Expression asExpression() throws ParseException {
167	0	return _throwParseException("Incomplete expression");
168		}
169	0	public Primary dotId(Option<List<TypeName>> targs, Token id) throws ParseException {
170	0	if (targs.isNone()) { return _throwParseException("Unexpected identifier"); }
171	0	else { return _throwParseException("Unexpected type arguments and identifier"); }
172		}
173	0	public Primary dotThis(Option<List<TypeName>> targs, Token t) throws ParseException {
174	0	if (targs.isNone()) { return _throwParseException("Unexpected 'this' keyword"); }
175	0	else { return _throwParseException("Unexpected type arguments and 'this' keyword"); }
176		}
177	0	public Primary dotSuper(Option<List<TypeName>> targs, Token t) throws ParseException {
178	0	if (targs.isNone()) { return _throwParseException("Unexpected 'super' keyword"); }
179	0	else { return _throwParseException("Unexpected type arguments and 'super' keyword"); }
180		}
181	0	public Primary dotClass(Token t) throws ParseException {
182	0	return _throwParseException("Illegal class literal");
183		}
184	0	public Primary dotNew(Option<List<TypeName>> targs, Token id) throws ParseException {
185	0	if (targs.isNone()) { return _throwParseException("Unexpected 'new' keyword"); }
186	0	else { return _throwParseException("Unexpected 'new' keyword and type arguments"); }
187		}
188	0	public Primary withArrayDim(Token last) throws ParseException {
189	0	return _throwParseException("Unexpected empty array brackets");
190		}
191	0	public Primary withArrayAccess(Expression exp, Token last) throws ParseException {
192	0	return _throwParseException("Unexpected array access");
193		}
194	0	public Primary withTypeArgs(List<TypeName> targs, Token last) throws ParseException {
195	0	return _throwParseException("Unexpected type arguments");
196		}
197	0	public Primary withArgs(List<Expression> args, Token last) throws ParseException {
198	0	return _throwParseException("Unexpected argument list");
199		}
200	0	public Primary withClassBody(List<Node> members, Token last) throws ParseException {
201	0	return _throwParseException("Unexpected class body");
202		}
203		}
204
205		/** A primary that can be parsed as a complete expression and act as a method receiver, etc. */
206		abstract class CompletedPrimary extends Primary {
207	4051	protected CompletedPrimary(SourceInfo si) { super(si); }
208
209		@Override public abstract Expression asExpression() throws ParseException;
210
211	23	@Override public Primary dotId(Option<List<TypeName>> targs, Token id) throws ParseException {
212	23	if (targs.isNone()) { return new ObjectFieldAccessPrimary(asExpression(), id); }
213	0	else { return new PartialObjectMethodCallPrimary(asExpression(), targs, id); }
214		}
215
216	0	@Override public Primary dotSuper(Option<List<TypeName>> targs, Token t) throws ParseException {
217	0	return new PartialSuperConstructorCallPrimary(asExpression(), targs, t);
218		}
219
220	1	@Override public Primary dotNew(Option<List<TypeName>> targs, Token id) throws ParseException {
221	1	return new PartialInnerAllocationPrimary(asExpression(), targs, id);
222		}
223
224	109	@Override public Primary withArrayAccess(Expression exp, Token last) throws ParseException {
225	109	return new ExpressionPrimary(new ArrayAccess(asExpression(), exp, _range(this, last)));
226		}
227		}
228
229		/** A primary that can only be parsed as the given expression, regardless of what follows. */
230		class ExpressionPrimary extends CompletedPrimary {
231		private Expression _exp;
232	1413	public ExpressionPrimary(Expression exp) { super(exp.getSourceInfo()); _exp = exp; }
233	1413	public Expression asExpression() { return _exp; }
234		}
235
236		/** Like an ExpressionPrimary, but constructor calls can't be followed by additional dots, etc. */
237		class ConstructorCallPrimary extends Primary {
238		private ConstructorCall _call;
239	46	public ConstructorCallPrimary(ConstructorCall call) { super(call.getSourceInfo()); _call = call; }
240	46	@Override public Expression asExpression() { return _call; }
241		}
242
243		/** An ExpressionPrimary, but doesn't allow array accesses. */
244		class ArrayAllocationPrimary extends ExpressionPrimary {
245	14	public ArrayAllocationPrimary(ArrayAllocation alloc) { super(alloc); }
246	0	public Primary withArrayAccess(Expression exp, Token last) throws ParseException {
247	0	return _throwParseException("Unexpected array access");
248		}
249		}
250
251
252		/** A dotted sequence of names. */
253		class AmbiguousNamePrimary extends CompletedPrimary {
254		private final ConsList.Nonempty<IdentifierToken> _reversed;
255	1856	public AmbiguousNamePrimary(Token id) {
256	1856	this(ConsList.<IdentifierToken>singleton(new TreeToken(id, file)), _range(id, id));
257		}
258	2118	private AmbiguousNamePrimary(ConsList.Nonempty<IdentifierToken> reversed, SourceInfo si) {
259	2118	super(si);
260	2118	_reversed = reversed;
261		}
262	1610	private LinkedList<IdentifierToken> ids() { return CollectUtil.makeLinkedList(ConsList.reverse(_reversed)); }
263
264	1602	public Expression asExpression() {
265	1602	return new AmbiguousName(ids(), getSourceInfo());
266		}
267
268	262	@Override public Primary dotId(Option<List<TypeName>> targs, Token id) {
269	262	if (targs.isNone()) {
270	262	return new AmbiguousNamePrimary(ConsList.cons(new TreeToken(id, file), _reversed), _range(this, id));
271		}
272	0	else { return new PartialObjectMethodCallPrimary(asExpression(), targs, id); }
273		}
274
275	1	@Override public Primary dotThis(Option<List<TypeName>> targs, Token t) throws ParseException {
276	1	if (targs.isNone()) {
277	1	Option<String> cn = Option.some(TreeUtilities.listToName(ids()));
278	1	return new ExpressionPrimary(new ThisExpression(cn, _range(this, t)));
279		}
280	0	else { return _throwParseException("Unexpected type arguments"); }
281		}
282
283	0	@Override public Primary dotSuper(Option<List<TypeName>> targs, Token t) throws ParseException {
284	0	if (targs.isNone()) { return new PartialSuperPrimary(ids(), t); }
285	0	else { return super.dotSuper(targs, t); }
286		}
287
288	6	@Override public Primary dotClass(Token t) {
289	6	return new ExpressionPrimary(new TypeExpression(new ReferenceTypeName(ids(), getSourceInfo()), _range(this, t)));
290		}
291
292	1	@Override public Primary withArrayDim(Token last) {
293	1	TypeName elt = new ReferenceTypeName(ids(), getSourceInfo());
294	1	return new ArrayTypeNamePrimary(new ArrayTypeName(elt, 1, false, _range(this, last)));
295		}
296
297	0	@Override public Primary withTypeArgs(List<TypeName> targs, Token last) {
298	0	return new GenericReferenceTypeNamePrimary(_reversed, targs, _range(this, last));
299		}
300
301	246	@Override public Primary withArgs(List<Expression> args, Token last) {
302	246	SourceInfo si = _range(this, last);
303	246	ConsList<? extends IdentifierToken> revObjIds = _reversed.rest();
304	246	if (revObjIds.isEmpty()) {
305	110	return new ExpressionPrimary(new SimpleMethodCall(_reversed.first().image(), args, si));
306		}
307		else {
308	136	LinkedList<IdentifierToken> objIds = CollectUtil.makeLinkedList(ConsList.reverse(revObjIds));
309	136	AmbiguousName obj = new AmbiguousName(objIds, _range(objIds.getFirst(), objIds.getLast()));
310	136	return new ExpressionPrimary(new ObjectMethodCall(obj, _reversed.first().image(), args, si));
311		}
312		}
313		}
314
315		/** A dotted name with at least one type argument. Can be followed by additional identifiers and type arguments. */
316		class GenericReferenceTypeNamePrimary extends Primary {
317		protected final ConsList.Nonempty<IdentifierToken> _reversed;
318		protected final ConsList.Nonempty<List<TypeName>> _targsReversed;
319	0	public GenericReferenceTypeNamePrimary(ConsList.Nonempty<IdentifierToken> reversed, List<TypeName> targs,
320		SourceInfo si) {
321	0	super(si);
322	0	_reversed = reversed;
323	0	ConsList<List<TypeName>> noArgs = ConsList.empty();
324	0	int noArgCount = _reversed.size() - 1;
325	0	for (int i = 0; i < noArgCount; i++) { noArgs = ConsList.cons(new LinkedList<TypeName>(), noArgs); }
326	0	_targsReversed = ConsList.cons(targs, noArgs);
327		}
328	0	private GenericReferenceTypeNamePrimary(ConsList.Nonempty<IdentifierToken> reversed,
329		ConsList.Nonempty<List<TypeName>> targsReversed, SourceInfo si) {
330	0	super(si);
331	0	_reversed = reversed;
332	0	_targsReversed = targsReversed;
333		}
334
335	0	protected GenericReferenceTypeName asTypeName() {
336	0	List<IdentifierToken> ids = CollectUtil.makeLinkedList(ConsList.reverse(_reversed));
337	0	List<List<? extends TypeName>> targs =
338		CollectUtil.<List<? extends TypeName>>makeLinkedList(ConsList.reverse(_targsReversed));
339	0	return new GenericReferenceTypeName(ids, targs, getSourceInfo());
340		}
341
342	0	@Override public Primary dotId(Option<List<TypeName>> targs, Token id) {
343	0	if (targs.isNone()) { return new IdGenericReferenceTypeNamePrimary(this, id); }
344	0	else { return new PartialStaticMethodCallPrimary(asTypeName(), targs, id); }
345		}
346
347	0	@Override public Primary dotClass(Token t) {
348	0	return new ExpressionPrimary(new TypeExpression(asTypeName(), _range(this, t)));
349		}
350
351	0	@Override public Primary withArrayDim(Token last) {
352	0	return new ArrayTypeNamePrimary(new ArrayTypeName(asTypeName(), 1, false, _range(this, last)));
353		}
354
355		}
356
357		/** A GenericReferenceTypeNamePrimary that ends with an id. */
358		class IdGenericReferenceTypeNamePrimary extends GenericReferenceTypeNamePrimary {
359		private final GenericReferenceTypeNamePrimary _prev;
360	0	public IdGenericReferenceTypeNamePrimary(GenericReferenceTypeNamePrimary prev, Token id) {
361	0	super(ConsList.cons(new TreeToken(id, file), prev._reversed),
362		ConsList.cons(new LinkedList<TypeName>(), prev._targsReversed),
363		_range(prev, id));
364	0	_prev = prev;
365		}
366	0	@Override public Primary withTypeArgs(List<TypeName> targs, Token last) {
367	0	ConsList.Nonempty<List<TypeName>> newTargs = ConsList.cons(targs, _targsReversed.rest());
368	0	return new GenericReferenceTypeNamePrimary(_reversed, newTargs, _range(this, last));
369		}
370	0	@Override public Primary withArgs(List<Expression> args, Token last) {
371	0	return new ExpressionPrimary(new StaticMethodCall(_prev.asTypeName(), _reversed.first().image(),
372		args, _range(this, last)));
373		}
374		}
375
376		/** An array type name. */
377		class ArrayTypeNamePrimary extends Primary {
378		private final ArrayTypeName _type;
379	3	public ArrayTypeNamePrimary(ArrayTypeName type) { super(type.getSourceInfo()); _type = type; }
380	2	@Override public Primary dotClass(Token t) {
381	2	return new ExpressionPrimary(new TypeExpression(_type, _range(this, t)));
382		}
383	1	@Override public Primary withArrayDim(Token last) {
384	1	return new ArrayTypeNamePrimary(new ArrayTypeName(_type, 1, false, _range(this, last)));
385		}
386		}
387
388		/** A primitive type, which may be part of a class literal or an array type. */
389		class PrimitiveTypeNamePrimary extends Primary {
390		private final PrimitiveTypeName _type;
391	8	public PrimitiveTypeNamePrimary(PrimitiveTypeName type) { super(type.getSourceInfo()); _type = type; }
392	7	@Override public Primary dotClass(Token t) {
393	7	return new ExpressionPrimary(new TypeExpression(_type, _range(this, t)));
394		}
395	1	@Override public Primary withArrayDim(Token last) {
396	1	return new ArrayTypeNamePrimary(new ArrayTypeName(_type, 1, false, _range(this, last)));
397		}
398		}
399
400		/** A "void" keyword, which may be part of a class literal. */
401		class VoidTypeNamePrimary extends Primary {
402		private final VoidTypeName _type;
403	1	public VoidTypeNamePrimary(VoidTypeName type) { super(type.getSourceInfo()); _type = type; }
404	1	@Override public Primary dotClass(Token t) {
405	1	return new ExpressionPrimary(new TypeExpression(_type, _range(this, t)));
406		}
407		}
408
409
410		/** Optional type arguments followed by a method name. */
411		class PartialSimpleMethodCallPrimary extends Primary {
412		private final Option<List<TypeName>> _targs;
413		private final String _name;
414	0	public PartialSimpleMethodCallPrimary(Option<List<TypeName>> targs, Token id, SourceInfo si) {
415	0	super(si);
416	0	_targs = targs;
417	0	_name = id.image;
418		}
419	0	@Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {
420	0	SourceInfo si = _range(this, last);
421	0	return new ExpressionPrimary(new SimpleMethodCall(_targs, _name, args, si));
422		}
423		}
424
425		/** An expression followed by a dot and a name. May be followed by method arguments. */
426		class ObjectFieldAccessPrimary extends CompletedPrimary {
427		private final Expression _obj;
428		private final String _name;
429	23	public ObjectFieldAccessPrimary(Expression obj, Token id) {
430	23	super(_range(obj, id));
431	23	_obj = obj;
432	23	_name = id.image;
433		}
434	0	public Expression asExpression() { return new ObjectFieldAccess(_obj, _name, getSourceInfo()); }
435	23	@Override public Primary withArgs(List<Expression> args, Token last) {
436	23	return new ExpressionPrimary(new ObjectMethodCall(_obj, _name, args, _range(this, last)));
437		}
438		}
439
440		/** An expression followed by a dot, optional type arguments, and a method name. */
441		class PartialObjectMethodCallPrimary extends Primary {
442		private final Expression _obj;
443		private final Option<List<TypeName>> _targs;
444		private final String _name;
445	0	public PartialObjectMethodCallPrimary(Expression obj, Option<List<TypeName>> targs, Token id) {
446	0	super(_range(obj, id));
447	0	_obj = obj;
448	0	_targs = targs;
449	0	_name = id.image;
450		}
451	0	@Override public Primary withArgs(List<Expression> args, Token last) {
452	0	SourceInfo si = _range(this, last);
453	0	return new ExpressionPrimary(new ObjectMethodCall(_obj, _targs, _name, args, si));
454		}
455		}
456
457		/** A type followed by a dot, optional type arguments, and a method name. */
458		class PartialStaticMethodCallPrimary extends Primary {
459		private final TypeName _type;
460		private final Option<List<TypeName>> _targs;
461		private final String _name;
462	0	PartialStaticMethodCallPrimary(TypeName type, Option<List<TypeName>> targs, Token id) {
463	0	super(_range(type, id));
464	0	_type = type;
465	0	_targs = targs;
466	0	_name = id.image;
467		}
468	0	@Override public Primary withArgs(List<Expression> args, Token last) {
469	0	SourceInfo si = _range(this, last);
470	0	return new ExpressionPrimary(new StaticMethodCall(_type, _targs, _name, args, si));
471		}
472		}
473
474		/** The "this" keyword. May be a constructor call. */
475		class ThisExpressionPrimary extends CompletedPrimary {
476	0	public ThisExpressionPrimary(Token t) { super(_range(t, t)); }
477	0	public Expression asExpression() {
478	0	return new ThisExpression(Option.<String>none(), getSourceInfo());
479		}
480	0	@Override public Primary withArgs(List<Expression> args, Token last) {
481	0	return new ConstructorCallPrimary(new ConstructorCall(null, args, false, _range(this, last)));
482		}
483		}
484
485		/** A "this" keyword prefixed by optional type arguments. */
486		class PartialThisConstructorCallPrimary extends Primary {
487		private final Option<List<TypeName>> _targs;
488	0	public PartialThisConstructorCallPrimary(Option<List<TypeName>> targs, SourceInfo si) {
489	0	super(si);
490	0	_targs = targs;
491		}
492	0	@Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {
493	0	if (_targs.isSome()) {
494	0	return _throwParseException("Parameterized this constructor calls are not yet supported");
495		}
496	0	return new ConstructorCallPrimary(new ConstructorCall(null, args, false, _range(this, last)));
497		}
498		}
499
500		/** The "super" keyword, optionally prefixed by a dotted name. May be a constructor call or a field/method access. */
501		class PartialSuperPrimary extends Primary {
502		private final LinkedList<IdentifierToken> _ids; // may be null
503	47	public PartialSuperPrimary(Token t) { super(_range(t, t)); _ids = null; }
504	0	public PartialSuperPrimary(LinkedList<IdentifierToken> ids, Token t) {
505	0	super(_range(ids.getFirst(), t));
506	0	_ids = ids;
507		}
508	1	@Override public Primary dotId(Option<List<TypeName>> targs, Token id) {
509	1	Option<String> cn = (_ids == null) ? Option.<String>none() : Option.some(TreeUtilities.listToName(_ids));
510	1	if (targs.isNone()) { return new SuperFieldAccessPrimary(cn, id, _range(this, id)); }
511	0	else { return new PartialSuperMethodCallPrimary(cn, targs, id, _range(this, id)); }
512		}
513	46	@Override public Primary withArgs(List<Expression> args, Token last) {
514	46	Expression outer = null;
515	0	if (_ids != null) { outer = new AmbiguousName(_ids, _range(_ids.getFirst(), _ids.getLast())); }
516	46	return new ConstructorCallPrimary(new ConstructorCall(outer, args, true, _range(this, last)));
517		}
518		}
519
520		/** A "super" keyword prefixed by optional type arguments. Optionally prefixed by an outer expression. */
521		class PartialSuperConstructorCallPrimary extends Primary {
522		private final Expression _outer; // may be null
523		private final Option<List<TypeName>> _targs;
524	0	public PartialSuperConstructorCallPrimary(Option<List<TypeName>> targs, SourceInfo si) {
525	0	super(si);
526	0	_outer = null;
527	0	_targs = targs;
528		}
529	0	public PartialSuperConstructorCallPrimary(Expression outer, Option<List<TypeName>> targs, Token last) {
530	0	super(_range(outer, last));
531	0	_outer = outer;
532	0	_targs = targs;
533		}
534	0	@Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {
535	0	if (_targs.isSome()) {
536	0	return _throwParseException("Parameterized super constructor calls are not yet supported");
537		}
538	0	return new ConstructorCallPrimary(new ConstructorCall(_outer, args, true, _range(this, last)));
539		}
540		}
541
542		/**
543		* A "super" keyword (optionally prefixed by a name), followed by a dot and a name. May be followed by
544		* method arguments.
545		*/
546		class SuperFieldAccessPrimary extends CompletedPrimary {
547		private final Option<String> _className;
548		private final String _name;
549	1	public SuperFieldAccessPrimary(Option<String> className, Token id, SourceInfo si) {
550	1	super(si);
551	1	_className = className;
552	1	_name = id.image;
553		}
554	1	public Expression asExpression() throws ParseException {
555	1	return new SuperFieldAccess(_className, _name, getSourceInfo());
556		}
557	0	@Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {
558	0	return new ExpressionPrimary(new SuperMethodCall(_className, _name, args, _range(this, last)));
559		}
560		}
561
562		/**
563		* A "super" keyword (optionally prefixed by a name), followed by a dot, optional type arguments, and
564		* a method name.
565		*/
566		class PartialSuperMethodCallPrimary extends Primary {
567		private final Option<String> _className;
568		private final Option<List<TypeName>> _targs;
569		private final String _name;
570	0	PartialSuperMethodCallPrimary(Option<String> className, Option<List<TypeName>> targs, Token id,
571		SourceInfo si) {
572	0	super(si);
573	0	_className = className;
574	0	_targs = targs;
575	0	_name = id.image;
576		}
577	0	@Override public Primary withArgs(List<Expression> args, Token last) throws ParseException {
578	0	SourceInfo si = _range(this, last);
579	0	return new ExpressionPrimary(new SuperMethodCall(_className, _targs, _name, args, si));
580		}
581		}
582
583		/** A "new" keyword followed by optional type arguments and a type. */
584		class PartialSimpleAllocationPrimary extends Primary {
585		private final Option<List<TypeName>> _targs;
586		private final ReferenceTypeName _type;
587	495	public PartialSimpleAllocationPrimary(Option<List<TypeName>> targs, ReferenceTypeName type, SourceInfo si) {
588	495	super(si);
589	495	_targs = targs;
590	495	_type = type;
591		}
592	495	@Override public Primary withArgs(List<Expression> args, Token last) {
593	495	return new SimpleAllocationPrimary(_targs, _type, args, _range(this, last));
594		}
595		}
596
597		/**
598		* A "new" keyword followed by optional type arguments, a type, and constructor arguments. May
599		* be an anonymous allocation if followed by a class body.
600		*/
601		class SimpleAllocationPrimary extends CompletedPrimary {
602		private final Option<List<TypeName>> _targs;
603		private final ReferenceTypeName _type;
604		private final List<Expression> _args;
605	495	public SimpleAllocationPrimary(Option<List<TypeName>> targs, ReferenceTypeName type, List<Expression> args,
606		SourceInfo si) {
607	495	super(si);
608	495	_targs = targs;
609	495	_type = type;
610	495	_args = args;
611		}
612	494	public Expression asExpression() {
613	494	return new SimpleAllocation(_targs, _type, _args, getSourceInfo());
614		}
615	1	@Override public Primary withClassBody(List<Node> members, Token last) {
616	1	SourceInfo si = _range(this, last);
617	1	return new ExpressionPrimary(new AnonymousAllocation(_targs, _type, _args, members, si));
618		}
619		}
620
621		/** An expression followed by a dot, "new", optional type arguments, and a class name. */
622		class PartialInnerAllocationPrimary extends Primary {
623		private final Expression _outer;
624		private final Option<List<TypeName>> _targs;
625		private final String _name;
626	1	public PartialInnerAllocationPrimary(Expression outer, Option<List<TypeName>> targs, Token id) {
627	1	super(_range(outer, id));
628	1	_outer = outer;
629	1	_targs = targs;
630	1	_name = id.image;
631		}
632	0	@Override public Primary withTypeArgs(List<TypeName> args, Token last) {
633	0	return new PartialGenericInnerAllocationPrimary(_outer, _targs, _name, args, last);
634		}
635	1	@Override public Primary withArgs(List<Expression> args, Token last) {
636	1	return new InnerAllocationPrimary(_outer, _targs, _name, Option.<List<TypeName>>none(), args, last);
637		}
638		}
639
640		/** An expression followed by a dot, "new", optional type arguments, a class name, and class type arguments. */
641		class PartialGenericInnerAllocationPrimary extends Primary {
642		private final Expression _outer;
643		private final Option<List<TypeName>> _targs;
644		private final String _name;
645		private final List<TypeName> _ctargs;
646	0	public PartialGenericInnerAllocationPrimary(Expression outer, Option<List<TypeName>> targs, String name,
647		List<TypeName> ctargs, Token last) {
648	0	super(_range(outer, last));
649	0	_outer = outer;
650	0	_targs = targs;
651	0	_name = name;
652	0	_ctargs = ctargs;
653		}
654	0	@Override public Primary withArgs(List<Expression> args, Token last) {
655	0	return new InnerAllocationPrimary(_outer, _targs, _name, Option.some(_ctargs), args, last);
656		}
657		}
658
659		/**
660		* An expresion followed by a dot, "new", optional type arguments, a class name, optional class type arguments,
661		* and constructor arguments. May be an anonymous allocation if followed by a class body.
662		*/
663		class InnerAllocationPrimary extends CompletedPrimary {
664		private final Expression _outer;
665		private final Option<List<TypeName>> _targs;
666		private final String _name;
667		private final Option<List<TypeName>> _ctargs;
668		private final List<Expression> _args;
669	1	public InnerAllocationPrimary(Expression outer, Option<List<TypeName>> targs, String name,
670		Option<List<TypeName>> ctargs, List<Expression> args, Token last) {
671	1	super(_range(outer, last));
672	1	_outer = outer;
673	1	_targs = targs;
674	1	_name = name;
675	1	_ctargs = ctargs;
676	1	_args = args;
677		}
678	1	public Expression asExpression() {
679	1	return new InnerAllocation(_outer, _targs, _name, _ctargs, _args, getSourceInfo());
680		}
681	0	@Override public Primary withClassBody(List<Node> members, Token last) {
682	0	SourceInfo si = _range(this, last);
683	0	return new ExpressionPrimary(new AnonymousInnerAllocation(_outer, _targs, _name, _ctargs, _args, members, si));
684		}
685		}
686
687	0	void _errorChar(char c) throws ParseException {
688	0	_throwParseException("'" + c + "' expected.");
689		}
690
691		/*
692		* The syntactic grammar
693		*/
694
695		// Productions for the intepreter ////////////////////////////////////////////////
696
697		/**
698		* Parses input stream. This production is
699		* not a Java language rule. It is used by DynamicJava.
700		* @return a list of nodes (possibly empty)
701		* @see koala.dynamicjava.tree.Node
702		*/
703	793	final public List<Node> parseStream() throws ParseException {
704	793	List<Node> list = new LinkedList<Node>(); List<Node> ns;
705	793	try {
706	793	label_1:
707		while (true) {
708	1798	if (jj_2_1(1)) {
709		;
710		} else {
711	793	break label_1;
712		}
713	1005	ns = replStatement();
714	1005	list.addAll(ns);
715		}
716	793	jj_consume_token(0);
717	793	{if (true) return list;}
718		} catch (ParseException pe) {
719	0	_throwParseException(pe, "Invalid top level statement");
720		}
721	0	throw new Error("Missing return statement in function");
722		}
723
724		/**
725		* Parses an item of the input stream. This production is
726		* not a Java language rule. It is used by DynamicJava.
727		* @return a list of nodes (a list because a single variable declaration
728		* can be parsed to multiple VariableDeclaration nodes)
729		* @see koala.dynamicjava.tree.Node
730		*/
731	1005	final public List<Node> replStatement() throws ParseException {
732	1005	ModifierSet mods; Node node = null; List<Node> nodes = null;
733	1005	try {
734	1005	if (jj_2_7(2)) {
735	46	node = keywordStatement(false);
736	959	} else if (jj_2_8(2)) {
737	9	mods = modifiers();
738	9	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
739	0	case PACKAGE:
740	0	node = unmodifiedPackageDeclaration(mods, DeclType.REPL);
741	0	break;
742	1	case CLASS:
743	0	case ENUM:
744	0	case INTERFACE:
745	0	case 132:
746	1	node = unmodifiedTypeDeclaration(mods, DeclType.REPL);
747	1	break;
748	8	default:
749	8	jj_la1[0] = jj_gen;
750	8	if (jj_2_2(2147483647)) {
751	1	node = unmodifiedMethodDeclaration(mods, DeclType.REPL);
752	7	} else if (jj_2_3(2147483647)) {
753	7	nodes = unmodifiedVariableDeclaration(mods, DeclType.REPL);
754		} else {
755	0	jj_consume_token(-1);
756	0	throw new ParseException();
757		}
758		}
759	950	} else if (jj_2_9(1)) {
760	950	mods = noModifiers();
761	950	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
762	1	case PACKAGE:
763	1	node = unmodifiedPackageDeclaration(mods, DeclType.REPL);
764	1	break;
765	12	case IMPORT:
766	12	node = importDeclaration();
767	12	break;
768	89	case CLASS:
769	0	case ENUM:
770	1	case INTERFACE:
771	0	case 132:
772	90	node = unmodifiedTypeDeclaration(mods, DeclType.REPL);
773	90	break;
774	847	default:
775	847	jj_la1[1] = jj_gen;
776	847	if (jj_2_4(2147483647)) {
777	183	node = unmodifiedMethodDeclaration(mods, DeclType.REPL);
778	664	} else if (jj_2_5(2147483647)) {
779	441	nodes = unmodifiedVariableDeclaration(mods, DeclType.REPL);
780	223	} else if (jj_2_6(1)) {
781	223	node = nonKeywordStatement(false);
782		} else {
783	0	jj_consume_token(-1);
784	0	throw new ParseException();
785		}
786		}
787		} else {
788	0	jj_consume_token(-1);
789	0	throw new ParseException();
790		}
791	1005	{if (true) return (node != null) ? Collections.singletonList(node) : nodes;}
792		} catch (ParseException pe) {
793	0	_throwParseException(pe, "Invalid top level statement");
794		}
795	0	throw new Error("Missing return statement in function");
796		}
797
798		// Productions for Packages ////////////////////////////////////////////////////////
799
800		/**
801		* Parses a Java compilation unit
802		* @return a list of nodes (possibly empty)
803		* @see koala.dynamicjava.tree.Node
804		*/
805	0	final public CompilationUnit parseCompilationUnit() throws ParseException {
806	0	ModifierSet mods;
807	0	Token start = getToken(1);
808	0	PackageDeclaration pkg = null;
809	0	List<ImportDeclaration> imps = new LinkedList<ImportDeclaration>();
810	0	ImportDeclaration imp;
811	0	List<Node> decls = new LinkedList<Node>();
812	0	Node decl;
813	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
814	0	case ABSTRACT:
815	0	case CLASS:
816	0	case ENUM:
817	0	case FINAL:
818	0	case IMPORT:
819	0	case INTERFACE:
820	0	case NATIVE:
821	0	case PACKAGE:
822	0	case PRIVATE:
823	0	case PROTECTED:
824	0	case PUBLIC:
825	0	case STATIC:
826	0	case STRICTFP:
827	0	case SYNCHRONIZED:
828	0	case TRANSIENT:
829	0	case VOLATILE:
830	0	case 132:
831	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
832	0	case IMPORT:
833	0	label_2:
834		while (true) {
835	0	imp = importDeclaration();
836	0	imps.add(imp);
837	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
838	0	case IMPORT:
839		;
840	0	break;
841	0	default:
842	0	jj_la1[2] = jj_gen;
843	0	break label_2;
844		}
845		}
846	0	break;
847	0	case ABSTRACT:
848	0	case CLASS:
849	0	case ENUM:
850	0	case FINAL:
851	0	case INTERFACE:
852	0	case NATIVE:
853	0	case PACKAGE:
854	0	case PRIVATE:
855	0	case PROTECTED:
856	0	case PUBLIC:
857	0	case STATIC:
858	0	case STRICTFP:
859	0	case SYNCHRONIZED:
860	0	case TRANSIENT:
861	0	case VOLATILE:
862	0	case 132:
863	0	mods = optionalModifiers();
864	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
865	0	case PACKAGE:
866	0	pkg = unmodifiedPackageDeclaration(mods, DeclType.TOP);
867	0	label_3:
868		while (true) {
869	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
870	0	case IMPORT:
871		;
872	0	break;
873	0	default:
874	0	jj_la1[3] = jj_gen;
875	0	break label_3;
876		}
877	0	imp = importDeclaration();
878	0	imps.add(imp);
879		}
880	0	break;
881	0	case CLASS:
882	0	case ENUM:
883	0	case INTERFACE:
884	0	case 132:
885	0	decl = unmodifiedTypeDeclaration(mods, DeclType.TOP);
886	0	decls.add(decl);
887	0	break;
888	0	default:
889	0	jj_la1[4] = jj_gen;
890	0	jj_consume_token(-1);
891	0	throw new ParseException();
892		}
893	0	break;
894	0	default:
895	0	jj_la1[5] = jj_gen;
896	0	jj_consume_token(-1);
897	0	throw new ParseException();
898		}
899	0	label_4:
900		while (true) {
901	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
902	0	case ABSTRACT:
903	0	case CLASS:
904	0	case ENUM:
905	0	case FINAL:
906	0	case INTERFACE:
907	0	case NATIVE:
908	0	case PRIVATE:
909	0	case PROTECTED:
910	0	case PUBLIC:
911	0	case STATIC:
912	0	case STRICTFP:
913	0	case SYNCHRONIZED:
914	0	case TRANSIENT:
915	0	case VOLATILE:
916	0	case SEMICOLON:
917	0	case 132:
918		;
919	0	break;
920	0	default:
921	0	jj_la1[6] = jj_gen;
922	0	break label_4;
923		}
924	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
925	0	case ABSTRACT:
926	0	case CLASS:
927	0	case ENUM:
928	0	case FINAL:
929	0	case INTERFACE:
930	0	case NATIVE:
931	0	case PRIVATE:
932	0	case PROTECTED:
933	0	case PUBLIC:
934	0	case STATIC:
935	0	case STRICTFP:
936	0	case SYNCHRONIZED:
937	0	case TRANSIENT:
938	0	case VOLATILE:
939	0	case 132:
940	0	decl = typeDeclaration(DeclType.TOP);
941	0	decls.add(decl);
942	0	break;
943	0	case SEMICOLON:
944	0	jj_consume_token(SEMICOLON);
945	0	break;
946	0	default:
947	0	jj_la1[7] = jj_gen;
948	0	jj_consume_token(-1);
949	0	throw new ParseException();
950		}
951		}
952	0	break;
953	0	default:
954	0	jj_la1[8] = jj_gen;
955		;
956		}
957	0	jj_consume_token(0);
958	0	{if (true) return new CompilationUnit(pkg, imps, decls, _range(start, token));}
959	0	throw new Error("Missing return statement in function");
960		}
961
962	671	final public ModifierSet optionalModifiers() throws ParseException {
963	671	ModifierSet mods = null;
964	671	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
965	0	case ABSTRACT:
966	0	case FINAL:
967	0	case NATIVE:
968	23	case PRIVATE:
969	0	case PROTECTED:
970	227	case PUBLIC:
971	0	case STATIC:
972	0	case STRICTFP:
973	0	case SYNCHRONIZED:
974	0	case TRANSIENT:
975	0	case VOLATILE:
976	0	case 132:
977	250	mods = modifiers();
978	250	{if (true) return mods;}
979	0	break;
980	421	default:
981	421	jj_la1[9] = jj_gen;
982	421	mods = noModifiers();
983	421	{if (true) return mods;}
984		}
985	0	throw new Error("Missing return statement in function");
986		}
987
988		/** Create an empty modifier set at the current location. */
989	1848	final public ModifierSet noModifiers() throws ParseException {
990	1848	SourceInfo si = SourceInfo.point(file, getToken(1).beginLine, getToken(1).beginColumn);
991	1848	{if (true) return new ModifierSet(EnumSet.noneOf(Modifier.class), new LinkedList<Annotation>(), si);}
992	0	throw new Error("Missing return statement in function");
993		}
994
995		/**
996		* Parse a nonempty list of modifiers and annotations
997		*/
998	259	final public ModifierSet modifiers() throws ParseException {
999	259	EnumSet<ModifierSet.Modifier> flags = EnumSet.noneOf(ModifierSet.Modifier.class);
1000	259	Annotation ann;
1001	259	List<Annotation> annots = new LinkedList<Annotation>();
1002	259	Token first = getToken(1);
1003	259	label_5:
1004		while (true) {
1005	261	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1006	1	case ABSTRACT:
1007	1	jj_consume_token(ABSTRACT);
1008	1	if (flags.contains(Modifier.ABSTRACT)) {
1009	0	{if (true) throw new ParseError(reader.getMessage("abstract.abstract", null), _range(token, token));}
1010		}
1011	1	if (flags.contains(Modifier.FINAL)) {
1012	0	{if (true) throw new ParseError(reader.getMessage("abstract.final", null), _range(token, token));}
1013		}
1014	1	if (flags.contains(Modifier.NATIVE)) {
1015	0	{if (true) throw new ParseError(reader.getMessage("abstract.native", null), _range(token, token));}
1016		}
1017	1	flags.add(Modifier.ABSTRACT);
1018	1	break;
1019	0	case FINAL:
1020	0	jj_consume_token(FINAL);
1021	0	if (flags.contains(Modifier.FINAL)) {
1022	0	{if (true) throw new ParseError(reader.getMessage("final.final", null), _range(token, token));}
1023		}
1024	0	if (flags.contains(Modifier.ABSTRACT)) {
1025	0	{if (true) throw new ParseError(reader.getMessage("abstract.final", null), _range(token, token));}
1026		}
1027	0	flags.add(Modifier.FINAL);
1028	0	break;
1029	229	case PUBLIC:
1030	229	jj_consume_token(PUBLIC);
1031	229	if (flags.contains(Modifier.PUBLIC)) {
1032	0	{if (true) throw new ParseError(reader.getMessage("public.public", null), _range(token, token));}
1033		}
1034	229	if (flags.contains(Modifier.PROTECTED)) {
1035	0	{if (true) throw new ParseError(reader.getMessage("public.protected", null), _range(token, token));}
1036		}
1037	229	if (flags.contains(Modifier.PRIVATE)) {
1038	0	{if (true) throw new ParseError(reader.getMessage("public.private", null), _range(token, token));}
1039		}
1040	229	flags.add(Modifier.PUBLIC);
1041	229	break;
1042	0	case PROTECTED:
1043	0	jj_consume_token(PROTECTED);
1044	0	if (flags.contains(Modifier.PROTECTED)) {
1045	0	{if (true) throw new ParseError(reader.getMessage("protected.protected", null), _range(token, token));}
1046		}
1047	0	if (flags.contains(Modifier.PUBLIC)) {
1048	0	{if (true) throw new ParseError(reader.getMessage("public.protected", null), _range(token, token));}
1049		}
1050	0	if (flags.contains(Modifier.PRIVATE)) {
1051	0	{if (true) throw new ParseError(reader.getMessage("protected.private", null), _range(token, token));}
1052		}
1053	0	flags.add(Modifier.PROTECTED);
1054	0	break;
1055	23	case PRIVATE:
1056	23	jj_consume_token(PRIVATE);
1057	23	if (flags.contains(Modifier.PRIVATE)) {
1058	0	{if (true) throw new ParseError(reader.getMessage("private.private", null), _range(token, token));}
1059		}
1060	23	if (flags.contains(Modifier.PUBLIC)) {
1061	0	{if (true) throw new ParseError(reader.getMessage("public.private", null), _range(token, token));}
1062		}
1063	23	if (flags.contains(Modifier.PROTECTED)) {
1064	0	{if (true) throw new ParseError(reader.getMessage("protected.private", null), _range(token, token));}
1065		}
1066	23	flags.add(Modifier.PRIVATE);
1067	23	break;
1068	0	case TRANSIENT:
1069	0	jj_consume_token(TRANSIENT);
1070	0	if (flags.contains(Modifier.TRANSIENT)) {
1071	0	{if (true) throw new ParseError(reader.getMessage("transient.transient", null), _range(token, token));}
1072		}
1073	0	flags.add(Modifier.TRANSIENT);
1074	0	break;
1075	0	case VOLATILE:
1076	0	jj_consume_token(VOLATILE);
1077	0	if (flags.contains(Modifier.VOLATILE)) {
1078	0	{if (true) throw new ParseError(reader.getMessage("volatile.volatile", null), _range(token, token));}
1079		}
1080	0	flags.add(Modifier.VOLATILE);
1081	0	break;
1082	0	case NATIVE:
1083	0	jj_consume_token(NATIVE);
1084	0	if (flags.contains(Modifier.NATIVE)) {
1085	0	{if (true) throw new ParseError(reader.getMessage("native.native", null), _range(token, token));}
1086		}
1087	0	if (flags.contains(Modifier.ABSTRACT)) {
1088	0	{if (true) throw new ParseError(reader.getMessage("abstract.native", null), _range(token, token));}
1089		}
1090	0	flags.add(Modifier.NATIVE);
1091	0	break;
1092	0	case STATIC:
1093	0	jj_consume_token(STATIC);
1094	0	if (flags.contains(Modifier.STATIC)) {
1095	0	{if (true) throw new ParseError(reader.getMessage("static.static", null), _range(token, token));}
1096		}
1097	0	flags.add(Modifier.STATIC);
1098	0	break;
1099	0	case SYNCHRONIZED:
1100	0	jj_consume_token(SYNCHRONIZED);
1101	0	if (flags.contains(Modifier.SYNCHRONIZED)) {
1102	0	{if (true) throw new ParseError(reader.getMessage("synchronized.synchronized", null), _range(token, token));}
1103		}
1104	0	flags.add(Modifier.SYNCHRONIZED);
1105	0	break;
1106	1	case STRICTFP:
1107	1	jj_consume_token(STRICTFP);
1108	1	if (flags.contains(Modifier.STRICT)) {
1109	0	{if (true) throw new ParseError(reader.getMessage("strictfp.strictfp", null), _range(token, token));}
1110		}
1111	1	flags.add(Modifier.STRICT);
1112	1	break;
1113	7	case 132:
1114	7	ann = annotation();
1115	7	annots.add(ann);
1116	7	break;
1117	0	default:
1118	0	jj_la1[10] = jj_gen;
1119	0	jj_consume_token(-1);
1120	0	throw new ParseException();
1121		}
1122	261	if (jj_2_10(2)) {
1123		;
1124		} else {
1125	259	break label_5;
1126		}
1127		}
1128	259	{if (true) return new ModifierSet(flags, annots, _range(first, token));}
1129	0	throw new Error("Missing return statement in function");
1130		}
1131
1132	0	final public PackageDeclaration packageDeclaration(DeclType level) throws ParseException {
1133	0	ModifierSet mods; PackageDeclaration decl;
1134	0	try {
1135	0	mods = optionalModifiers();
1136	0	decl = unmodifiedPackageDeclaration(mods, level);
1137	0	{if (true) return decl;}
1138		} catch (ParseException pe) {
1139	0	_throwParseException(pe,"Invalid package declaration");
1140		}
1141	0	throw new Error("Missing return statement in function");
1142		}
1143
1144	1	final public PackageDeclaration unmodifiedPackageDeclaration(ModifierSet mods, DeclType level) throws ParseException {
1145	1	ReferenceTypeName name = null;
1146	1	try {
1147	1	jj_consume_token(PACKAGE);
1148	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1149	1	case IDENTIFIER:
1150	1	name = referenceTypeName();
1151	1	break;
1152	0	default:
1153	0	jj_la1[11] = jj_gen;
1154		;
1155		}
1156	1	optionalSemicolon();
1157	1	if(name instanceof GenericReferenceTypeName){
1158	0	_throwParseException("Package names cannot be parameterized.");
1159		}
1160	1	if(name == null) {
1161	0	_throwParseException("Empty package name");
1162		}
1163	1	checkModifiers(mods); // only annotations are allowed
1164	1	{if (true) return new PackageDeclaration(mods, name.getRepresentation(), _range(mods, token));}
1165		} catch (ParseException pe) {
1166	0	_throwParseException(pe,"Invalid package declaration");
1167		}
1168	0	throw new Error("Missing return statement in function");
1169		}
1170
1171	12	final public ImportDeclaration importDeclaration() throws ParseException {
1172	12	ReferenceTypeName name = null;
1173	12	Token star = null;
1174	12	Token t1, t2;
1175	12	Token sttic = null;
1176	12	try {
1177	12	t1 = jj_consume_token(IMPORT);
1178	12	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1179	1	case STATIC:
1180	1	sttic = jj_consume_token(STATIC);
1181	1	break;
1182	11	default:
1183	11	jj_la1[12] = jj_gen;
1184		;
1185		}
1186	12	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1187	12	case IDENTIFIER:
1188	12	name = referenceTypeName();
1189	12	break;
1190	0	default:
1191	0	jj_la1[13] = jj_gen;
1192		;
1193		}
1194	12	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1195	11	case DOT:
1196	11	jj_consume_token(DOT);
1197	11	star = jj_consume_token(STAR);
1198	11	break;
1199	1	default:
1200	1	jj_la1[14] = jj_gen;
1201		;
1202		}
1203	12	t2 = optionalSemicolon();
1204	12	if(name instanceof GenericReferenceTypeName){
1205	0	_throwParseException("Import names cannot be parameterized.");
1206		}
1207	12	if(name == null) {
1208	0	_throwParseException("Missing name - Cannot import");
1209		}
1210	12	{if (true) return new ImportDeclaration(name.getRepresentation(), star != null, sttic != null, _range(t1, t2));}
1211		} catch (ParseException pe) {
1212	0	_throwParseException(pe,"Invalid Import Declaration");
1213		}
1214	0	throw new Error("Missing return statement in function");
1215		}
1216
1217	0	final public TypeDeclaration typeDeclaration(DeclType level) throws ParseException {
1218	0	ModifierSet mods; TypeDeclaration decl;
1219	0	try {
1220	0	mods = optionalModifiers();
1221	0	decl = unmodifiedTypeDeclaration(mods, level);
1222	0	{if (true) return decl;}
1223		} catch (ParseException pe) {
1224	0	_throwParseException(pe,"Invalid declaration");
1225		}
1226	0	throw new Error("Missing return statement in function");
1227		}
1228
1229	91	final public TypeDeclaration unmodifiedTypeDeclaration(ModifierSet mods, DeclType level) throws ParseException {
1230	91	TypeDeclaration node;
1231	91	try {
1232	91	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1233	90	case CLASS:
1234	90	node = unmodifiedClassDeclaration(mods, level);
1235	90	break;
1236	0	case ENUM:
1237	0	node = unmodifiedEnumDeclaration(mods, level);
1238	0	break;
1239	1	case INTERFACE:
1240	0	case 132:
1241	1	node = unmodifiedInterfaceDeclaration(mods, level);
1242	1	break;
1243	0	default:
1244	0	jj_la1[15] = jj_gen;
1245	0	jj_consume_token(-1);
1246	0	throw new ParseException();
1247		}
1248	91	{if (true) return node;}
1249		} catch (ParseException pe) {
1250	0	_throwParseException(pe,"Invalid declaration");
1251		}
1252	0	throw new Error("Missing return statement in function");
1253		}
1254
1255		// Productions for Names ////////////////////////////////////////////////////////
1256
1257		/**
1258		* Parses a name
1259		* @return a list of tree token
1260		* @see koala.dynamicjava.parser.wrapper.TreeToken
1261		*/
1262	69	final public List<IdentifierToken> name() throws ParseException {
1263	69	Token id;
1264	69	List<IdentifierToken> list = new LinkedList<IdentifierToken>();
1265	69	id = jj_consume_token(IDENTIFIER);
1266	69	list.add(new TreeToken(id, file));
1267	69	label_6:
1268		while (true) {
1269	69	if (jj_2_11(2)) {
1270		;
1271		} else {
1272	69	break label_6;
1273		}
1274	0	jj_consume_token(DOT);
1275	0	id = jj_consume_token(IDENTIFIER);
1276	0	list.add(new TreeToken(id, file));
1277		}
1278	69	{if (true) return list;}
1279	0	throw new Error("Missing return statement in function");
1280		}
1281
1282		// Production for a ReferenceTypeName ////////////////////////////////////////////////////////
1283
1284		/**
1285		* Consumes as large a name as possible: the type must not be followed by ".[id]" or "<", because
1286		* the parser will assume those delimiters mark a continuation of the ReferenceTypeName.
1287		*/
1288	1729	final public ReferenceTypeName referenceTypeName() throws ParseException {
1289	1729	Token id = null;
1290	1729	LinkedList<IdentifierToken> ids = new LinkedList<IdentifierToken>();
1291	1729	List<TypeName> targs = null;
1292	1729	boolean parameterized = false;
1293	1729	List<List<? extends TypeName>> allTypeArgs = new LinkedList<List<? extends TypeName>>();
1294	1729	try {
1295	1729	id = jj_consume_token(IDENTIFIER);
1296	1729	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1297	500	case LESS:
1298	500	targs = typeArguments();
1299	500	break;
1300	1229	default:
1301	1229	jj_la1[16] = jj_gen;
1302		;
1303		}
1304	1729	ids.add(new TreeToken(id, file));
1305	1729	allTypeArgs.add((targs == null) ? new LinkedList<TypeName>() : targs);
1306	1729	parameterized \|= targs != null;
1307	1729	targs = null;
1308	1729	label_7:
1309		while (true) {
1310	2131	if (jj_2_12(2)) {
1311		;
1312		} else {
1313	1729	break label_7;
1314		}
1315	402	jj_consume_token(DOT);
1316	402	id = jj_consume_token(IDENTIFIER);
1317	402	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1318	7	case LESS:
1319	7	targs = typeArguments();
1320	7	break;
1321	395	default:
1322	395	jj_la1[17] = jj_gen;
1323		;
1324		}
1325	402	ids.add(new TreeToken(id, file));
1326	402	allTypeArgs.add((targs == null) ? new LinkedList<TypeName>() : targs);
1327	402	parameterized \|= targs != null;
1328	402	targs = null;
1329		}
1330	1729	SourceInfo si = _range(ids.getFirst(), token);
1331	507	if (parameterized) { {if (true) return new GenericReferenceTypeName(ids, allTypeArgs, si);} }
1332	1222	else { {if (true) return new ReferenceTypeName(ids, si);} }
1333		} catch (ParseException pe) {
1334	0	_throwParseException(pe,"Invalid reference name");
1335		}
1336	0	throw new Error("Missing return statement in function");
1337		}
1338
1339		/**
1340		* Parses a comma separated list of ReferenceTypeName names
1341		* @return a list of ReferenceTypeName
1342		* @see koala.dynamicjava.tree.ReferenceTypeName
1343		*/
1344	1	final public List<? extends ReferenceTypeName> ReferenceTypeNameList() throws ParseException {
1345	1	List<ReferenceTypeName> list = new LinkedList<ReferenceTypeName>();
1346	1	ReferenceTypeName obj;
1347	1	obj = referenceTypeName();
1348	1	list.add(obj);
1349	1	label_8:
1350		while (true) {
1351	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1352	0	case COMMA:
1353		;
1354	0	break;
1355	1	default:
1356	1	jj_la1[18] = jj_gen;
1357	1	break label_8;
1358		}
1359	0	jj_consume_token(COMMA);
1360	0	obj = referenceTypeName();
1361	0	list.add(obj);
1362		}
1363	1	{if (true) return list;}
1364	0	throw new Error("Missing return statement in function");
1365		}
1366
1367		// Productions for Classes //////////////////////////////////////////////////////
1368
1369		// Productions for Class Declaration ============================================
1370
1371		/**
1372		* Parses a class declaration
1373		* @see koala.dynamicjava.tree.ClassDeclaration
1374		*/
1375	0	final public ClassDeclaration classDeclaration(DeclType level) throws ParseException {
1376	0	ClassDeclaration cd; ModifierSet md;
1377	0	md = optionalModifiers();
1378	0	cd = unmodifiedClassDeclaration(md, level);
1379	0	{if (true) return cd;}
1380	0	throw new Error("Missing return statement in function");
1381		}
1382
1383		/**
1384		* Parses a class declaration without modifier
1385		* @see koala.dynamicjava.tree.ClassDeclaration
1386		*/
1387	90	final public ClassDeclaration unmodifiedClassDeclaration(ModifierSet mods, DeclType level) throws ParseException {
1388	90	Token t;
1389	90	Token id;
1390	90	List<TypeParameter> typeParameters = null;
1391	90	ReferenceTypeName ext = null;
1392	90	List<? extends ReferenceTypeName> impl = null;
1393	90	List<Node> body;
1394	90	t = jj_consume_token(CLASS);
1395	90	id = jj_consume_token(IDENTIFIER);
1396	90	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1397	69	case LESS:
1398	69	typeParameters = typeParameters();
1399	69	break;
1400	21	default:
1401	21	jj_la1[19] = jj_gen;
1402		;
1403		}
1404	90	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1405	47	case EXTENDS:
1406	47	jj_consume_token(EXTENDS);
1407	47	ext = referenceTypeName();
1408	47	break;
1409	43	default:
1410	43	jj_la1[20] = jj_gen;
1411		;
1412		}
1413	90	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1414	1	case IMPLEMENTS:
1415	1	jj_consume_token(IMPLEMENTS);
1416	1	impl = ReferenceTypeNameList();
1417	1	break;
1418	89	default:
1419	89	jj_la1[21] = jj_gen;
1420		;
1421		}
1422	90	body = classBody();
1423	90	switch (level) {
1424	0	case TOP: checkModifiers(mods, Modifier.PUBLIC, Modifier.FINAL, Modifier.ABSTRACT, Modifier.STRICT); break;
1425	0	case CLASS_MEMBER: checkModifiers(mods, Modifier.PUBLIC, Modifier.PROTECTED, Modifier.PRIVATE,
1426	0	Modifier.STATIC, Modifier.FINAL, Modifier.ABSTRACT, Modifier.STRICT); break;
1427	0	case INTERFACE_MEMBER: checkModifiers(mods, Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL,
1428	0	Modifier.ABSTRACT, Modifier.STRICT); break;
1429	0	case LOCAL: checkModifiers(mods, Modifier.FINAL, Modifier.ABSTRACT, Modifier.STRICT); break;
1430	90	case REPL: checkModifiers(mods, Modifier.PUBLIC, Modifier.FINAL, Modifier.ABSTRACT, Modifier.STRICT); break;
1431		}
1432	90	{if (true) return new ClassDeclaration(mods, id.image, Option.wrap(typeParameters), ext, impl, body, _range(mods, token));}
1433	0	throw new Error("Missing return statement in function");
1434		}
1435
1436		/**
1437		* Used internally to parse the body of a class
1438		*/
1439	91	final public List<Node> classBody() throws ParseException {
1440	91	List<Node> list = new LinkedList<Node>();
1441	91	List<Node> decl;
1442	91	try {
1443	91	jj_consume_token(LBRACE);
1444	91	label_9:
1445		while (true) {
1446	342	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1447	0	case ABSTRACT:
1448	0	case BOOLEAN:
1449	0	case BYTE:
1450	0	case CHAR:
1451	0	case CLASS:
1452	0	case DOUBLE:
1453	0	case ENUM:
1454	0	case FINAL:
1455	0	case FLOAT:
1456	0	case INT:
1457	0	case INTERFACE:
1458	0	case LONG:
1459	0	case NATIVE:
1460	23	case PRIVATE:
1461	0	case PROTECTED:
1462	227	case PUBLIC:
1463	0	case SHORT:
1464	0	case STATIC:
1465	0	case STRICTFP:
1466	0	case SYNCHRONIZED:
1467	0	case TRANSIENT:
1468	1	case VOID:
1469	0	case VOLATILE:
1470	0	case IDENTIFIER:
1471	0	case LBRACE:
1472	0	case SEMICOLON:
1473	0	case LESS:
1474	0	case 132:
1475		;
1476	251	break;
1477	91	default:
1478	91	jj_la1[22] = jj_gen;
1479	91	break label_9;
1480		}
1481	251	decl = classBodyDeclaration();
1482	251	list.addAll(decl);
1483		}
1484	91	jj_consume_token(RBRACE);
1485	91	{if (true) return list;}
1486		} catch (ParseException pe) {
1487	0	_throwParseException(pe,"Invalid class body");
1488		}
1489	0	throw new Error("Missing return statement in function");
1490		}
1491
1492		/**
1493		* Parses one declaration in the body of a class.
1494		* @return a list of node because one field declaration can
1495		* contain multiple declarations.
1496		* @see koala.dynamicjava.tree.Node
1497		*/
1498	251	final public List<Node> classBodyDeclaration() throws ParseException {
1499	251	ModifierSet mods;
1500	251	Node node = null;
1501	251	List<Node> list = new LinkedList<Node>();
1502	251	try {
1503	251	if (jj_2_16(2)) {
1504	0	node = initializer();
1505	0	list.add(node); {if (true) return list;}
1506		} else {
1507	251	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1508	0	case SEMICOLON:
1509	0	jj_consume_token(SEMICOLON);
1510	0	{if (true) return list;}
1511	0	break;
1512	0	case ABSTRACT:
1513	0	case BOOLEAN:
1514	0	case BYTE:
1515	0	case CHAR:
1516	0	case CLASS:
1517	0	case DOUBLE:
1518	0	case ENUM:
1519	0	case FINAL:
1520	0	case FLOAT:
1521	0	case INT:
1522	0	case INTERFACE:
1523	0	case LONG:
1524	0	case NATIVE:
1525	23	case PRIVATE:
1526	0	case PROTECTED:
1527	227	case PUBLIC:
1528	0	case SHORT:
1529	0	case STATIC:
1530	0	case STRICTFP:
1531	0	case SYNCHRONIZED:
1532	0	case TRANSIENT:
1533	1	case VOID:
1534	0	case VOLATILE:
1535	0	case IDENTIFIER:
1536	0	case LESS:
1537	0	case 132:
1538	251	mods = optionalModifiers();
1539	251	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1540	0	case CLASS:
1541	0	case ENUM:
1542	0	case INTERFACE:
1543	0	case 132:
1544	0	node = unmodifiedTypeDeclaration(mods, DeclType.CLASS_MEMBER);
1545	0	break;
1546	251	default:
1547	251	jj_la1[23] = jj_gen;
1548	251	if (jj_2_13(2147483647)) {
1549	69	node = unmodifiedConstructorDeclaration(mods);
1550	182	} else if (jj_2_14(2147483647)) {
1551	159	node = unmodifiedMethodDeclaration(mods, DeclType.CLASS_MEMBER);
1552	23	} else if (jj_2_15(2147483647)) {
1553	23	list = unmodifiedVariableDeclaration(mods, DeclType.CLASS_MEMBER);
1554		} else {
1555	0	jj_consume_token(-1);
1556	0	throw new ParseException();
1557		}
1558		}
1559	251	if (node != null) { list.add(node); } {if (true) return list;}
1560	0	break;
1561	0	default:
1562	0	jj_la1[24] = jj_gen;
1563	0	jj_consume_token(-1);
1564	0	throw new ParseException();
1565		}
1566		}
1567		} catch (ParseException pe) {
1568	0	_throwParseException(pe,"Invalid member declaration");
1569		}
1570	0	throw new Error("Missing return statement in function");
1571		}
1572
1573		// Productions for variable declaration ============================================
1574
1575		/**
1576		* Parses a variable (field or local) declaration.
1577		* @return a list of field declaration because one variable declaration can
1578		* contain multiple declarations.
1579		*/
1580	0	final public List<Node> variableDeclaration(DeclType level) throws ParseException {
1581	0	ModifierSet mods; List<Node> decls;
1582	0	try {
1583	0	mods = optionalModifiers();
1584	0	decls = unmodifiedVariableDeclaration(mods, level);
1585	0	{if (true) return decls;}
1586		} catch (ParseException pe) {
1587	0	_throwParseException(pe, "Invalid variable declaration");
1588		}
1589	0	throw new Error("Missing return statement in function");
1590		}
1591
1592	692	final public List<Node> unmodifiedVariableDeclaration(ModifierSet mods, DeclType level) throws ParseException {
1593	692	TypeName typ;
1594	692	Token id;
1595	692	int dim = 0;
1596	692	Expression exp = null;
1597	692	List<Node> list = new LinkedList<Node>();
1598	692	try {
1599	692	typ = type();
1600	692	id = jj_consume_token(IDENTIFIER);
1601	692	label_10:
1602		while (true) {
1603	692	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1604	0	case LBRACKET:
1605		;
1606	0	break;
1607	692	default:
1608	692	jj_la1[25] = jj_gen;
1609	692	break label_10;
1610		}
1611	0	jj_consume_token(LBRACKET);
1612	0	jj_consume_token(RBRACKET);
1613	0	dim++;
1614		}
1615	692	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1616	641	case ASSIGN:
1617	641	jj_consume_token(ASSIGN);
1618	641	exp = variableInitializer();
1619	641	break;
1620	51	default:
1621	51	jj_la1[26] = jj_gen;
1622		;
1623		}
1624	692	switch (level) {
1625	23	case CLASS_MEMBER:
1626	23	checkModifiers(mods, Modifier.PUBLIC, Modifier.PRIVATE, Modifier.PROTECTED, Modifier.STATIC,
1627		Modifier.FINAL, Modifier.VOLATILE, Modifier.TRANSIENT);
1628	23	list.add(createFieldDeclaration(mods, typ, id, exp, dim));
1629	23	break;
1630	0	case INTERFACE_MEMBER:
1631	0	checkModifiers(mods, Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL);
1632	0	list.add(createFieldDeclaration(mods, typ, id, exp, dim));
1633	0	break;
1634	448	case REPL:
1635	448	checkModifiers(mods, Modifier.PUBLIC, Modifier.FINAL);
1636	448	list.add(createVariableDeclaration(mods, typ, id, exp, dim));
1637	448	break;
1638	221	default:
1639	221	checkModifiers(mods, Modifier.FINAL);
1640	221	list.add(createVariableDeclaration(mods, typ, id, exp, dim));
1641	221	break;
1642		}
1643	692	label_11:
1644		while (true) {
1645	694	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1646	2	case COMMA:
1647		;
1648	2	break;
1649	692	default:
1650	692	jj_la1[27] = jj_gen;
1651	692	break label_11;
1652		}
1653	2	jj_consume_token(COMMA);
1654	2	dim = 0; exp = null;
1655	2	id = jj_consume_token(IDENTIFIER);
1656	2	label_12:
1657		while (true) {
1658	2	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1659	0	case LBRACKET:
1660		;
1661	0	break;
1662	2	default:
1663	2	jj_la1[28] = jj_gen;
1664	2	break label_12;
1665		}
1666	0	jj_consume_token(LBRACKET);
1667	0	jj_consume_token(RBRACKET);
1668	0	dim++;
1669		}
1670	2	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1671	1	case ASSIGN:
1672	1	jj_consume_token(ASSIGN);
1673	1	exp = variableInitializer();
1674	1	break;
1675	1	default:
1676	1	jj_la1[29] = jj_gen;
1677		;
1678		}
1679	2	switch (level) {
1680	0	case CLASS_MEMBER:
1681	0	case INTERFACE_MEMBER:
1682	0	list.add(createFieldDeclaration(mods, typ, id, exp, dim));
1683	0	break;
1684	2	default:
1685	2	list.add(createVariableDeclaration(mods, typ, id, exp, dim));
1686	2	break;
1687		}
1688		}
1689	692	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1690	692	case SEMICOLON:
1691	692	jj_consume_token(SEMICOLON);
1692	692	break;
1693	0	default:
1694	0	jj_la1[30] = jj_gen;
1695	0	Token lookahead = getToken(1);
1696	0	boolean canSkip = !opt.requireSemicolon() && level.equals(DeclType.REPL) &&
1697		(lookahead.kind == ParserConstants.EOF \|\| lookahead.image.equals("}"));
1698	0	if (!canSkip) {
1699	0	_throwParseException("Invalid variable declaration");
1700		}
1701		}
1702	692	{if (true) return list;}
1703		} catch (ParseException pe) {
1704	0	_throwParseException(pe, "Invalid variable declaration");
1705		}
1706	0	throw new Error("Missing return statement in function");
1707		}
1708
1709		// Productions for Method Declaration ===========================================
1710	0	final public MethodDeclaration methodDeclaration(DeclType level) throws ParseException {
1711	0	ModifierSet mods; MethodDeclaration decl;
1712	0	try {
1713	0	mods = optionalModifiers();
1714	0	decl = unmodifiedMethodDeclaration(mods, level);
1715	0	{if (true) return decl;}
1716		} catch (ParseException pe) {
1717	0	_throwParseException(pe, "Invalid method declaration");
1718		}
1719	0	throw new Error("Missing return statement in function");
1720		}
1721
1722	343	final public MethodDeclaration unmodifiedMethodDeclaration(ModifierSet mods, DeclType level) throws ParseException {
1723	343	List<TypeParameter> typeParameters = null;
1724	343	TypeName typ;
1725	343	Token id;
1726	343	int dim = 0;
1727	343	List<FormalParameter> params;
1728	343	List<? extends ReferenceTypeName> exceptions = new LinkedList<ReferenceTypeName>();
1729	343	BlockStatement body = null;
1730	343	try {
1731	343	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1732	0	case LESS:
1733	0	typeParameters = typeParameters();
1734	0	break;
1735	343	default:
1736	343	jj_la1[31] = jj_gen;
1737		;
1738		}
1739	343	typ = resultType();
1740	343	id = jj_consume_token(IDENTIFIER);
1741	343	params = formalParameters();
1742	343	label_13:
1743		while (true) {
1744	343	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1745	0	case LBRACKET:
1746		;
1747	0	break;
1748	343	default:
1749	343	jj_la1[32] = jj_gen;
1750	343	break label_13;
1751		}
1752	0	jj_consume_token(LBRACKET);
1753	0	jj_consume_token(RBRACKET);
1754	0	dim++;
1755		}
1756	343	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1757	0	case THROWS:
1758	0	jj_consume_token(THROWS);
1759	0	exceptions = ReferenceTypeNameList();
1760	0	break;
1761	343	default:
1762	343	jj_la1[33] = jj_gen;
1763		;
1764		}
1765	343	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1766	343	case LBRACE:
1767	343	body = block();
1768	343	break;
1769	0	case SEMICOLON:
1770	0	jj_consume_token(SEMICOLON);
1771	0	break;
1772	0	default:
1773	0	jj_la1[34] = jj_gen;
1774	0	jj_consume_token(-1);
1775	0	throw new ParseException();
1776		}
1777	343	switch (level) {
1778	159	case CLASS_MEMBER:
1779	159	checkModifiers(mods, Modifier.PUBLIC, Modifier.PRIVATE, Modifier.PROTECTED, Modifier.STATIC,
1780		Modifier.FINAL, Modifier.ABSTRACT, Modifier.SYNCHRONIZED, Modifier.NATIVE,
1781		Modifier.STRICT);
1782	159	break;
1783	0	case INTERFACE_MEMBER:
1784	0	checkModifiers(mods, Modifier.PUBLIC, Modifier.ABSTRACT);
1785	0	break;
1786	184	case REPL:
1787	184	checkModifiers(mods, Modifier.PUBLIC, Modifier.STRICT);
1788	184	break;
1789	0	default:
1790	0	checkModifiers(mods, Modifier.STRICT);
1791	0	break;
1792		}
1793	72	if (lastFormalParameterIsVarArgs) mods.getFlags().add(Modifier.VARARGS);
1794
1795	343	if (dim > 0) {
1796	0	typ = new ArrayTypeName(typ, dim, false, typ.getSourceInfo());
1797		}
1798	343	{if (true) return new MethodDeclaration(mods, Option.wrap(typeParameters), typ, id.image, params, exceptions, body,
1799		_range(mods, token));}
1800		} catch (ParseException pe) {
1801	0	_throwParseException(pe, "Invalid method declaration");
1802		}
1803	0	throw new Error("Missing return statement in function");
1804		}
1805
1806		/**
1807		* Parses formal parameters of the form '(param, param, ...)'
1808		* @see koala.dynamicjava.tree.FormalParameter
1809		*/
1810	412	final public List<FormalParameter> formalParameters() throws ParseException {
1811	412	List<FormalParameter> list = new LinkedList<FormalParameter>();
1812	412	FormalParameter node;
1813	412	FormalParameter lastParam = null;
1814	412	try {
1815	412	jj_consume_token(LPAREN);
1816	412	lastFormalParameterIsVarArgs = false;
1817	412	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1818	0	case ABSTRACT:
1819	183	case BOOLEAN:
1820	0	case BYTE:
1821	0	case CHAR:
1822	0	case DOUBLE:
1823	0	case FINAL:
1824	0	case FLOAT:
1825	54	case INT:
1826	0	case LONG:
1827	0	case NATIVE:
1828	0	case PRIVATE:
1829	0	case PROTECTED:
1830	0	case PUBLIC:
1831	0	case SHORT:
1832	0	case STATIC:
1833	0	case STRICTFP:
1834	0	case SYNCHRONIZED:
1835	0	case TRANSIENT:
1836	0	case VOLATILE:
1837	146	case IDENTIFIER:
1838	0	case 132:
1839	383	node = formalParameter();
1840	383	list.add(node);
1841	383	label_14:
1842		while (true) {
1843	419	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1844	36	case COMMA:
1845		;
1846	36	break;
1847	383	default:
1848	383	jj_la1[35] = jj_gen;
1849	383	break label_14;
1850		}
1851	36	jj_consume_token(COMMA);
1852	0	if (lastFormalParameterIsVarArgs) _throwParseException("Varargs parameter must be last");
1853	36	node = formalParameter();
1854	36	list.add(node);
1855		}
1856	383	break;
1857	29	default:
1858	29	jj_la1[36] = jj_gen;
1859		;
1860		}
1861	412	jj_consume_token(RPAREN);
1862	412	{if (true) return list;}
1863		} catch (ParseException pe) {
1864	0	_throwParseException(pe, "Invalid formal parameters");
1865		}
1866	0	throw new Error("Missing return statement in function");
1867		}
1868
1869		/**
1870		* Parses one formal parameter
1871		* @see koala.dynamicjava.tree.FormalParameter
1872		*/
1873	420	final public FormalParameter formalParameter() throws ParseException {
1874	420	ModifierSet mods;
1875	420	TypeName typ;
1876	420	Token id;
1877	420	Token varargs = null;
1878	420	int dim = 0;
1879	420	try {
1880	420	mods = optionalModifiers();
1881	420	typ = type();
1882	420	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1883	72	case VAR_ARGS:
1884	72	varargs = jj_consume_token(VAR_ARGS);
1885	72	break;
1886	348	default:
1887	348	jj_la1[37] = jj_gen;
1888		;
1889		}
1890	420	id = jj_consume_token(IDENTIFIER);
1891	420	label_15:
1892		while (true) {
1893	420	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1894	0	case LBRACKET:
1895		;
1896	0	break;
1897	420	default:
1898	420	jj_la1[38] = jj_gen;
1899	420	break label_15;
1900		}
1901	0	jj_consume_token(LBRACKET);
1902	0	jj_consume_token(RBRACKET);
1903	0	dim++;
1904		}
1905	420	checkModifiers(mods, Modifier.FINAL);
1906	420	if (dim > 0) {
1907	0	typ = new ArrayTypeName(typ, dim, false, typ.getSourceInfo());
1908		}
1909	420	if (varargs != null) {
1910	72	lastFormalParameterIsVarArgs = true;
1911	72	typ = new ArrayTypeName(typ, 1, true, _range(typ, varargs));
1912		}
1913	420	{if (true) return new FormalParameter(mods, typ, id.image, _range(mods, token));}
1914		} catch (ParseException pe) {
1915	0	_throwParseException(pe, "Invalid formal parameter");
1916		}
1917	0	throw new Error("Missing return statement in function");
1918		}
1919
1920		// Production for Initializer ===================================================
1921
1922		/**
1923		* Parses one initializer
1924		* @see koala.dynamicjava.tree.Initializer
1925		*/
1926	0	final public Initializer initializer() throws ParseException {
1927	0	Token t = null;
1928	0	BlockStatement node;
1929	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1930	0	case STATIC:
1931	0	t = jj_consume_token(STATIC);
1932	0	break;
1933	0	default:
1934	0	jj_la1[39] = jj_gen;
1935		;
1936		}
1937	0	node = block();
1938	0	if (t == null) {
1939	0	{if (true) return new InstanceInitializer(node, node.getSourceInfo());}
1940		} else {
1941	0	{if (true) return new ClassInitializer(node, _range(t, node));}
1942		}
1943	0	throw new Error("Missing return statement in function");
1944		}
1945
1946		// Productions for Constructor Declaration ======================================
1947	0	final public ConstructorDeclaration constructorDeclaration() throws ParseException {
1948	0	ModifierSet mods; ConstructorDeclaration decl;
1949	0	try {
1950	0	mods = optionalModifiers();
1951	0	decl = unmodifiedConstructorDeclaration(mods);
1952	0	{if (true) return decl;}
1953		} catch (ParseException pe) {
1954	0	_throwParseException(pe, "Invalid constructor declaration");
1955		}
1956	0	throw new Error("Missing return statement in function");
1957		}
1958
1959	69	final public ConstructorDeclaration unmodifiedConstructorDeclaration(ModifierSet mods) throws ParseException {
1960	69	List<TypeParameter> typeParameters = null;
1961	69	Token id;
1962	69	List<FormalParameter> params;
1963	69	List<? extends ReferenceTypeName> exceptions = new LinkedList<ReferenceTypeName>();
1964	69	ConstructorCall ci = null;
1965	69	List<Node> stmt;
1966	69	LinkedList<Node> stmts = new LinkedList<Node>();
1967	69	try {
1968	69	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1969	0	case LESS:
1970	0	typeParameters = typeParameters();
1971	0	break;
1972	69	default:
1973	69	jj_la1[40] = jj_gen;
1974		;
1975		}
1976	69	id = jj_consume_token(IDENTIFIER);
1977	69	params = formalParameters();
1978	69	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1979	0	case THROWS:
1980	0	jj_consume_token(THROWS);
1981	0	exceptions = ReferenceTypeNameList();
1982	0	break;
1983	69	default:
1984	69	jj_la1[41] = jj_gen;
1985		;
1986		}
1987	69	jj_consume_token(LBRACE);
1988	69	label_16:
1989		while (true) {
1990	138	if (jj_2_17(1)) {
1991		;
1992		} else {
1993	69	break label_16;
1994		}
1995	69	stmt = blockStatement();
1996	69	stmts.addAll(stmt);
1997		}
1998	69	jj_consume_token(RBRACE);
1999		// check for a constructor call ExpressionStatement
2000	69	if (!stmts.isEmpty()) {
2001	69	Node first = stmts.getFirst();
2002	69	if (first instanceof ExpressionStatement) {
2003	69	Expression exp = ((ExpressionStatement) first).getExpression();
2004	69	if (exp instanceof ConstructorCall) {
2005	46	ci = (ConstructorCall) exp;
2006	46	stmts.removeFirst();
2007		}
2008		}
2009		}
2010	69	checkModifiers(mods, Modifier.PUBLIC, Modifier.PRIVATE, Modifier.PROTECTED);
2011	0	if (lastFormalParameterIsVarArgs) mods.getFlags().add(Modifier.VARARGS);
2012	69	{if (true) return new ConstructorDeclaration(mods, Option.wrap(typeParameters), id.image, params, exceptions, ci, stmts,
2013		_range(mods, token));}
2014		} catch (ParseException pe) {
2015	0	_throwParseException(pe, "Invalid constructor declaration");
2016		}
2017	0	throw new Error("Missing return statement in function");
2018		}
2019
2020		// Productions for Interfaces ///////////////////////////////////////////////////
2021
2022		/**
2023		* Parses a interface declaration
2024		* @see koala.dynamicjava.tree.InterfaceDeclaration
2025		*/
2026	0	final public InterfaceDeclaration interfaceDeclaration(DeclType level) throws ParseException {
2027	0	ModifierSet mods; InterfaceDeclaration decl;
2028	0	try {
2029	0	mods = optionalModifiers();
2030	0	decl = unmodifiedInterfaceDeclaration(mods, level);
2031	0	{if (true) return decl;}
2032		} catch (ParseException pe) {
2033	0	_throwParseException(pe, "Invalid interface declaration");
2034		}
2035	0	throw new Error("Missing return statement in function");
2036		}
2037
2038		/**
2039		* Parses a interface declaration without modifier
2040		* @see koala.dynamicjava.tree.InterfaceDeclaration
2041		*/
2042	1	final public InterfaceDeclaration unmodifiedInterfaceDeclaration(ModifierSet mods, DeclType level) throws ParseException {
2043	1	Token id;
2044	1	Token isAnnotation = null;
2045	1	List<TypeParameter> typeParameters = null;
2046	1	List<? extends ReferenceTypeName> impl = null;
2047	1	List<Node> list = new LinkedList<Node>();
2048	1	List<Node> decl;
2049	1	try {
2050	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2051	0	case 132:
2052	0	isAnnotation = jj_consume_token(132);
2053	0	break;
2054	1	default:
2055	1	jj_la1[42] = jj_gen;
2056		;
2057		}
2058	1	jj_consume_token(INTERFACE);
2059	1	id = jj_consume_token(IDENTIFIER);
2060	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2061	0	case LESS:
2062	0	typeParameters = typeParameters();
2063	0	break;
2064	1	default:
2065	1	jj_la1[43] = jj_gen;
2066		;
2067		}
2068	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2069	0	case EXTENDS:
2070	0	jj_consume_token(EXTENDS);
2071	0	impl = ReferenceTypeNameList();
2072	0	break;
2073	1	default:
2074	1	jj_la1[44] = jj_gen;
2075		;
2076		}
2077	1	jj_consume_token(LBRACE);
2078	1	label_17:
2079		while (true) {
2080	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2081	0	case ABSTRACT:
2082	0	case BOOLEAN:
2083	0	case BYTE:
2084	0	case CHAR:
2085	0	case CLASS:
2086	0	case DOUBLE:
2087	0	case ENUM:
2088	0	case FINAL:
2089	0	case FLOAT:
2090	0	case INT:
2091	0	case INTERFACE:
2092	0	case LONG:
2093	0	case NATIVE:
2094	0	case PRIVATE:
2095	0	case PROTECTED:
2096	0	case PUBLIC:
2097	0	case SHORT:
2098	0	case STATIC:
2099	0	case STRICTFP:
2100	0	case SYNCHRONIZED:
2101	0	case TRANSIENT:
2102	0	case VOID:
2103	0	case VOLATILE:
2104	0	case IDENTIFIER:
2105	0	case SEMICOLON:
2106	0	case LESS:
2107	0	case 132:
2108		;
2109	0	break;
2110	1	default:
2111	1	jj_la1[45] = jj_gen;
2112	1	break label_17;
2113		}
2114	0	decl = interfaceMemberDeclaration();
2115	0	list.addAll(decl);
2116		}
2117	1	jj_consume_token(RBRACE);
2118	1	switch (level) {
2119	0	case TOP: checkModifiers(mods, Modifier.PUBLIC, Modifier.ABSTRACT, Modifier.STRICT); break;
2120	0	case CLASS_MEMBER: checkModifiers(mods, Modifier.PUBLIC, Modifier.PRIVATE, Modifier.PROTECTED,
2121	0	Modifier.STATIC, Modifier.ABSTRACT, Modifier.STRICT); break;
2122	0	case INTERFACE_MEMBER: checkModifiers(mods, Modifier.PUBLIC, Modifier.STATIC,
2123	0	Modifier.ABSTRACT, Modifier.STRICT); break;
2124	0	case LOCAL: checkModifiers(mods, Modifier.ABSTRACT, Modifier.STRICT); break;
2125	1	case REPL: checkModifiers(mods, Modifier.PUBLIC, Modifier.ABSTRACT, Modifier.STRICT); break;
2126		}
2127
2128	1	{if (true) return new InterfaceDeclaration(mods, isAnnotation != null, id.image, Option.wrap(typeParameters), impl, list,
2129		_range(mods, token));}
2130		} catch (ParseException pe) {
2131	0	_throwParseException(pe, "Invalid interface declaration");
2132		}
2133	0	throw new Error("Missing return statement in function");
2134		}
2135
2136		/**
2137		* Parses one declaration in the body of an interface.
2138		* @return a list of node because one field declaration can
2139		* contain multiple declarations.
2140		* @see koala.dynamicjava.tree.Node
2141		*/
2142	0	final public List<Node> interfaceMemberDeclaration() throws ParseException {
2143	0	ModifierSet mods;
2144	0	Node node = null;
2145	0	List<Node> list = new LinkedList<Node>();
2146	0	try {
2147	0	mods = optionalModifiers();
2148	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2149	0	case CLASS:
2150	0	case ENUM:
2151	0	case INTERFACE:
2152	0	case 132:
2153	0	node = unmodifiedTypeDeclaration(mods, DeclType.INTERFACE_MEMBER);
2154	0	break;
2155	0	default:
2156	0	jj_la1[46] = jj_gen;
2157	0	if (jj_2_18(2147483647)) {
2158	0	node = unmodifiedMethodDeclaration(mods, DeclType.INTERFACE_MEMBER);
2159	0	} else if (jj_2_19(2147483647)) {
2160	0	list = unmodifiedVariableDeclaration(mods, DeclType.INTERFACE_MEMBER);
2161		} else {
2162	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2163	0	case SEMICOLON:
2164	0	jj_consume_token(SEMICOLON);
2165	0	break;
2166	0	default:
2167	0	jj_la1[47] = jj_gen;
2168	0	jj_consume_token(-1);
2169	0	throw new ParseException();
2170		}
2171		}
2172		}
2173	0	if (node != null) { list.add(node); }
2174	0	{if (true) return list;}
2175		} catch (ParseException pe) {
2176	0	_throwParseException(pe, "Invalid interface member declaration");
2177		}
2178	0	throw new Error("Missing return statement in function");
2179		}
2180
2181		// Productions for Enums ////////////////////////////////////////////////////////
2182
2183		/**
2184		* Parses an enum declaration
2185		* @see koala.dynamicjava.tree.EnumDeclaration
2186		*/
2187	0	final public EnumDeclaration enumDeclaration(DeclType level) throws ParseException {
2188	0	ModifierSet mods; EnumDeclaration decl;
2189	0	try {
2190	0	mods = optionalModifiers();
2191	0	decl = unmodifiedEnumDeclaration(mods, level);
2192	0	{if (true) return decl;}
2193		} catch (ParseException pe) {
2194	0	_throwParseException(pe, "Invalid enum declaration");
2195		}
2196	0	throw new Error("Missing return statement in function");
2197		}
2198
2199	0	final public EnumDeclaration unmodifiedEnumDeclaration(ModifierSet mods, DeclType level) throws ParseException {
2200	0	Token id;
2201	0	List<? extends ReferenceTypeName> impl = null;
2202	0	EnumDeclaration.EnumBody body;
2203	0	jj_consume_token(ENUM);
2204	0	id = jj_consume_token(IDENTIFIER);
2205	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2206	0	case IMPLEMENTS:
2207	0	jj_consume_token(IMPLEMENTS);
2208	0	impl = ReferenceTypeNameList();
2209	0	break;
2210	0	default:
2211	0	jj_la1[48] = jj_gen;
2212		;
2213		}
2214	0	jj_consume_token(LBRACE);
2215	0	body = enumBody();
2216	0	jj_consume_token(RBRACE);
2217	0	switch (level) {
2218	0	case TOP: checkModifiers(mods, Modifier.PUBLIC, Modifier.STRICT); break;
2219	0	case CLASS_MEMBER: checkModifiers(mods, Modifier.PUBLIC, Modifier.PROTECTED, Modifier.PRIVATE,
2220	0	Modifier.STATIC, Modifier.STRICT); break;
2221	0	case INTERFACE_MEMBER: checkModifiers(mods, Modifier.PUBLIC, Modifier.STATIC, Modifier.STRICT); break;
2222	0	case LOCAL: checkModifiers(mods, Modifier.STRICT); break;
2223	0	case REPL: checkModifiers(mods, Modifier.PUBLIC, Modifier.STRICT); break;
2224		}
2225	0	{if (true) return new EnumDeclaration(mods, id.image, impl, body, _range(mods, token));}
2226	0	throw new Error("Missing return statement in function");
2227		}
2228
2229		/**
2230		* Parses the body of an enum
2231		* @see koala.dynamicjava.tree.Node
2232		*/
2233	0	final public EnumDeclaration.EnumBody enumBody() throws ParseException {
2234	0	List<EnumDeclaration.EnumConstant> consts = null;
2235	0	List<Node> decls = new LinkedList<Node>();
2236	0	List<Node> ns;
2237	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2238	0	case ABSTRACT:
2239	0	case FINAL:
2240	0	case NATIVE:
2241	0	case PRIVATE:
2242	0	case PROTECTED:
2243	0	case PUBLIC:
2244	0	case STATIC:
2245	0	case STRICTFP:
2246	0	case SYNCHRONIZED:
2247	0	case TRANSIENT:
2248	0	case VOLATILE:
2249	0	case IDENTIFIER:
2250	0	case 132:
2251	0	consts = enumConstants();
2252	0	break;
2253	0	default:
2254	0	jj_la1[49] = jj_gen;
2255		;
2256		}
2257	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2258	0	case SEMICOLON:
2259	0	jj_consume_token(SEMICOLON);
2260	0	label_18:
2261		while (true) {
2262	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2263	0	case ABSTRACT:
2264	0	case BOOLEAN:
2265	0	case BYTE:
2266	0	case CHAR:
2267	0	case CLASS:
2268	0	case DOUBLE:
2269	0	case ENUM:
2270	0	case FINAL:
2271	0	case FLOAT:
2272	0	case INT:
2273	0	case INTERFACE:
2274	0	case LONG:
2275	0	case NATIVE:
2276	0	case PRIVATE:
2277	0	case PROTECTED:
2278	0	case PUBLIC:
2279	0	case SHORT:
2280	0	case STATIC:
2281	0	case STRICTFP:
2282	0	case SYNCHRONIZED:
2283	0	case TRANSIENT:
2284	0	case VOID:
2285	0	case VOLATILE:
2286	0	case IDENTIFIER:
2287	0	case LBRACE:
2288	0	case SEMICOLON:
2289	0	case LESS:
2290	0	case 132:
2291		;
2292	0	break;
2293	0	default:
2294	0	jj_la1[50] = jj_gen;
2295	0	break label_18;
2296		}
2297	0	ns = classBodyDeclaration();
2298	0	decls.addAll(ns);
2299		}
2300	0	break;
2301	0	default:
2302	0	jj_la1[51] = jj_gen;
2303		;
2304		}
2305	0	{if (true) return new EnumDeclaration.EnumBody((consts==null) ? new LinkedList<EnumDeclaration.EnumConstant>() : consts,
2306		decls);}
2307	0	throw new Error("Missing return statement in function");
2308		}
2309
2310	0	final public List<EnumDeclaration.EnumConstant> enumConstants() throws ParseException {
2311	0	List<EnumDeclaration.EnumConstant> list = new LinkedList<EnumDeclaration.EnumConstant>();
2312	0	EnumDeclaration.EnumConstant c;
2313	0	c = enumConstant();
2314	0	list.add(c);
2315	0	label_19:
2316		while (true) {
2317	0	if (jj_2_20(3)) {
2318		;
2319		} else {
2320	0	break label_19;
2321		}
2322	0	jj_consume_token(COMMA);
2323	0	c = enumConstant();
2324	0	list.add(c);
2325		}
2326	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2327	0	case COMMA:
2328	0	jj_consume_token(COMMA);
2329	0	break;
2330	0	default:
2331	0	jj_la1[52] = jj_gen;
2332		;
2333		}
2334	0	{if (true) return list;}
2335	0	throw new Error("Missing return statement in function");
2336		}
2337
2338	0	final public EnumDeclaration.EnumConstant enumConstant() throws ParseException {
2339	0	ModifierSet mods;
2340	0	Token id;
2341	0	List<Expression> args = null;
2342	0	List<Node> body = null;
2343	0	mods = optionalModifiers();
2344	0	id = jj_consume_token(IDENTIFIER);
2345	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2346	0	case LPAREN:
2347	0	args = arguments();
2348	0	break;
2349	0	default:
2350	0	jj_la1[53] = jj_gen;
2351		;
2352		}
2353	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2354	0	case LBRACE:
2355	0	body = classBody();
2356	0	break;
2357	0	default:
2358	0	jj_la1[54] = jj_gen;
2359		;
2360		}
2361	0	checkModifiers(mods); // can only have annotations
2362	0	{if (true) return new EnumDeclaration.EnumConstant(mods, id.image, args, body, _range(mods, token));}
2363	0	throw new Error("Missing return statement in function");
2364		}
2365
2366		// Productions for Arrays ////////////////////////////////////////////////////////
2367
2368		/**
2369		* Parses an array initializer
2370		* @see koala.dynamicjava.tree.ArrayInitializer
2371		*/
2372	13	final public ArrayInitializer arrayInitializer() throws ParseException {
2373	13	Expression init;
2374	13	Token t = null, b, e;
2375	13	List<Expression> list = new LinkedList<Expression>();
2376	13	b = jj_consume_token(LBRACE);
2377	13	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2378	0	case BOOLEAN:
2379	0	case BYTE:
2380	0	case CHAR:
2381	0	case DOUBLE:
2382	0	case FALSE:
2383	0	case FLOAT:
2384	0	case INT:
2385	0	case LONG:
2386	0	case NEW:
2387	0	case NULL:
2388	0	case SHORT:
2389	0	case SUPER:
2390	0	case THIS:
2391	0	case TRUE:
2392	0	case VOID:
2393	6	case INTEGER_LITERAL:
2394	0	case LONG_LITERAL:
2395	0	case FLOAT_LITERAL:
2396	0	case DOUBLE_LITERAL:
2397	0	case CHARACTER_LITERAL:
2398	7	case STRING_LITERAL:
2399	0	case IDENTIFIER:
2400	0	case LPAREN:
2401	0	case LBRACE:
2402	0	case LESS:
2403	0	case BANG:
2404	0	case TILDE:
2405	0	case INCREMENT:
2406	0	case DECREMENT:
2407	0	case PLUS:
2408	0	case MINUS:
2409	13	init = variableInitializer();
2410	13	list.add(init);
2411	13	label_20:
2412		while (true) {
2413	41	if (jj_2_21(2)) {
2414		;
2415		} else {
2416	13	break label_20;
2417		}
2418	28	jj_consume_token(COMMA);
2419	28	init = variableInitializer();
2420	28	list.add(init);
2421		}
2422	13	break;
2423	0	default:
2424	0	jj_la1[55] = jj_gen;
2425		;
2426		}
2427	13	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2428	0	case COMMA:
2429	0	t = jj_consume_token(COMMA);
2430	0	break;
2431	13	default:
2432	13	jj_la1[56] = jj_gen;
2433		;
2434		}
2435	13	e = jj_consume_token(RBRACE);
2436	13	{if (true) return new ArrayInitializer(list, _range(b, e));}
2437	0	throw new Error("Missing return statement in function");
2438		}
2439
2440		/**
2441		* Parses a variable initializer (ie. an expression or an array initializer)
2442		* @see koala.dynamicjava.tree.Expression
2443		*/
2444	683	final public Expression variableInitializer() throws ParseException {
2445	683	Expression exp;
2446	683	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2447	0	case LBRACE:
2448	0	exp = arrayInitializer();
2449	0	break;
2450	1	case BOOLEAN:
2451	1	case BYTE:
2452	1	case CHAR:
2453	1	case DOUBLE:
2454	48	case FALSE:
2455	0	case FLOAT:
2456	2	case INT:
2457	1	case LONG:
2458	190	case NEW:
2459	4	case NULL:
2460	1	case SHORT:
2461	0	case SUPER:
2462	0	case THIS:
2463	1	case TRUE:
2464	1	case VOID:
2465	196	case INTEGER_LITERAL:
2466	2	case LONG_LITERAL:
2467	8	case FLOAT_LITERAL:
2468	5	case DOUBLE_LITERAL:
2469	7	case CHARACTER_LITERAL:
2470	65	case STRING_LITERAL:
2471	131	case IDENTIFIER:
2472	10	case LPAREN:
2473	0	case LESS:
2474	0	case BANG:
2475	0	case TILDE:
2476	2	case INCREMENT:
2477	2	case DECREMENT:
2478	0	case PLUS:
2479	3	case MINUS:
2480	683	exp = expression();
2481	683	break;
2482	0	default:
2483	0	jj_la1[57] = jj_gen;
2484	0	jj_consume_token(-1);
2485	0	throw new ParseException();
2486		}
2487	683	{if (true) return exp;}
2488	0	throw new Error("Missing return statement in function");
2489		}
2490
2491		// Productions for Blocks And Statements ////////////////////////////////////////////
2492
2493		/**
2494		* Parses a block
2495		* @see koala.dynamicjava.tree.BlockStatement
2496		*/
2497	487	final public BlockStatement block() throws ParseException {
2498	487	Token p1;
2499	487	Token p2;
2500	487	List<Node> nodes;
2501	487	List<Node> list = new LinkedList<Node>();
2502	487	try {
2503	487	p1 = jj_consume_token(LBRACE);
2504	487	label_21:
2505		while (true) {
2506	1215	if (jj_2_22(1)) {
2507		;
2508		} else {
2509	487	break label_21;
2510		}
2511	728	nodes = blockStatement();
2512	728	list.addAll(nodes);
2513		}
2514	487	p2 = jj_consume_token(RBRACE);
2515	487	{if (true) return new BlockStatement(list, _range(p1, p2));}
2516		} catch (ParseException pe) {
2517	0	_throwParseException(pe,"Invalid block statement");
2518		}
2519	0	throw new Error("Missing return statement in function");
2520		}
2521
2522		/**
2523		* Parses one block statement.
2524		* @return a list of node because one variable declaration can
2525		* contain multiple declarations.
2526		* @see koala.dynamicjava.tree.Node
2527		*/
2528	801	final public List<Node> blockStatement() throws ParseException {
2529	801	ModifierSet mods; Node node = null; List<Node> nodes = null;
2530	801	try {
2531	801	if (jj_2_26(2)) {
2532	443	node = keywordStatement(true);
2533	358	} else if (jj_2_27(2)) {
2534	0	mods = modifiers();
2535	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2536	0	case CLASS:
2537	0	case ENUM:
2538	0	case INTERFACE:
2539	0	case 132:
2540	0	node = unmodifiedTypeDeclaration(mods, DeclType.LOCAL);
2541	0	break;
2542	0	default:
2543	0	jj_la1[58] = jj_gen;
2544	0	if (jj_2_23(2147483647)) {
2545	0	nodes = unmodifiedVariableDeclaration(mods, DeclType.LOCAL);
2546		} else {
2547	0	jj_consume_token(-1);
2548	0	throw new ParseException();
2549		}
2550		}
2551	358	} else if (jj_2_28(1)) {
2552	358	mods = noModifiers();
2553	358	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2554	0	case CLASS:
2555	0	case ENUM:
2556	0	case INTERFACE:
2557	0	case 132:
2558	0	node = unmodifiedTypeDeclaration(mods, DeclType.LOCAL);
2559	0	break;
2560	358	default:
2561	358	jj_la1[59] = jj_gen;
2562	358	if (jj_2_24(2147483647)) {
2563	109	nodes = unmodifiedVariableDeclaration(mods, DeclType.LOCAL);
2564	249	} else if (jj_2_25(1)) {
2565	249	node = nonKeywordStatement(true);
2566		} else {
2567	0	jj_consume_token(-1);
2568	0	throw new ParseException();
2569		}
2570		}
2571		} else {
2572	0	jj_consume_token(-1);
2573	0	throw new ParseException();
2574		}
2575	801	{if (true) return (node != null) ? Collections.singletonList(node) : nodes;}
2576		} catch (ParseException pe) {
2577	0	_throwParseException(pe, "Invalid block statement");
2578		}
2579	0	throw new Error("Missing return statement in function");
2580		}
2581
2582	339	final public Node statement(boolean strictExpressions) throws ParseException {
2583	339	Node node;
2584	339	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2585	0	case ASSERT:
2586	0	case BREAK:
2587	0	case CONTINUE:
2588	0	case DO:
2589	0	case FOR:
2590	2	case IF:
2591	4	case RETURN:
2592	0	case SWITCH:
2593	0	case SYNCHRONIZED:
2594	183	case THROW:
2595	0	case TRY:
2596	0	case WHILE:
2597	139	case LBRACE:
2598	0	case SEMICOLON:
2599	328	node = keywordStatement(strictExpressions);
2600	328	{if (true) return node;}
2601	0	break;
2602	11	default:
2603	11	jj_la1[60] = jj_gen;
2604	11	if (jj_2_29(1)) {
2605	11	node = nonKeywordStatement(strictExpressions);
2606	11	{if (true) return node;}
2607		} else {
2608	0	jj_consume_token(-1);
2609	0	throw new ParseException();
2610		}
2611		}
2612	0	throw new Error("Missing return statement in function");
2613		}
2614
2615		/** A statement that starts with a keyword or special delimiter. */
2616	817	final public Node keywordStatement(boolean strictExpressions) throws ParseException {
2617	817	Node node;
2618	817	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2619	141	case LBRACE:
2620	141	node = block();
2621	141	break;
2622	13	case SEMICOLON:
2623	13	node = emptyStatement();
2624	13	break;
2625	202	case IF:
2626	202	node = ifStatement();
2627	202	break;
2628	0	case ASSERT:
2629	0	node = assertStatement();
2630	0	break;
2631	4	case WHILE:
2632	4	node = whileStatement();
2633	4	break;
2634	4	case DO:
2635	4	node = doStatement();
2636	4	break;
2637	1	case SWITCH:
2638	1	node = switchStatement();
2639	1	break;
2640	119	case FOR:
2641	119	node = forStatement();
2642	119	break;
2643	3	case BREAK:
2644	3	node = breakStatement();
2645	3	break;
2646	1	case CONTINUE:
2647	1	node = continueStatement();
2648	1	break;
2649	141	case RETURN:
2650	141	node = returnStatement();
2651	141	break;
2652	186	case THROW:
2653	186	node = throwStatement();
2654	186	break;
2655	1	case SYNCHRONIZED:
2656	1	node = synchronizedStatement();
2657	1	break;
2658	1	case TRY:
2659	1	node = tryStatement();
2660	1	break;
2661	0	default:
2662	0	jj_la1[61] = jj_gen;
2663	0	jj_consume_token(-1);
2664	0	throw new ParseException();
2665		}
2666	817	{if (true) return node;}
2667	0	throw new Error("Missing return statement in function");
2668		}
2669
2670		/** A statement that does not begin with a keyword (and thus may need special lookahead treatment). */
2671	483	final public Node nonKeywordStatement(boolean strictExpressions) throws ParseException {
2672	483	Node node;
2673	483	if (jj_2_30(2)) {
2674	1	node = labeledStatement();
2675	1	{if (true) return node;}
2676	482	} else if (jj_2_31(1)) {
2677	482	node = expressionStatement(strictExpressions);
2678	482	{if (true) return node;}
2679		} else {
2680	0	jj_consume_token(-1);
2681	0	throw new ParseException();
2682		}
2683	0	throw new Error("Missing return statement in function");
2684		}
2685
2686		/**
2687		* Parses a labeled statement
2688		* @see koala.dynamicjava.tree.ContinueTarget
2689		* @see koala.dynamicjava.tree.LabeledStatement
2690		*/
2691	1	final public Statement labeledStatement() throws ParseException {
2692	1	Token id;
2693	1	Node node;
2694	1	id = jj_consume_token(IDENTIFIER);
2695	1	jj_consume_token(COLON);
2696	1	node = statement(true);
2697	1	if (node instanceof ContinueTarget) {
2698	0	((ContinueTarget)node).addLabel(id.image);
2699	0	{if (true) return (Statement)node;}
2700		} else {
2701	1	{if (true) return new LabeledStatement(id.image, node, _range(id, node));}
2702		}
2703	0	throw new Error("Missing return statement in function");
2704		}
2705
2706		/**
2707		* Parses an empty statement
2708		* @see koala.dynamicjava.tree.EmptyStatement
2709		*/
2710	13	final public EmptyStatement emptyStatement() throws ParseException {
2711	13	Token t;
2712	13	t = jj_consume_token(SEMICOLON);
2713	13	{if (true) return new EmptyStatement(_range(t, t));}
2714	0	throw new Error("Missing return statement in function");
2715		}
2716
2717		/**
2718		* Parses an if statement
2719		* @see koala.dynamicjava.tree.IfThenStatement
2720		* @see koala.dynamicjava.tree.IfThenElseStatement
2721		*/
2722	202	final public Statement ifStatement() throws ParseException {
2723	202	Token t;
2724	202	Expression exp;
2725	202	Node stat1;
2726	202	Node stat2 = null;
2727	202	try {
2728	202	t = jj_consume_token(IF);
2729	202	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2730	202	case LPAREN:
2731	202	jj_consume_token(LPAREN);
2732	202	break;
2733	0	default:
2734	0	jj_la1[62] = jj_gen;
2735	0	_errorChar('(');
2736		}
2737	202	exp = expression();
2738	202	jj_consume_token(RPAREN);
2739	202	stat1 = statement(true);
2740	202	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2741	9	case ELSE:
2742	9	jj_consume_token(ELSE);
2743	9	stat2 = statement(true);
2744	9	break;
2745	193	default:
2746	193	jj_la1[63] = jj_gen;
2747		;
2748		}
2749	202	if (stat2 == null) {
2750	193	{if (true) return new IfThenStatement(exp, stat1, _range(t, stat1));}
2751		} else {
2752	9	{if (true) return new IfThenElseStatement(exp, stat1, stat2, _range(t, stat2));}
2753		}
2754		} catch (ParseException pe) {
2755	0	_throwParseException(pe,"Invalid if statement");
2756		}
2757	0	throw new Error("Missing return statement in function");
2758		}
2759
2760		/**
2761		* Parses an assert statement
2762		* @see koala.dynamicjava.tree.AssertStatement
2763		*/
2764	0	final public AssertStatement assertStatement() throws ParseException {
2765	0	Token t, t2;
2766	0	Expression exp, falseString = null;
2767	0	try {
2768	0	t = jj_consume_token(ASSERT);
2769	0	exp = expression();
2770	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2771	0	case COLON:
2772	0	jj_consume_token(COLON);
2773	0	falseString = expression();
2774	0	break;
2775	0	default:
2776	0	jj_la1[64] = jj_gen;
2777		;
2778		}
2779	0	t2 = optionalSemicolon();
2780	0	{if (true) return new AssertStatement(exp, falseString, _range(t, t2));}
2781		} catch (ParseException pe) {
2782	0	_throwParseException(pe,"Invalid assert statement");
2783		}
2784	0	throw new Error("Missing return statement in function");
2785		}
2786
2787		/**
2788		* Parses a while statement
2789		* @see koala.dynamicjava.tree.WhileStatement
2790		*/
2791	4	final public WhileStatement whileStatement() throws ParseException {
2792	4	Token t;
2793	4	Expression exp;
2794	4	Node stat;
2795	4	try {
2796	4	t = jj_consume_token(WHILE);
2797	4	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2798	4	case LPAREN:
2799	4	jj_consume_token(LPAREN);
2800	4	break;
2801	0	default:
2802	0	jj_la1[65] = jj_gen;
2803	0	_errorChar('(');
2804		}
2805	4	exp = expression();
2806	4	jj_consume_token(RPAREN);
2807	4	stat = statement(true);
2808	4	{if (true) return new WhileStatement(exp, stat, _range(t, stat));}
2809		} catch (ParseException pe) {
2810	0	_throwParseException(pe,"Invalid while statement");
2811		}
2812	0	throw new Error("Missing return statement in function");
2813		}
2814
2815		/**
2816		* Parses a do statement
2817		* @see koala.dynamicjava.tree.DoStatement
2818		*/
2819	4	final public DoStatement doStatement() throws ParseException {
2820	4	Token t1, t2;
2821	4	Expression exp;
2822	4	Node stat;
2823	4	try {
2824	4	t1 = jj_consume_token(DO);
2825	4	stat = statement(true);
2826	4	jj_consume_token(WHILE);
2827	4	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2828	4	case LPAREN:
2829	4	jj_consume_token(LPAREN);
2830	4	break;
2831	0	default:
2832	0	jj_la1[66] = jj_gen;
2833	0	_errorChar('(');
2834		}
2835	4	exp = expression();
2836	4	jj_consume_token(RPAREN);
2837	4	t2 = optionalSemicolon();
2838	4	{if (true) return new DoStatement(exp, stat, _range(t1, t2));}
2839		} catch (ParseException pe) {
2840	0	_throwParseException(pe,"Invalid do statement");
2841		}
2842	0	throw new Error("Missing return statement in function");
2843		}
2844
2845		/**
2846		* Parses a switch statement
2847		* @see koala.dynamicjava.tree.SwitchStatement
2848		*/
2849	1	final public SwitchStatement switchStatement() throws ParseException {
2850	1	Token b, e;
2851	1	Expression sel;
2852	1	SwitchBlock sb;
2853	1	List<SwitchBlock> cases = new LinkedList<SwitchBlock>();
2854	1	try {
2855	1	b = jj_consume_token(SWITCH);
2856	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2857	1	case LPAREN:
2858	1	jj_consume_token(LPAREN);
2859	1	break;
2860	0	default:
2861	0	jj_la1[67] = jj_gen;
2862	0	_errorChar('(');
2863		}
2864	1	sel = expression();
2865	1	jj_consume_token(RPAREN);
2866	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2867	1	case LBRACE:
2868	1	jj_consume_token(LBRACE);
2869	1	break;
2870	0	default:
2871	0	jj_la1[68] = jj_gen;
2872	0	_errorChar('{');
2873		}
2874	1	label_22:
2875		while (true) {
2876	4	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2877	3	case CASE:
2878	0	case _DEFAULT:
2879		;
2880	3	break;
2881	1	default:
2882	1	jj_la1[69] = jj_gen;
2883	1	break label_22;
2884		}
2885	3	sb = switchBlock();
2886	3	cases.add(sb);
2887		}
2888	1	e = jj_consume_token(RBRACE);
2889	1	{if (true) return new SwitchStatement(sel, cases, _range(b, e));}
2890		} catch (ParseException pe) {
2891	0	_throwParseException(pe,"Invalid switch statement");
2892		}
2893	0	throw new Error("Missing return statement in function");
2894		}
2895
2896	3	final public SwitchBlock switchBlock() throws ParseException {
2897	3	Token t, t2;
2898	3	Expression val = null;
2899	3	List<Node> stat;
2900	3	List<Node> allStats = new LinkedList<Node>();
2901	3	SourceInfo si;
2902	3	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2903	3	case CASE:
2904	3	t = jj_consume_token(CASE);
2905	3	val = expression();
2906	3	break;
2907	0	case _DEFAULT:
2908	0	t = jj_consume_token(_DEFAULT);
2909	0	break;
2910	0	default:
2911	0	jj_la1[70] = jj_gen;
2912	0	jj_consume_token(-1);
2913	0	throw new ParseException();
2914		}
2915	3	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2916	3	case COLON:
2917	3	t2 = jj_consume_token(COLON);
2918	3	si = _range(t, t2);
2919	3	break;
2920	0	default:
2921	0	jj_la1[71] = jj_gen;
2922	0	_errorChar(':');
2923	0	si = _range(t, t);
2924		}
2925	3	label_23:
2926		while (true) {
2927	7	if (jj_2_32(1)) {
2928		;
2929		} else {
2930	3	break label_23;
2931		}
2932	4	stat = blockStatement();
2933	4	allStats.addAll(stat);
2934	4	if (stat.size() > 0)
2935	4	si = _range(si, stat.get(stat.size()-1).getSourceInfo());
2936		}
2937	3	{if (true) return new SwitchBlock(val, (allStats.isEmpty()) ? null: allStats, si);}
2938	0	throw new Error("Missing return statement in function");
2939		}
2940
2941		/**
2942		* Parses a for statement (with standard or foreach syntax)
2943		* @see koala.dynamicjava.tree.ForStatement
2944		* Modified by Adam Wulf and David Peters
2945		* March 2004: Dr. Java team.
2946		* @see koala.dynamicjava.tree.ForSlashEachStatement
2947		* @see koala.dynamicjava.tree.ForEachStatement
2948		*/
2949	119	final public ForSlashEachStatement forStatement() throws ParseException {
2950	119	Token start;
2951	119	ModifierSet mods;
2952	119	FormalParameter param = null;
2953	119	List<Node> init = null;
2954	119	Expression exp = null;
2955	119	List<Node> update = null;
2956	119	Node stmt;
2957	119	try {
2958	119	start = jj_consume_token(FOR);
2959	119	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2960	119	case LPAREN:
2961	119	jj_consume_token(LPAREN);
2962	119	break;
2963	0	default:
2964	0	jj_la1[72] = jj_gen;
2965	0	_errorChar('(');
2966		}
2967	119	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2968	0	case ABSTRACT:
2969	0	case FINAL:
2970	0	case NATIVE:
2971	0	case PRIVATE:
2972	0	case PROTECTED:
2973	0	case PUBLIC:
2974	0	case STATIC:
2975	0	case STRICTFP:
2976	0	case SYNCHRONIZED:
2977	0	case TRANSIENT:
2978	0	case VOLATILE:
2979	0	case 132:
2980	0	mods = modifiers();
2981	0	if (jj_2_33(2147483647)) {
2982	0	param = forEachParameter(mods);
2983	0	jj_consume_token(COLON);
2984	0	exp = expression();
2985	0	} else if (jj_2_34(2147483647)) {
2986	0	init = unmodifiedVariableDeclaration(mods, DeclType.LOCAL);
2987		} else {
2988	0	jj_consume_token(-1);
2989	0	throw new ParseException();
2990		}
2991	0	break;
2992	0	case BOOLEAN:
2993	0	case BYTE:
2994	0	case CHAR:
2995	0	case DOUBLE:
2996	0	case FALSE:
2997	0	case FLOAT:
2998	113	case INT:
2999	0	case LONG:
3000	0	case NEW:
3001	0	case NULL:
3002	0	case SHORT:
3003	0	case SUPER:
3004	0	case THIS:
3005	0	case TRUE:
3006	0	case VOID:
3007	0	case INTEGER_LITERAL:
3008	0	case LONG_LITERAL:
3009	0	case FLOAT_LITERAL:
3010	0	case DOUBLE_LITERAL:
3011	0	case CHARACTER_LITERAL:
3012	0	case STRING_LITERAL:
3013	6	case IDENTIFIER:
3014	0	case LPAREN:
3015	0	case SEMICOLON:
3016	0	case LESS:
3017	0	case INCREMENT:
3018	0	case DECREMENT:
3019	119	mods = noModifiers();
3020	119	if (jj_2_35(2147483647)) {
3021	7	param = forEachParameter(mods);
3022	7	jj_consume_token(COLON);
3023	7	exp = expression();
3024	112	} else if (jj_2_36(2147483647)) {
3025	112	init = unmodifiedVariableDeclaration(mods, DeclType.LOCAL);
3026		} else {
3027	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3028	0	case BOOLEAN:
3029	0	case BYTE:
3030	0	case CHAR:
3031	0	case DOUBLE:
3032	0	case FALSE:
3033	0	case FLOAT:
3034	0	case INT:
3035	0	case LONG:
3036	0	case NEW:
3037	0	case NULL:
3038	0	case SHORT:
3039	0	case SUPER:
3040	0	case THIS:
3041	0	case TRUE:
3042	0	case VOID:
3043	0	case INTEGER_LITERAL:
3044	0	case LONG_LITERAL:
3045	0	case FLOAT_LITERAL:
3046	0	case DOUBLE_LITERAL:
3047	0	case CHARACTER_LITERAL:
3048	0	case STRING_LITERAL:
3049	0	case IDENTIFIER:
3050	0	case LPAREN:
3051	0	case LESS:
3052	0	case INCREMENT:
3053	0	case DECREMENT:
3054	0	init = expressionStatementList();
3055	0	jj_consume_token(SEMICOLON);
3056	0	break;
3057	0	case SEMICOLON:
3058	0	jj_consume_token(SEMICOLON);
3059	0	break;
3060	0	default:
3061	0	jj_la1[73] = jj_gen;
3062	0	jj_consume_token(-1);
3063	0	throw new ParseException();
3064		}
3065		}
3066	119	break;
3067	0	default:
3068	0	jj_la1[74] = jj_gen;
3069	0	jj_consume_token(-1);
3070	0	throw new ParseException();
3071		}
3072	119	if (param == null) {
3073	112	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3074	0	case BOOLEAN:
3075	0	case BYTE:
3076	0	case CHAR:
3077	0	case DOUBLE:
3078	0	case FALSE:
3079	0	case FLOAT:
3080	0	case INT:
3081	0	case LONG:
3082	0	case NEW:
3083	0	case NULL:
3084	0	case SHORT:
3085	0	case SUPER:
3086	0	case THIS:
3087	0	case TRUE:
3088	0	case VOID:
3089	0	case INTEGER_LITERAL:
3090	0	case LONG_LITERAL:
3091	0	case FLOAT_LITERAL:
3092	0	case DOUBLE_LITERAL:
3093	0	case CHARACTER_LITERAL:
3094	0	case STRING_LITERAL:
3095	111	case IDENTIFIER:
3096	1	case LPAREN:
3097	0	case LESS:
3098	0	case BANG:
3099	0	case TILDE:
3100	0	case INCREMENT:
3101	0	case DECREMENT:
3102	0	case PLUS:
3103	0	case MINUS:
3104	112	exp = expression();
3105	112	break;
3106	0	default:
3107	0	jj_la1[75] = jj_gen;
3108		;
3109		}
3110	112	jj_consume_token(SEMICOLON);
3111	112	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3112	0	case BOOLEAN:
3113	0	case BYTE:
3114	0	case CHAR:
3115	0	case DOUBLE:
3116	0	case FALSE:
3117	0	case FLOAT:
3118	0	case INT:
3119	0	case LONG:
3120	0	case NEW:
3121	0	case NULL:
3122	0	case SHORT:
3123	0	case SUPER:
3124	0	case THIS:
3125	0	case TRUE:
3126	0	case VOID:
3127	0	case INTEGER_LITERAL:
3128	0	case LONG_LITERAL:
3129	0	case FLOAT_LITERAL:
3130	0	case DOUBLE_LITERAL:
3131	0	case CHARACTER_LITERAL:
3132	0	case STRING_LITERAL:
3133	111	case IDENTIFIER:
3134	1	case LPAREN:
3135	0	case LESS:
3136	0	case INCREMENT:
3137	0	case DECREMENT:
3138	112	update = expressionStatementList();
3139	112	break;
3140	0	default:
3141	0	jj_la1[76] = jj_gen;
3142		;
3143		}
3144		} else {
3145		;
3146		}
3147	119	jj_consume_token(RPAREN);
3148	119	stmt = statement(true);
3149	119	if (param == null) {
3150	112	{if (true) return new ForStatement(init, exp, update, stmt, _range(start, stmt));}
3151		}
3152		else {
3153	7	{if (true) return new ForEachStatement(param, exp, stmt, _range(start, stmt));}
3154		}
3155		} catch (ParseException pe) {
3156	0	_throwParseException(pe,"Invalid for statement");
3157		}
3158	0	throw new Error("Missing return statement in function");
3159		}
3160
3161		/**
3162		* A for-each parameter, which is more restricted than a general formal parameter (no additional array
3163		* brackets, and no varargs)
3164		*/
3165	7	final public FormalParameter forEachParameter(ModifierSet mods) throws ParseException {
3166	7	TypeName typ; Token id; Expression exp;
3167	7	typ = type();
3168	7	id = jj_consume_token(IDENTIFIER);
3169	7	checkModifiers(mods, Modifier.FINAL);
3170	7	{if (true) return new FormalParameter(mods, typ, id.image, _range(mods, id));}
3171	0	throw new Error("Missing return statement in function");
3172		}
3173
3174		/**
3175		* Parses a comma separated list of strict ExpressionStatements
3176		*/
3177	112	final public List<Node> expressionStatementList() throws ParseException {
3178	112	List<Node> list = new LinkedList<Node>(); Expression exp;
3179	112	exp = statementExpression();
3180	112	list.add(new ExpressionStatement(exp, true, exp.getSourceInfo()));
3181	112	label_24:
3182		while (true) {
3183	112	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3184	0	case COMMA:
3185		;
3186	0	break;
3187	112	default:
3188	112	jj_la1[77] = jj_gen;
3189	112	break label_24;
3190		}
3191	0	jj_consume_token(COMMA);
3192	0	exp = statementExpression();
3193	0	list.add(new ExpressionStatement(exp, true, exp.getSourceInfo()));
3194		}
3195	112	{if (true) return list;}
3196	0	throw new Error("Missing return statement in function");
3197		}
3198
3199		/**
3200		* Parses a break statement
3201		* @see koala.dynamicjava.tree.BreakStatement
3202		*/
3203	3	final public BreakStatement breakStatement() throws ParseException {
3204	3	Token b, e;
3205	3	Token id = null;
3206	3	try {
3207	3	b = jj_consume_token(BREAK);
3208	3	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3209	0	case IDENTIFIER:
3210	0	id = jj_consume_token(IDENTIFIER);
3211	0	break;
3212	3	default:
3213	3	jj_la1[78] = jj_gen;
3214		;
3215		}
3216	3	e = jj_consume_token(SEMICOLON);
3217	3	{if (true) return new BreakStatement((id != null) ? id.image : null, _range(b, e));}
3218		} catch (ParseException pe) {
3219	0	_throwParseException(pe,"Invalid break statement");
3220		}
3221	0	throw new Error("Missing return statement in function");
3222		}
3223
3224		/**
3225		* Parses a continue statement
3226		* @see koala.dynamicjava.tree.ContinueStatement
3227		*/
3228	1	final public ContinueStatement continueStatement() throws ParseException {
3229	1	Token b, e;
3230	1	Token id = null;
3231	1	try {
3232	1	b = jj_consume_token(CONTINUE);
3233	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3234	0	case IDENTIFIER:
3235	0	id = jj_consume_token(IDENTIFIER);
3236	0	break;
3237	1	default:
3238	1	jj_la1[79] = jj_gen;
3239		;
3240		}
3241	1	e = jj_consume_token(SEMICOLON);
3242	1	{if (true) return new ContinueStatement((id != null) ? id.image : null, _range(b, e));}
3243		} catch (ParseException pe) {
3244	0	_throwParseException(pe,"Invalid continue statement");
3245		}
3246	0	throw new Error("Missing return statement in function");
3247		}
3248
3249		/**
3250		* Parses a return statement
3251		* @see koala.dynamicjava.tree.ReturnStatement
3252		*/
3253	141	final public ReturnStatement returnStatement() throws ParseException {
3254	141	Token b, e;
3255	141	Expression exp = null;
3256	141	try {
3257	141	b = jj_consume_token(RETURN);
3258	141	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3259	0	case BOOLEAN:
3260	0	case BYTE:
3261	0	case CHAR:
3262	0	case DOUBLE:
3263	2	case FALSE:
3264	0	case FLOAT:
3265	0	case INT:
3266	0	case LONG:
3267	0	case NEW:
3268	0	case NULL:
3269	0	case SHORT:
3270	0	case SUPER:
3271	0	case THIS:
3272	3	case TRUE:
3273	0	case VOID:
3274	1	case INTEGER_LITERAL:
3275	0	case LONG_LITERAL:
3276	0	case FLOAT_LITERAL:
3277	0	case DOUBLE_LITERAL:
3278	0	case CHARACTER_LITERAL:
3279	0	case STRING_LITERAL:
3280	135	case IDENTIFIER:
3281	0	case LPAREN:
3282	0	case LESS:
3283	0	case BANG:
3284	0	case TILDE:
3285	0	case INCREMENT:
3286	0	case DECREMENT:
3287	0	case PLUS:
3288	0	case MINUS:
3289	141	exp = expression();
3290	141	break;
3291	0	default:
3292	0	jj_la1[80] = jj_gen;
3293		;
3294		}
3295	141	e = optionalSemicolon();
3296	141	{if (true) return new ReturnStatement(exp, _range(b, e));}
3297		} catch (ParseException pe) {
3298	0	_throwParseException(pe,"Invalid return statement");
3299		}
3300	0	throw new Error("Missing return statement in function");
3301		}
3302
3303		/**
3304		* Parses a throw statement
3305		* @see koala.dynamicjava.tree.ThrowStatement
3306		*/
3307	186	final public ThrowStatement throwStatement() throws ParseException {
3308	186	Token b, e;
3309	186	Expression exp;
3310	186	try {
3311	186	b = jj_consume_token(THROW);
3312	186	exp = expression();
3313	186	e = optionalSemicolon();
3314	186	{if (true) return new ThrowStatement(exp, _range(b, e));}
3315		} catch (ParseException pe) {
3316	0	_throwParseException(pe,"Invalid throw statement");
3317		}
3318	0	throw new Error("Missing return statement in function");
3319		}
3320
3321		/**
3322		* Parses a synchronized statement
3323		* @see koala.dynamicjava.tree.SynchronizedStatement
3324		*/
3325	1	final public SynchronizedStatement synchronizedStatement() throws ParseException {
3326	1	Token t;
3327	1	Expression exp;
3328	1	Node stmt;
3329	1	try {
3330	1	t = jj_consume_token(SYNCHRONIZED);
3331	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3332	1	case LPAREN:
3333	1	jj_consume_token(LPAREN);
3334	1	break;
3335	0	default:
3336	0	jj_la1[81] = jj_gen;
3337	0	_errorChar('(');
3338		}
3339	1	exp = expression();
3340	1	jj_consume_token(RPAREN);
3341	1	stmt = block();
3342	1	{if (true) return new SynchronizedStatement(exp, stmt, _range(t, stmt));}
3343		} catch (ParseException pe) {
3344	0	_throwParseException(pe,"Invalid synchronized statement");
3345		}
3346	0	throw new Error("Missing return statement in function");
3347		}
3348
3349		/**
3350		* Parses a try statement
3351		* @see koala.dynamicjava.tree.TryStatement
3352		*/
3353	1	final public TryStatement tryStatement() throws ParseException {
3354	1	Token t, u;
3355	1	Node tryBlock;
3356	1	Node catchBlock;
3357	1	List<CatchStatement> catches = new LinkedList<CatchStatement>();
3358	1	FormalParameter formal;
3359	1	Node finallyBlock = null;
3360	1	try {
3361	1	t = jj_consume_token(TRY);
3362	1	tryBlock = block();
3363	1	label_25:
3364		while (true) {
3365	2	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3366	1	case CATCH:
3367		;
3368	1	break;
3369	1	default:
3370	1	jj_la1[82] = jj_gen;
3371	1	break label_25;
3372		}
3373	1	u = jj_consume_token(CATCH);
3374	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3375	1	case LPAREN:
3376	1	jj_consume_token(LPAREN);
3377	1	break;
3378	0	default:
3379	0	jj_la1[83] = jj_gen;
3380	0	_errorChar('(');
3381		}
3382	1	formal = formalParameter();
3383	1	jj_consume_token(RPAREN);
3384	1	catchBlock = block();
3385	1	catches.add(new CatchStatement(formal, catchBlock, _range(u, catchBlock)));
3386		}
3387	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3388	0	case FINALLY:
3389	0	jj_consume_token(FINALLY);
3390	0	finallyBlock = block();
3391	0	break;
3392	1	default:
3393	1	jj_la1[84] = jj_gen;
3394		;
3395		}
3396	1	if (finallyBlock == null && catches.size() == 0) {
3397	0	{if (true) throw new ParseError(reader.getMessage("try.without.catch", null), _range(t, t));}
3398		}
3399	1	{if (true) return new TryStatement(tryBlock, catches, finallyBlock, _range(t, token));}
3400		} catch (ParseException pe) {
3401	0	_throwParseException(pe,"Invalid try statement");
3402		}
3403	0	throw new Error("Missing return statement in function");
3404		}
3405
3406		/**
3407		* Parses an ExpressionStatement; if strictExpression is true,
3408		* a trailing semicolon is required and only StatementExpressions
3409		* will be allowed.
3410		*/
3411	482	final public ExpressionStatement expressionStatement(boolean strictExpression) throws ParseException {
3412	482	Expression exp; Token t = null;
3413	482	lookaheadFlag = strictExpression;
3414	482	if (lookaheadFlag) {
3415	260	exp = statementExpression();
3416	260	t = jj_consume_token(SEMICOLON);
3417		} else {
3418	222	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3419	0	case BOOLEAN:
3420	0	case BYTE:
3421	0	case CHAR:
3422	0	case DOUBLE:
3423	0	case FALSE:
3424	0	case FLOAT:
3425	0	case INT:
3426	0	case LONG:
3427	5	case NEW:
3428	0	case NULL:
3429	0	case SHORT:
3430	1	case SUPER:
3431	0	case THIS:
3432	0	case TRUE:
3433	0	case VOID:
3434	1	case INTEGER_LITERAL:
3435	0	case LONG_LITERAL:
3436	0	case FLOAT_LITERAL:
3437	0	case DOUBLE_LITERAL:
3438	0	case CHARACTER_LITERAL:
3439	1	case STRING_LITERAL:
3440	204	case IDENTIFIER:
3441	9	case LPAREN:
3442	0	case LESS:
3443	0	case BANG:
3444	0	case TILDE:
3445	1	case INCREMENT:
3446	0	case DECREMENT:
3447	0	case PLUS:
3448	0	case MINUS:
3449	222	exp = expression();
3450	222	if (jj_2_37(2147483647)) {
3451
3452		} else {
3453	195	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3454	195	case SEMICOLON:
3455	195	t = jj_consume_token(SEMICOLON);
3456	195	break;
3457	0	default:
3458	0	jj_la1[85] = jj_gen;
3459	0	jj_consume_token(-1);
3460	0	throw new ParseException();
3461		}
3462		}
3463	222	break;
3464	0	default:
3465	0	jj_la1[86] = jj_gen;
3466	0	jj_consume_token(-1);
3467	0	throw new ParseException();
3468		}
3469		}
3470	482	{if (true) return new ExpressionStatement(exp, t != null, _range(exp, token));}
3471	0	throw new Error("Missing return statement in function");
3472		}
3473
3474	344	final public Token optionalSemicolon() throws ParseException {
3475	344	Token t;
3476	344	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3477	344	case SEMICOLON:
3478	344	t = jj_consume_token(SEMICOLON);
3479	344	break;
3480	0	default:
3481	0	jj_la1[87] = jj_gen;
3482	0	if (!opt.requireSemicolon()) {
3483	0	t = jj_consume_token(0);
3484		} else {
3485	0	jj_consume_token(-1);
3486	0	throw new ParseException();
3487		}
3488		}
3489	344	{if (true) return t;}
3490	0	throw new Error("Missing return statement in function");
3491		}
3492
3493		// Productions for Expressions /////////////////////////////////////////////////////////
3494
3495		/**
3496		* Parses an expression
3497		* @see koala.dynamicjava.tree.Expression
3498		*/
3499	2718	final public Expression expression() throws ParseException {
3500	2718	Expression exp;
3501	2718	exp = conditionalExpression();
3502	2718	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3503	53	case ASSIGN:
3504	0	case PLUS_ASSIGN:
3505	0	case MINUS_ASSIGN:
3506	0	case STAR_ASSIGN:
3507	0	case SLASH_ASSIGN:
3508	0	case AND_ASSIGN:
3509	0	case OR_ASSIGN:
3510	1	case XOR_ASSIGN:
3511	0	case REMAINDER_ASSIGN:
3512	0	case LEFT_SHIFT_ASSIGN:
3513	0	case RIGHT_SIGNED_SHIFT_ASSIGN:
3514	0	case RIGHT_UNSIGNED_SHIFTASSIGN:
3515	54	exp = expressionSuffix(exp);
3516	54	break;
3517	2664	default:
3518	2664	jj_la1[88] = jj_gen;
3519		;
3520		}
3521	2718	{if (true) return exp;}
3522	0	throw new Error("Missing return statement in function");
3523		}
3524
3525		/**
3526		* Parse only an expression that can appear as a statement
3527		*/
3528	372	final public Expression statementExpression() throws ParseException {
3529	372	Expression exp;
3530	372	Expression exp2;
3531	372	Expression exp3 = null;
3532	372	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3533	0	case INCREMENT:
3534	0	exp = preIncrementExpression();
3535	0	break;
3536	0	case DECREMENT:
3537	0	exp = preDecrementExpression();
3538	0	break;
3539	0	case BOOLEAN:
3540	0	case BYTE:
3541	0	case CHAR:
3542	0	case DOUBLE:
3543	0	case FALSE:
3544	0	case FLOAT:
3545	0	case INT:
3546	0	case LONG:
3547	1	case NEW:
3548	0	case NULL:
3549	0	case SHORT:
3550	46	case SUPER:
3551	0	case THIS:
3552	0	case TRUE:
3553	0	case VOID:
3554	0	case INTEGER_LITERAL:
3555	0	case LONG_LITERAL:
3556	0	case FLOAT_LITERAL:
3557	0	case DOUBLE_LITERAL:
3558	0	case CHARACTER_LITERAL:
3559	0	case STRING_LITERAL:
3560	316	case IDENTIFIER:
3561	9	case LPAREN:
3562	0	case LESS:
3563	372	exp = primaryExpression();
3564	372	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3565	187	case ASSIGN:
3566	119	case INCREMENT:
3567	3	case DECREMENT:
3568	0	case PLUS_ASSIGN:
3569	0	case MINUS_ASSIGN:
3570	0	case STAR_ASSIGN:
3571	0	case SLASH_ASSIGN:
3572	0	case AND_ASSIGN:
3573	0	case OR_ASSIGN:
3574	0	case XOR_ASSIGN:
3575	0	case REMAINDER_ASSIGN:
3576	0	case LEFT_SHIFT_ASSIGN:
3577	0	case RIGHT_SIGNED_SHIFT_ASSIGN:
3578	0	case RIGHT_UNSIGNED_SHIFTASSIGN:
3579	309	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3580	119	case INCREMENT:
3581	119	jj_consume_token(INCREMENT);
3582	119	exp = new PostIncrement(exp, _range(exp, token));
3583	119	break;
3584	3	case DECREMENT:
3585	3	jj_consume_token(DECREMENT);
3586	3	exp = new PostDecrement(exp, _range(exp, token));
3587	3	break;
3588	187	case ASSIGN:
3589	0	case PLUS_ASSIGN:
3590	0	case MINUS_ASSIGN:
3591	0	case STAR_ASSIGN:
3592	0	case SLASH_ASSIGN:
3593	0	case AND_ASSIGN:
3594	0	case OR_ASSIGN:
3595	0	case XOR_ASSIGN:
3596	0	case REMAINDER_ASSIGN:
3597	0	case LEFT_SHIFT_ASSIGN:
3598	0	case RIGHT_SIGNED_SHIFT_ASSIGN:
3599	0	case RIGHT_UNSIGNED_SHIFTASSIGN:
3600	187	exp = expressionSuffix(exp);
3601	187	break;
3602	0	default:
3603	0	jj_la1[89] = jj_gen;
3604	0	jj_consume_token(-1);
3605	0	throw new ParseException();
3606		}
3607	309	break;
3608	63	default:
3609	63	jj_la1[90] = jj_gen;
3610		;
3611		}
3612	372	break;
3613	0	default:
3614	0	jj_la1[91] = jj_gen;
3615	0	jj_consume_token(-1);
3616	0	throw new ParseException();
3617		}
3618	372	if (exp instanceof StatementExpression) {
3619	372	{if (true) return exp;}
3620		} else {
3621	0	{if (true) throw new ParseError(reader.getMessage("expression.statement", null), exp.getSourceInfo());}
3622		}
3623	0	throw new Error("Missing return statement in function");
3624		}
3625
3626		/**
3627		* Used internally to parse an expression
3628		*/
3629	241	final public Expression expressionSuffix(Expression pre) throws ParseException {
3630	241	Expression exp2;
3631	241	Expression exp;
3632	241	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3633	240	case ASSIGN:
3634	240	jj_consume_token(ASSIGN);
3635	240	exp2 = expression();
3636	240	exp = new SimpleAssignExpression(pre, exp2, _range(pre, exp2));
3637	240	break;
3638	0	case STAR_ASSIGN:
3639	0	jj_consume_token(STAR_ASSIGN);
3640	0	exp2 = expression();
3641	0	exp = new MultiplyAssignExpression(pre, exp2, _range(pre, exp2));
3642	0	break;
3643	0	case SLASH_ASSIGN:
3644	0	jj_consume_token(SLASH_ASSIGN);
3645	0	exp2 = expression();
3646	0	exp = new DivideAssignExpression(pre, exp2, _range(pre, exp2));
3647	0	break;
3648	0	case REMAINDER_ASSIGN:
3649	0	jj_consume_token(REMAINDER_ASSIGN);
3650	0	exp2 = expression();
3651	0	exp = new RemainderAssignExpression(pre, exp2, _range(pre, exp2));
3652	0	break;
3653	0	case PLUS_ASSIGN:
3654	0	jj_consume_token(PLUS_ASSIGN);
3655	0	exp2 = expression();
3656	0	exp = new AddAssignExpression(pre, exp2, _range(pre, exp2));
3657	0	break;
3658	0	case MINUS_ASSIGN:
3659	0	jj_consume_token(MINUS_ASSIGN);
3660	0	exp2 = expression();
3661	0	exp = new SubtractAssignExpression(pre, exp2, _range(pre, exp2));
3662	0	break;
3663	0	case LEFT_SHIFT_ASSIGN:
3664	0	jj_consume_token(LEFT_SHIFT_ASSIGN);
3665	0	exp2 = expression();
3666	0	exp = new ShiftLeftAssignExpression(pre, exp2, _range(pre, exp2));
3667	0	break;
3668	0	case RIGHT_SIGNED_SHIFT_ASSIGN:
3669	0	jj_consume_token(RIGHT_SIGNED_SHIFT_ASSIGN);
3670	0	exp2 = expression();
3671	0	exp = new ShiftRightAssignExpression(pre, exp2, _range(pre, exp2));
3672	0	break;
3673	0	case RIGHT_UNSIGNED_SHIFTASSIGN:
3674	0	jj_consume_token(RIGHT_UNSIGNED_SHIFTASSIGN);
3675	0	exp2 = expression();
3676	0	exp = new UnsignedShiftRightAssignExpression(pre, exp2, _range(pre, exp2));
3677	0	break;
3678	0	case AND_ASSIGN:
3679	0	jj_consume_token(AND_ASSIGN);
3680	0	exp2 = expression();
3681	0	exp = new BitAndAssignExpression(pre, exp2, _range(pre, exp2));
3682	0	break;
3683	1	case XOR_ASSIGN:
3684	1	jj_consume_token(XOR_ASSIGN);
3685	1	exp2 = expression();
3686	1	exp = new ExclusiveOrAssignExpression(pre, exp2, _range(pre, exp2));
3687	1	break;
3688	0	case OR_ASSIGN:
3689	0	jj_consume_token(OR_ASSIGN);
3690	0	exp2 = expression();
3691	0	exp = new BitOrAssignExpression(pre, exp2, _range(pre, exp2));
3692	0	break;
3693	0	default:
3694	0	jj_la1[92] = jj_gen;
3695	0	jj_consume_token(-1);
3696	0	throw new ParseException();
3697		}
3698	241	if (!(pre instanceof LeftHandSide)) {
3699	0	{if (true) throw new ParseError(reader.getMessage("left.expression.in.assignment",
3700		null),
3701		pre.getSourceInfo());}
3702		}
3703	241	{if (true) return exp;}
3704	0	throw new Error("Missing return statement in function");
3705		}
3706
3707		/**
3708		* Used internally to parse an expression
3709		*/
3710	2730	final public Expression conditionalExpression() throws ParseException {
3711	2730	Expression exp;
3712	2730	Expression exp2;
3713	2730	Expression exp3;
3714	2730	exp = conditionalOrExpression();
3715	2730	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3716	1	case HOOK:
3717	1	jj_consume_token(HOOK);
3718	1	exp2 = expression();
3719	1	jj_consume_token(COLON);
3720	1	exp3 = conditionalExpression();
3721	1	exp = new ConditionalExpression(exp, exp2, exp3, _range(exp, exp3));
3722	1	break;
3723	2729	default:
3724	2729	jj_la1[93] = jj_gen;
3725		;
3726		}
3727	2730	{if (true) return exp;}
3728	0	throw new Error("Missing return statement in function");
3729		}
3730
3731		/**
3732		* Used internally to parse an expression
3733		*/
3734	2730	final public Expression conditionalOrExpression() throws ParseException {
3735	2730	Expression exp;
3736	2730	Expression exp2;
3737	2730	exp = conditionalAndExpression();
3738	2730	label_26:
3739		while (true) {
3740	2730	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3741	0	case CONDITIONAL_OR:
3742		;
3743	0	break;
3744	2730	default:
3745	2730	jj_la1[94] = jj_gen;
3746	2730	break label_26;
3747		}
3748	0	jj_consume_token(CONDITIONAL_OR);
3749	0	exp2 = conditionalAndExpression();
3750	0	exp = new OrExpression(exp, exp2, _range(exp, exp2));
3751		}
3752	2730	{if (true) return exp;}
3753	0	throw new Error("Missing return statement in function");
3754		}
3755
3756		/**
3757		* Used internally to parse an expression
3758		*/
3759	2730	final public Expression conditionalAndExpression() throws ParseException {
3760	2730	Expression exp;
3761	2730	Expression exp2;
3762	2730	exp = inclusiveOrExpression();
3763	2730	label_27:
3764		while (true) {
3765	2730	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3766	0	case CONDITIONAL_AND:
3767		;
3768	0	break;
3769	2730	default:
3770	2730	jj_la1[95] = jj_gen;
3771	2730	break label_27;
3772		}
3773	0	jj_consume_token(CONDITIONAL_AND);
3774	0	exp2 = inclusiveOrExpression();
3775	0	exp = new AndExpression(exp, exp2, _range(exp, exp2));
3776		}
3777	2730	{if (true) return exp;}
3778	0	throw new Error("Missing return statement in function");
3779		}
3780
3781		/**
3782		* Used internally to parse an expression
3783		*/
3784	2730	final public Expression inclusiveOrExpression() throws ParseException {
3785	2730	Expression exp;
3786	2730	Expression exp2;
3787	2730	exp = exclusiveOrExpression();
3788	2730	label_28:
3789		while (true) {
3790	2730	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3791	0	case BITWISE_OR:
3792		;
3793	0	break;
3794	2730	default:
3795	2730	jj_la1[96] = jj_gen;
3796	2730	break label_28;
3797		}
3798	0	jj_consume_token(BITWISE_OR);
3799	0	exp2 = exclusiveOrExpression();
3800	0	exp = new BitOrExpression(exp, exp2, _range(exp, exp2));
3801		}
3802	2730	{if (true) return exp;}
3803	0	throw new Error("Missing return statement in function");
3804		}
3805
3806		/**
3807		* Used internally to parse an expression
3808		*/
3809	2730	final public Expression exclusiveOrExpression() throws ParseException {
3810	2730	Expression exp;
3811	2730	Expression exp2;
3812	2730	exp = andExpression();
3813	2730	label_29:
3814		while (true) {
3815	2730	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3816	0	case XOR:
3817		;
3818	0	break;
3819	2730	default:
3820	2730	jj_la1[97] = jj_gen;
3821	2730	break label_29;
3822		}
3823	0	jj_consume_token(XOR);
3824	0	exp2 = andExpression();
3825	0	exp = new ExclusiveOrExpression(exp, exp2, _range(exp, exp2));
3826		}
3827	2730	{if (true) return exp;}
3828	0	throw new Error("Missing return statement in function");
3829		}
3830
3831		/**
3832		* Used internally to parse an expression
3833		*/
3834	2730	final public Expression andExpression() throws ParseException {
3835	2730	Expression exp;
3836	2730	Expression exp2;
3837	2730	exp = equalityExpression();
3838	2730	label_30:
3839		while (true) {
3840	2730	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3841	0	case BITWISE_AND:
3842		;
3843	0	break;
3844	2730	default:
3845	2730	jj_la1[98] = jj_gen;
3846	2730	break label_30;
3847		}
3848	0	jj_consume_token(BITWISE_AND);
3849	0	exp2 = equalityExpression();
3850	0	exp = new BitAndExpression(exp, exp2, _range(exp, exp2));
3851		}
3852	2730	{if (true) return exp;}
3853	0	throw new Error("Missing return statement in function");
3854		}
3855
3856		/**
3857		* Used internally to parse an expression
3858		*/
3859	2730	final public Expression equalityExpression() throws ParseException {
3860	2730	Expression exp;
3861	2730	Expression exp2;
3862	2730	exp = instanceOfExpression();
3863	2730	label_31:
3864		while (true) {
3865	2784	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3866	50	case EQUAL:
3867	4	case NOT_EQUAL:
3868		;
3869	54	break;
3870	2730	default:
3871	2730	jj_la1[99] = jj_gen;
3872	2730	break label_31;
3873		}
3874	54	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3875	50	case EQUAL:
3876	50	jj_consume_token(EQUAL);
3877	50	exp2 = instanceOfExpression();
3878	50	exp = new EqualExpression(exp, exp2, _range(exp, exp2));
3879	50	break;
3880	4	case NOT_EQUAL:
3881	4	jj_consume_token(NOT_EQUAL);
3882	4	exp2 = instanceOfExpression();
3883	4	exp = new NotEqualExpression(exp, exp2, _range(exp, exp2));
3884	4	break;
3885	0	default:
3886	0	jj_la1[100] = jj_gen;
3887	0	jj_consume_token(-1);
3888	0	throw new ParseException();
3889		}
3890		}
3891	2730	{if (true) return exp;}
3892	0	throw new Error("Missing return statement in function");
3893		}
3894
3895		/**
3896		* Used internally to parse an expression
3897		*/
3898	2784	final public Expression instanceOfExpression() throws ParseException {
3899	2784	Expression exp;
3900	2784	TypeName typ = null;
3901	2784	exp = relationalExpression();
3902	2784	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3903	1	case INSTANCEOF:
3904	1	jj_consume_token(INSTANCEOF);
3905	1	typ = type();
3906	1	break;
3907	2783	default:
3908	2783	jj_la1[101] = jj_gen;
3909		;
3910		}
3911	1	if (typ != null) { {if (true) return new InstanceOfExpression(exp, typ, _range(exp, typ));} }
3912	2783	else { {if (true) return exp;} }
3913	0	throw new Error("Missing return statement in function");
3914		}
3915
3916		/**
3917		* Used internally to parse an expression
3918		*/
3919	2784	final public Expression relationalExpression() throws ParseException {
3920	2784	Expression exp;
3921	2784	Expression exp2;
3922	2784	exp = shiftExpression();
3923	2784	label_32:
3924		while (true) {
3925	2921	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3926	12	case GREATER_THAN:
3927	124	case LESS:
3928	0	case LESS_OR_EQUAL:
3929	1	case GREATER_OR_EQUAL:
3930		;
3931	137	break;
3932	2784	default:
3933	2784	jj_la1[102] = jj_gen;
3934	2784	break label_32;
3935		}
3936	137	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3937	124	case LESS:
3938	124	jj_consume_token(LESS);
3939	124	exp2 = shiftExpression();
3940	124	exp = new LessExpression(exp, exp2, _range(exp, exp2));
3941	124	break;
3942	12	case GREATER_THAN:
3943	12	jj_consume_token(GREATER_THAN);
3944	12	exp2 = shiftExpression();
3945	12	exp = new GreaterExpression(exp, exp2, _range(exp, exp2));
3946	12	break;
3947	0	case LESS_OR_EQUAL:
3948	0	jj_consume_token(LESS_OR_EQUAL);
3949	0	exp2 = shiftExpression();
3950	0	exp = new LessOrEqualExpression(exp, exp2, _range(exp, exp2));
3951	0	break;
3952	1	case GREATER_OR_EQUAL:
3953	1	jj_consume_token(GREATER_OR_EQUAL);
3954	1	exp2 = shiftExpression();
3955	1	exp = new GreaterOrEqualExpression(exp, exp2, _range(exp, exp2));
3956	1	break;
3957	0	default:
3958	0	jj_la1[103] = jj_gen;
3959	0	jj_consume_token(-1);
3960	0	throw new ParseException();
3961		}
3962		}
3963	2784	{if (true) return exp;}
3964	0	throw new Error("Missing return statement in function");
3965		}
3966
3967		/**
3968		* Used internally to parse an expression
3969		*/
3970	2921	final public Expression shiftExpression() throws ParseException {
3971	2921	Expression exp;
3972	2921	Expression exp2;
3973	2921	exp = additiveExpression();
3974	2921	label_33:
3975		while (true) {
3976	2922	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3977	1	case LEFT_SHIFT:
3978	0	case RSSHIFT1:
3979	0	case RUSHIFT1:
3980		;
3981	1	break;
3982	2921	default:
3983	2921	jj_la1[104] = jj_gen;
3984	2921	break label_33;
3985		}
3986	1	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3987	1	case LEFT_SHIFT:
3988	1	jj_consume_token(LEFT_SHIFT);
3989	1	exp2 = additiveExpression();
3990	1	exp = new ShiftLeftExpression(exp, exp2, _range(exp, exp2));
3991	1	break;
3992	0	case RSSHIFT1:
3993	0	jj_consume_token(RSSHIFT1);
3994	0	jj_consume_token(RSSHIFT2);
3995	0	exp2 = additiveExpression();
3996	0	exp = new ShiftRightExpression(exp, exp2, _range(exp, exp2));
3997	0	break;
3998	0	case RUSHIFT1:
3999	0	jj_consume_token(RUSHIFT1);
4000	0	jj_consume_token(RUSHIFT2);
4001	0	jj_consume_token(RUSHIFT3);
4002	0	exp2 = additiveExpression();
4003	0	exp = new UnsignedShiftRightExpression(exp, exp2, _range(exp, exp2));
4004	0	break;
4005	0	default:
4006	0	jj_la1[105] = jj_gen;
4007	0	jj_consume_token(-1);
4008	0	throw new ParseException();
4009		}
4010		}
4011	2921	{if (true) return exp;}
4012	0	throw new Error("Missing return statement in function");
4013		}
4014
4015		/**
4016		* Used internally to parse an expression
4017		*/
4018	2922	final public Expression additiveExpression() throws ParseException {
4019	2922	Expression exp;
4020	2922	Expression exp2;
4021	2922	exp = multiplicativeExpression();
4022	2922	label_34:
4023		while (true) {
4024	3051	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4025	126	case PLUS:
4026	3	case MINUS:
4027		;
4028	129	break;
4029	2922	default:
4030	2922	jj_la1[106] = jj_gen;
4031	2922	break label_34;
4032		}
4033	129	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4034	126	case PLUS:
4035	126	jj_consume_token(PLUS);
4036	126	exp2 = multiplicativeExpression();
4037	126	exp = new AddExpression(exp, exp2, _range(exp, exp2));
4038	126	break;
4039	3	case MINUS:
4040	3	jj_consume_token(MINUS);
4041	3	exp2 = multiplicativeExpression();
4042	3	exp = new SubtractExpression(exp, exp2, _range(exp, exp2));
4043	3	break;
4044	0	default:
4045	0	jj_la1[107] = jj_gen;
4046	0	jj_consume_token(-1);
4047	0	throw new ParseException();
4048		}
4049		}
4050	2922	{if (true) return exp;}
4051	0	throw new Error("Missing return statement in function");
4052		}
4053
4054		/**
4055		* Used internally to parse an expression
4056		*/
4057	3051	final public Expression multiplicativeExpression() throws ParseException {
4058	3051	Expression exp;
4059	3051	Expression exp2;
4060	3051	exp = unaryExpression();
4061	3051	label_35:
4062		while (true) {
4063	3055	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4064	0	case STAR:
4065	4	case SLASH:
4066	0	case REMAINDER:
4067		;
4068	4	break;
4069	3051	default:
4070	3051	jj_la1[108] = jj_gen;
4071	3051	break label_35;
4072		}
4073	4	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4074	0	case STAR:
4075	0	jj_consume_token(STAR);
4076	0	exp2 = unaryExpression();
4077	0	exp = new MultiplyExpression(exp, exp2, _range(exp, exp2));
4078	0	break;
4079	4	case SLASH:
4080	4	jj_consume_token(SLASH);
4081	4	exp2 = unaryExpression();
4082	4	exp = new DivideExpression(exp, exp2, _range(exp, exp2));
4083	4	break;
4084	0	case REMAINDER:
4085	0	jj_consume_token(REMAINDER);
4086	0	exp2 = unaryExpression();
4087	0	exp = new RemainderExpression(exp, exp2, _range(exp, exp2));
4088	0	break;
4089	0	default:
4090	0	jj_la1[109] = jj_gen;
4091	0	jj_consume_token(-1);
4092	0	throw new ParseException();
4093		}
4094		}
4095	3051	{if (true) return exp;}
4096	0	throw new Error("Missing return statement in function");
4097		}
4098
4099		/**
4100		* Used internally to parse an expression
4101		*/
4102	3272	final public Expression unaryExpression() throws ParseException {
4103	3272	Expression exp = null;
4104	3272	Token t,tk;
4105	3272	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4106	0	case PLUS:
4107	0	t = jj_consume_token(PLUS);
4108	0	exp = unaryExpression();
4109	0	{if (true) return new PlusExpression(exp, _range(t, exp));}
4110	0	break;
4111	7	case MINUS:
4112	7	t = jj_consume_token(MINUS);
4113	7	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4114	3	case INTEGER_LITERAL:
4115	3	tk = jj_consume_token(INTEGER_LITERAL);
4116	3	try { {if (true) return new IntegerLiteral("-"+tk.image, _range(t, tk));} }
4117	0	catch (NumberFormatException e) { {if (true) throw new ParseError(e, _range(t, tk));} }
4118	0	break;
4119	0	case LONG_LITERAL:
4120	0	tk = jj_consume_token(LONG_LITERAL);
4121	0	if(tk.image.endsWith("L")) tk.image=tk.image.substring(0,tk.image.length()-1);
4122	0	try { {if (true) return new LongLiteral("-"+tk.image, _range(t, tk));} }
4123	0	catch (NumberFormatException e) { {if (true) throw new ParseError(e, _range(t, tk));} }
4124	0	break;
4125	0	case BOOLEAN:
4126	0	case BYTE:
4127	0	case CHAR:
4128	0	case DOUBLE:
4129	0	case FALSE:
4130	0	case FLOAT:
4131	0	case INT:
4132	0	case LONG:
4133	0	case NEW:
4134	0	case NULL:
4135	0	case SHORT:
4136	0	case SUPER:
4137	0	case THIS:
4138	0	case TRUE:
4139	0	case VOID:
4140	3	case FLOAT_LITERAL:
4141	1	case DOUBLE_LITERAL:
4142	0	case CHARACTER_LITERAL:
4143	0	case STRING_LITERAL:
4144	0	case IDENTIFIER:
4145	0	case LPAREN:
4146	0	case LESS:
4147	0	case BANG:
4148	0	case TILDE:
4149	0	case INCREMENT:
4150	0	case DECREMENT:
4151	0	case PLUS:
4152	0	case MINUS:
4153	4	exp = unaryExpression();
4154	4	{if (true) return new MinusExpression(exp, _range(t, exp));}
4155	0	break;
4156	0	default:
4157	0	jj_la1[110] = jj_gen;
4158	0	jj_consume_token(-1);
4159	0	throw new ParseException();
4160		}
4161	0	break;
4162	3	case INCREMENT:
4163	3	exp = preIncrementExpression();
4164	3	break;
4165	2	case DECREMENT:
4166	2	exp = preDecrementExpression();
4167	2	break;
4168	1	case BOOLEAN:
4169	1	case BYTE:
4170	1	case CHAR:
4171	1	case DOUBLE:
4172	52	case FALSE:
4173	0	case FLOAT:
4174	2	case INT:
4175	1	case LONG:
4176	508	case NEW:
4177	10	case NULL:
4178	1	case SHORT:
4179	1	case SUPER:
4180	0	case THIS:
4181	34	case TRUE:
4182	1	case VOID:
4183	416	case INTEGER_LITERAL:
4184	5	case LONG_LITERAL:
4185	23	case FLOAT_LITERAL:
4186	34	case DOUBLE_LITERAL:
4187	8	case CHARACTER_LITERAL:
4188	387	case STRING_LITERAL:
4189	1536	case IDENTIFIER:
4190	38	case LPAREN:
4191	0	case LESS:
4192	199	case BANG:
4193	0	case TILDE:
4194	3260	exp = unaryExpressionNotPlusMinus();
4195	3260	break;
4196	0	default:
4197	0	jj_la1[111] = jj_gen;
4198	0	jj_consume_token(-1);
4199	0	throw new ParseException();
4200		}
4201	3265	{if (true) return exp;}
4202	0	throw new Error("Missing return statement in function");
4203		}
4204
4205		/**
4206		* Used internally to parse an expression
4207		*/
4208	3262	final public Expression unaryExpressionNotPlusMinus() throws ParseException {
4209	3262	Expression exp;
4210	3262	Token t;
4211	3262	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4212	0	case TILDE:
4213	0	t = jj_consume_token(TILDE);
4214	0	exp = unaryExpression();
4215	0	{if (true) return new ComplementExpression(exp, _range(t, exp));}
4216	0	break;
4217	199	case BANG:
4218	199	t = jj_consume_token(BANG);
4219	199	exp = unaryExpression();
4220	199	{if (true) return new NotExpression(exp, _range(t, exp));}
4221	0	break;
4222	3063	default:
4223	3063	jj_la1[112] = jj_gen;
4224	3063	if (jj_2_38(2147483647)) {
4225	16	exp = castExpression();
4226		} else {
4227	3047	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4228	1	case BOOLEAN:
4229	1	case BYTE:
4230	1	case CHAR:
4231	1	case DOUBLE:
4232	52	case FALSE:
4233	0	case FLOAT:
4234	2	case INT:
4235	1	case LONG:
4236	508	case NEW:
4237	10	case NULL:
4238	1	case SHORT:
4239	1	case SUPER:
4240	0	case THIS:
4241	34	case TRUE:
4242	1	case VOID:
4243	416	case INTEGER_LITERAL:
4244	5	case LONG_LITERAL:
4245	23	case FLOAT_LITERAL:
4246	34	case DOUBLE_LITERAL:
4247	8	case CHARACTER_LITERAL:
4248	387	case STRING_LITERAL:
4249	1536	case IDENTIFIER:
4250	24	case LPAREN:
4251	0	case LESS:
4252	3047	exp = postfixExpression();
4253	3047	break;
4254	0	default:
4255	0	jj_la1[113] = jj_gen;
4256	0	jj_consume_token(-1);
4257	0	throw new ParseException();
4258		}
4259		}
4260		}
4261	3063	{if (true) return exp;}
4262	0	throw new Error("Missing return statement in function");
4263		}
4264
4265		/**
4266		* Used internally to parse an expression
4267		*/
4268	16	final public Expression castExpression() throws ParseException {
4269	16	TypeName typ; Token t; Expression exp;
4270	16	t = jj_consume_token(LPAREN);
4271	16	if (jj_2_39(2)) {
4272	14	typ = primitiveType();
4273	14	jj_consume_token(RPAREN);
4274	14	exp = unaryExpression();
4275		} else {
4276	2	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4277	0	case BOOLEAN:
4278	0	case BYTE:
4279	0	case CHAR:
4280	0	case DOUBLE:
4281	0	case FLOAT:
4282	0	case INT:
4283	0	case LONG:
4284	0	case SHORT:
4285	2	case IDENTIFIER:
4286	2	typ = type();
4287	2	jj_consume_token(RPAREN);
4288	2	exp = unaryExpressionNotPlusMinus();
4289	2	break;
4290	0	default:
4291	0	jj_la1[114] = jj_gen;
4292	0	jj_consume_token(-1);
4293	0	throw new ParseException();
4294		}
4295		}
4296	16	{if (true) return new CastExpression(typ, exp, _range(t, exp));}
4297	0	throw new Error("Missing return statement in function");
4298		}
4299
4300		/**
4301		* Used internally to parse an expression
4302		*/
4303	3	final public Expression preIncrementExpression() throws ParseException {
4304	3	Expression pe;
4305	3	Token t;
4306	3	t = jj_consume_token(INCREMENT);
4307	3	pe = primaryExpression();
4308	3	{if (true) return new PreIncrement(pe, _range(t, pe));}
4309	0	throw new Error("Missing return statement in function");
4310		}
4311
4312		/**
4313		* Used internally to parse an expression
4314		*/
4315	2	final public Expression preDecrementExpression() throws ParseException {
4316	2	Expression pe;
4317	2	Token t;
4318	2	t = jj_consume_token(DECREMENT);
4319	2	pe = primaryExpression();
4320	2	{if (true) return new PreDecrement(pe, _range(t, pe));}
4321	0	throw new Error("Missing return statement in function");
4322		}
4323
4324		/**
4325		* Used internally to parse an expression
4326		*/
4327	3047	final public Expression postfixExpression() throws ParseException {
4328	3047	Expression pe;
4329	3047	pe = primaryExpression();
4330	3047	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4331	5	case INCREMENT:
4332	3	case DECREMENT:
4333	8	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4334	5	case INCREMENT:
4335	5	jj_consume_token(INCREMENT);
4336	5	{if (true) return new PostIncrement(pe, _range(pe, token));}
4337	0	break;
4338	3	case DECREMENT:
4339	3	jj_consume_token(DECREMENT);
4340	3	{if (true) return new PostDecrement(pe, _range(pe, token));}
4341	0	break;
4342	0	default:
4343	0	jj_la1[115] = jj_gen;
4344	0	jj_consume_token(-1);
4345	0	throw new ParseException();
4346		}
4347	0	break;
4348	3039	default:
4349	3039	jj_la1[116] = jj_gen;
4350		;
4351		}
4352	3039	{if (true) return pe;}
4353	0	throw new Error("Missing return statement in function");
4354		}
4355
4356		/**
4357		* Used internally to parse an expression
4358		*/
4359	3424	final public Expression primaryExpression() throws ParseException {
4360	3424	Primary p; Option<List<TypeName>> targs; List<TypeName> targs2;
4361	3424	Expression exp; List<Expression> args; List<Node> nodes;
4362	3424	p = primaryPrefix();
4363	3424	label_36:
4364		while (true) {
4365	4652	if (jj_2_40(2147483647)) {
4366		;
4367		} else {
4368	3424	break label_36;
4369		}
4370	1228	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4371	304	case DOT:
4372	304	jj_consume_token(DOT);
4373	304	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4374	1	case NEW:
4375	0	case SUPER:
4376	1	case THIS:
4377	286	case IDENTIFIER:
4378	0	case LESS:
4379	288	targs = optionalTypeArguments();
4380	288	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4381	286	case IDENTIFIER:
4382	286	jj_consume_token(IDENTIFIER);
4383	286	p = p.dotId(targs, token);
4384	286	break;
4385	1	case THIS:
4386	1	jj_consume_token(THIS);
4387	1	p = p.dotThis(targs, token);
4388	1	break;
4389	0	case SUPER:
4390	0	jj_consume_token(SUPER);
4391	0	p = p.dotSuper(targs, token);
4392	0	break;
4393	1	case NEW:
4394	1	jj_consume_token(NEW);
4395	1	jj_consume_token(IDENTIFIER);
4396	1	p = p.dotNew(targs, token);
4397	1	break;
4398	0	default:
4399	0	jj_la1[117] = jj_gen;
4400	0	jj_consume_token(-1);
4401	0	throw new ParseException();
4402		}
4403	288	break;
4404	16	case CLASS:
4405	16	jj_consume_token(CLASS);
4406	16	p = p.dotClass(token);
4407	16	break;
4408	0	default:
4409	0	jj_la1[118] = jj_gen;
4410	0	jj_consume_token(-1);
4411	0	throw new ParseException();
4412		}
4413	304	break;
4414	112	case LBRACKET:
4415	112	jj_consume_token(LBRACKET);
4416	112	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4417	3	case RBRACKET:
4418	3	jj_consume_token(RBRACKET);
4419	3	p = p.withArrayDim(token);
4420	3	break;
4421	0	case BOOLEAN:
4422	0	case BYTE:
4423	0	case CHAR:
4424	0	case DOUBLE:
4425	0	case FALSE:
4426	0	case FLOAT:
4427	0	case INT:
4428	0	case LONG:
4429	0	case NEW:
4430	0	case NULL:
4431	0	case SHORT:
4432	0	case SUPER:
4433	0	case THIS:
4434	0	case TRUE:
4435	0	case VOID:
4436	1	case INTEGER_LITERAL:
4437	0	case LONG_LITERAL:
4438	0	case FLOAT_LITERAL:
4439	0	case DOUBLE_LITERAL:
4440	0	case CHARACTER_LITERAL:
4441	0	case STRING_LITERAL:
4442	108	case IDENTIFIER:
4443	0	case LPAREN:
4444	0	case LESS:
4445	0	case BANG:
4446	0	case TILDE:
4447	0	case INCREMENT:
4448	0	case DECREMENT:
4449	0	case PLUS:
4450	0	case MINUS:
4451	109	exp = expression();
4452	109	jj_consume_token(RBRACKET);
4453	109	p = p.withArrayAccess(exp, token);
4454	109	break;
4455	0	default:
4456	0	jj_la1[119] = jj_gen;
4457	0	jj_consume_token(-1);
4458	0	throw new ParseException();
4459		}
4460	112	break;
4461	0	case LESS:
4462	0	targs2 = typeArguments();
4463	0	p = p.withTypeArgs(targs2, token);
4464	0	break;
4465	811	case LPAREN:
4466	811	args = arguments();
4467	811	p = p.withArgs(args, token);
4468	811	break;
4469	1	case LBRACE:
4470	1	nodes = classBody();
4471	1	p = p.withClassBody(nodes, token);
4472	1	break;
4473	0	default:
4474	0	jj_la1[120] = jj_gen;
4475	0	jj_consume_token(-1);
4476	0	throw new ParseException();
4477		}
4478		}
4479	3424	{if (true) return p.asExpression();}
4480	0	throw new Error("Missing return statement in function");
4481		}
4482
4483		/**
4484		* Used internally to parse an expression
4485		*/
4486	3424	final public Primary primaryPrefix() throws ParseException {
4487	3424	Token first=getToken(1); Expression exp; PrimitiveTypeName pt; List<TypeName> targs; Primary p;
4488	3424	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4489	1856	case IDENTIFIER:
4490	1856	jj_consume_token(IDENTIFIER);
4491	1856	{if (true) return new AmbiguousNamePrimary(token);}
4492	0	break;
4493	52	case FALSE:
4494	10	case NULL:
4495	34	case TRUE:
4496	416	case INTEGER_LITERAL:
4497	5	case LONG_LITERAL:
4498	23	case FLOAT_LITERAL:
4499	34	case DOUBLE_LITERAL:
4500	8	case CHARACTER_LITERAL:
4501	387	case STRING_LITERAL:
4502	969	exp = literal();
4503	969	{if (true) return new ExpressionPrimary(exp);}
4504	0	break;
4505	34	case LPAREN:
4506	34	jj_consume_token(LPAREN);
4507	34	exp = expression();
4508	34	jj_consume_token(RPAREN);
4509	34	exp.setSourceInfo(_range(first, token)); {if (true) return new ExpressionPrimary(exp);}
4510	0	break;
4511	1	case BOOLEAN:
4512	1	case BYTE:
4513	1	case CHAR:
4514	1	case DOUBLE:
4515	0	case FLOAT:
4516	2	case INT:
4517	1	case LONG:
4518	1	case SHORT:
4519	8	pt = primitiveType();
4520	8	{if (true) return new PrimitiveTypeNamePrimary(pt);}
4521	0	break;
4522	1	case VOID:
4523	1	jj_consume_token(VOID);
4524	1	{if (true) return new VoidTypeNamePrimary(new VoidTypeName(_range(token, token)));}
4525	0	break;
4526	0	case THIS:
4527	0	jj_consume_token(THIS);
4528	0	{if (true) return new ThisExpressionPrimary(token);}
4529	0	break;
4530	47	case SUPER:
4531	47	jj_consume_token(SUPER);
4532	47	{if (true) return new PartialSuperPrimary(token);}
4533	0	break;
4534	0	case LESS:
4535	0	targs = typeArguments();
4536	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4537	0	case IDENTIFIER:
4538	0	jj_consume_token(IDENTIFIER);
4539	0	{if (true) return new PartialSimpleMethodCallPrimary(Option.some(targs), token, _range(first, token));}
4540	0	break;
4541	0	case THIS:
4542	0	jj_consume_token(THIS);
4543	0	{if (true) return new PartialThisConstructorCallPrimary(Option.some(targs), _range(first, token));}
4544	0	break;
4545	0	case SUPER:
4546	0	jj_consume_token(SUPER);
4547	0	{if (true) return new PartialSuperConstructorCallPrimary(Option.some(targs), _range(first, token));}
4548	0	break;
4549	0	default:
4550	0	jj_la1[121] = jj_gen;
4551	0	jj_consume_token(-1);
4552	0	throw new ParseException();
4553		}
4554	0	break;
4555	509	case NEW:
4556	509	p = allocation();
4557	509	{if (true) return p;}
4558	0	break;
4559	0	default:
4560	0	jj_la1[122] = jj_gen;
4561	0	jj_consume_token(-1);
4562	0	throw new ParseException();
4563		}
4564	0	throw new Error("Missing return statement in function");
4565		}
4566
4567		/**
4568		* Used internally to parse an expression
4569		*/
4570	509	final public Primary allocation() throws ParseException {
4571	509	Token first; ArrayAllocation.TypeDescriptor td; TypeName primT; ReferenceTypeName refT;
4572	509	List<TypeName> typeArgs;
4573	509	first = jj_consume_token(NEW);
4574	509	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4575	0	case BOOLEAN:
4576	0	case BYTE:
4577	0	case CHAR:
4578	0	case DOUBLE:
4579	0	case FLOAT:
4580	7	case INT:
4581	0	case LONG:
4582	0	case SHORT:
4583	7	primT = primitiveType();
4584	7	td = arrayDimsAndInits();
4585	7	{if (true) return new ArrayAllocationPrimary(new ArrayAllocation(primT, td, _range(first, td)));}
4586	0	break;
4587	0	case LESS:
4588	0	typeArgs = typeArguments();
4589	0	refT = referenceTypeName();
4590	0	{if (true) return new PartialSimpleAllocationPrimary(Option.some(typeArgs), refT, _range(first, refT));}
4591	0	break;
4592	502	case IDENTIFIER:
4593	502	refT = referenceTypeName();
4594	502	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4595	7	case LBRACKET:
4596	7	td = arrayDimsAndInits();
4597	7	{if (true) return new ArrayAllocationPrimary(new ArrayAllocation(refT, td, _range(first, td)));}
4598	0	break;
4599	495	default:
4600	495	jj_la1[123] = jj_gen;
4601	495	{if (true) return new PartialSimpleAllocationPrimary(Option.<List<TypeName>>none(), refT, _range(first, refT));}
4602		}
4603	0	break;
4604	0	default:
4605	0	jj_la1[124] = jj_gen;
4606	0	jj_consume_token(-1);
4607	0	throw new ParseException();
4608		}
4609	0	throw new Error("Missing return statement in function");
4610		}
4611
4612		/**
4613		* Used internally to parse an expression
4614		*/
4615	14	final public ArrayAllocation.TypeDescriptor arrayDimsAndInits() throws ParseException {
4616	14	List<Expression> dims = new LinkedList<Expression>();
4617	14	int dim = 0;
4618	14	Token left, right;
4619	14	Expression exp;
4620	14	ArrayInitializer ai;
4621	14	if (jj_2_43(2)) {
4622	1	label_37:
4623		while (true) {
4624	1	left = jj_consume_token(LBRACKET);
4625	1	exp = expression();
4626	1	right = jj_consume_token(RBRACKET);
4627	1	dims.add(exp);
4628	1	if (jj_2_41(2)) {
4629		;
4630		} else {
4631	1	break label_37;
4632		}
4633		}
4634	1	label_38:
4635		while (true) {
4636	1	if (jj_2_42(2)) {
4637		;
4638		} else {
4639	1	break label_38;
4640		}
4641	0	left = jj_consume_token(LBRACKET);
4642	0	right = jj_consume_token(RBRACKET);
4643	0	dim++;
4644		}
4645	1	{if (true) return new ArrayAllocation.TypeDescriptor(dims, dim+dims.size(), null, _range(left, right));}
4646		} else {
4647	13	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4648	13	case LBRACKET:
4649	13	label_39:
4650		while (true) {
4651	13	left = jj_consume_token(LBRACKET);
4652	13	jj_consume_token(RBRACKET);
4653	13	dim++;
4654	13	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4655	0	case LBRACKET:
4656		;
4657	0	break;
4658	13	default:
4659	13	jj_la1[125] = jj_gen;
4660	13	break label_39;
4661		}
4662		}
4663	13	ai = arrayInitializer();
4664	13	{if (true) return new ArrayAllocation.TypeDescriptor(dims, dim, ai, _range(left, ai));}
4665	0	break;
4666	0	default:
4667	0	jj_la1[126] = jj_gen;
4668	0	jj_consume_token(-1);
4669	0	throw new ParseException();
4670		}
4671		}
4672	0	throw new Error("Missing return statement in function");
4673		}
4674
4675		/**
4676		* Used internally to parse an expression
4677		*/
4678	811	final public List<Expression> arguments() throws ParseException {
4679	811	List<Expression> list = new LinkedList<Expression>(); Expression exp;
4680	811	jj_consume_token(LPAREN);
4681	811	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4682	0	case BOOLEAN:
4683	0	case BYTE:
4684	0	case CHAR:
4685	0	case DOUBLE:
4686	0	case FALSE:
4687	0	case FLOAT:
4688	0	case INT:
4689	0	case LONG:
4690	115	case NEW:
4691	5	case NULL:
4692	0	case SHORT:
4693	0	case SUPER:
4694	0	case THIS:
4695	1	case TRUE:
4696	0	case VOID:
4697	98	case INTEGER_LITERAL:
4698	1	case LONG_LITERAL:
4699	0	case FLOAT_LITERAL:
4700	18	case DOUBLE_LITERAL:
4701	1	case CHARACTER_LITERAL:
4702	305	case STRING_LITERAL:
4703	157	case IDENTIFIER:
4704	2	case LPAREN:
4705	0	case LESS:
4706	16	case BANG:
4707	0	case TILDE:
4708	0	case INCREMENT:
4709	0	case DECREMENT:
4710	0	case PLUS:
4711	1	case MINUS:
4712	720	exp = expression();
4713	720	list.add(exp);
4714	720	label_40:
4715		while (true) {
4716	766	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4717	46	case COMMA:
4718		;
4719	46	break;
4720	720	default:
4721	720	jj_la1[127] = jj_gen;
4722	720	break label_40;
4723		}
4724	46	jj_consume_token(COMMA);
4725	46	exp = expression();
4726	46	list.add(exp);
4727		}
4728	720	break;
4729	91	default:
4730	91	jj_la1[128] = jj_gen;
4731		;
4732		}
4733	811	jj_consume_token(RPAREN);
4734	811	{if (true) return list;}
4735	0	throw new Error("Missing return statement in function");
4736		}
4737
4738		/**
4739		* Used internally to parse an expression
4740		*/
4741	969	final public Expression literal() throws ParseException {
4742	969	Token t;
4743	969	try {
4744	969	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4745	416	case INTEGER_LITERAL:
4746	416	t = jj_consume_token(INTEGER_LITERAL);
4747	416	try { {if (true) return new IntegerLiteral(t.image, _range(t, t));} }
4748	0	catch (NumberFormatException e) { {if (true) throw new ParseError(e, _range(t, t));} }
4749	0	break;
4750	5	case LONG_LITERAL:
4751	5	t = jj_consume_token(LONG_LITERAL);
4752	0	if(t.image.endsWith("L")) t.image=t.image.substring(0,t.image.length()-1);
4753	5	try { {if (true) return new LongLiteral(t.image, _range(t, t));} }
4754	0	catch (NumberFormatException e) { {if (true) throw new ParseError(e, _range(t, t));} }
4755	0	break;
4756	23	case FLOAT_LITERAL:
4757	23	t = jj_consume_token(FLOAT_LITERAL);
4758	23	{if (true) return new FloatLiteral(t.image, _range(t, t));}
4759	0	break;
4760	34	case DOUBLE_LITERAL:
4761	34	t = jj_consume_token(DOUBLE_LITERAL);
4762	34	{if (true) return new DoubleLiteral(t.image, _range(t, t));}
4763	0	break;
4764	8	case CHARACTER_LITERAL:
4765	8	t = jj_consume_token(CHARACTER_LITERAL);
4766	8	{if (true) return new CharacterLiteral(t.image, _range(t, t));}
4767	0	break;
4768	387	case STRING_LITERAL:
4769	387	t = jj_consume_token(STRING_LITERAL);
4770	387	{if (true) return new StringLiteral(t.image, _range(t, t));}
4771	0	break;
4772	34	case TRUE:
4773	34	t = jj_consume_token(TRUE);
4774	34	{if (true) return new BooleanLiteral(true, _range(t, t));}
4775	0	break;
4776	52	case FALSE:
4777	52	t = jj_consume_token(FALSE);
4778	52	{if (true) return new BooleanLiteral(false, _range(t, t));}
4779	0	break;
4780	10	case NULL:
4781	10	t = jj_consume_token(NULL);
4782	10	{if (true) return new NullLiteral(_range(t, t));}
4783	0	break;
4784	0	default:
4785	0	jj_la1[129] = jj_gen;
4786	0	jj_consume_token(-1);
4787	0	throw new ParseException();
4788		}
4789		} catch (ParseException pe) {
4790	0	_throwParseException(pe, "This is an illegal literal!");
4791		}
4792	0	throw new Error("Missing return statement in function");
4793		}
4794
4795		// Productions for Types ///////////////////////////////////////////////////////////
4796
4797		/**
4798		* Used internally to parse types
4799		*/
4800	1791	final public TypeName type() throws ParseException {
4801	1791	int dim = 0;
4802	1791	TypeName pt = null;
4803	1791	Token t = null;
4804	1791	TypeName rt = null;
4805	1791	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4806	232	case BOOLEAN:
4807	6	case BYTE:
4808	8	case CHAR:
4809	7	case DOUBLE:
4810	15	case FLOAT:
4811	356	case INT:
4812	3	case LONG:
4813	6	case SHORT:
4814	633	pt = primitiveType();
4815	633	break;
4816	1158	case IDENTIFIER:
4817	1158	rt = referenceTypeName();
4818	1158	break;
4819	0	default:
4820	0	jj_la1[130] = jj_gen;
4821	0	jj_consume_token(-1);
4822	0	throw new ParseException();
4823		}
4824	1791	label_41:
4825		while (true) {
4826	1832	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4827	41	case LBRACKET:
4828		;
4829	41	break;
4830	1791	default:
4831	1791	jj_la1[131] = jj_gen;
4832	1791	break label_41;
4833		}
4834	41	jj_consume_token(LBRACKET);
4835	41	t = jj_consume_token(RBRACKET);
4836	41	dim++;
4837		}
4838	1791	if (pt != null) {
4839	633	rt = pt;
4840		}
4841	1791	if (dim == 0) {
4842	1751	{if (true) return rt;}
4843		} else {
4844	40	{if (true) return new ArrayTypeName(rt, dim, false, _range(rt, t));}
4845		}
4846	0	throw new Error("Missing return statement in function");
4847		}
4848
4849		/**
4850		* Used internally to parse types
4851		*/
4852	343	final public TypeName resultType() throws ParseException {
4853	343	TypeName typ;
4854	343	Token t;
4855	343	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4856	207	case VOID:
4857	207	t = jj_consume_token(VOID);
4858	207	{if (true) return new VoidTypeName(_range(t, t));}
4859	0	break;
4860	0	case BOOLEAN:
4861	0	case BYTE:
4862	0	case CHAR:
4863	0	case DOUBLE:
4864	0	case FLOAT:
4865	55	case INT:
4866	0	case LONG:
4867	0	case SHORT:
4868	81	case IDENTIFIER:
4869	136	typ = type();
4870	136	{if (true) return typ;}
4871	0	break;
4872	0	default:
4873	0	jj_la1[132] = jj_gen;
4874	0	jj_consume_token(-1);
4875	0	throw new ParseException();
4876		}
4877	0	throw new Error("Missing return statement in function");
4878		}
4879
4880		/**
4881		* Used internally to parse types
4882		*/
4883	662	final public PrimitiveTypeName primitiveType() throws ParseException {
4884	662	Token t;
4885	662	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4886	233	case BOOLEAN:
4887	233	t = jj_consume_token(BOOLEAN);
4888	233	{if (true) return new BooleanTypeName(_range(t, t));}
4889	0	break;
4890	9	case CHAR:
4891	9	t = jj_consume_token(CHAR);
4892	9	{if (true) return new CharTypeName(_range(t, t));}
4893	0	break;
4894	14	case BYTE:
4895	14	t = jj_consume_token(BYTE);
4896	14	{if (true) return new ByteTypeName(_range(t, t));}
4897	0	break;
4898	14	case SHORT:
4899	14	t = jj_consume_token(SHORT);
4900	14	{if (true) return new ShortTypeName(_range(t, t));}
4901	0	break;
4902	365	case INT:
4903	365	t = jj_consume_token(INT);
4904	365	{if (true) return new IntTypeName(_range(t, t));}
4905	0	break;
4906	4	case LONG:
4907	4	t = jj_consume_token(LONG);
4908	4	{if (true) return new LongTypeName(_range(t, t));}
4909	0	break;
4910	15	case FLOAT:
4911	15	t = jj_consume_token(FLOAT);
4912	15	{if (true) return new FloatTypeName(_range(t, t));}
4913	0	break;
4914	8	case DOUBLE:
4915	8	t = jj_consume_token(DOUBLE);
4916	8	{if (true) return new DoubleTypeName(_range(t, t));}
4917	0	break;
4918	0	default:
4919	0	jj_la1[133] = jj_gen;
4920	0	jj_consume_token(-1);
4921	0	throw new ParseException();
4922		}
4923	0	throw new Error("Missing return statement in function");
4924		}
4925
4926	69	final public List<TypeParameter> typeParameters() throws ParseException {
4927	69	List<TypeParameter> list = new LinkedList<TypeParameter>();
4928	69	TypeParameter temp;
4929	69	jj_consume_token(LESS);
4930	69	temp = typeParameter();
4931	69	list.add(temp);
4932	69	label_42:
4933		while (true) {
4934	69	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4935	0	case COMMA:
4936		;
4937	0	break;
4938	69	default:
4939	69	jj_la1[134] = jj_gen;
4940	69	break label_42;
4941		}
4942	0	jj_consume_token(COMMA);
4943	0	temp = typeParameter();
4944	0	list.add(temp);
4945		}
4946	69	RightAngledBracket();
4947	69	{if (true) return list;}
4948	0	throw new Error("Missing return statement in function");
4949		}
4950
4951	69	final public TypeParameter typeParameter() throws ParseException {
4952	69	List<IdentifierToken> name;
4953	69	TypeName bound = new ReferenceTypeName("java.lang.Object");
4954	69	List<ReferenceTypeName> interfaceBoundsList = new LinkedList<ReferenceTypeName>();
4955	69	ReferenceTypeName interf;
4956	69	name = name();
4957	69	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4958	23	case EXTENDS:
4959	23	jj_consume_token(EXTENDS);
4960	23	bound = type();
4961	23	label_43:
4962		while (true) {
4963	23	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4964	0	case BITWISE_AND:
4965		;
4966	0	break;
4967	23	default:
4968	23	jj_la1[135] = jj_gen;
4969	23	break label_43;
4970		}
4971	0	jj_consume_token(BITWISE_AND);
4972	0	interf = referenceTypeName();
4973	0	interfaceBoundsList.add(interf);
4974		}
4975	23	break;
4976	46	default:
4977	46	jj_la1[136] = jj_gen;
4978		;
4979		}
4980	69	IdentifierToken first = name.get(0);
4981	69	if(bound instanceof ReferenceTypeName){
4982	69	{if (true) return new TypeParameter(name, (ReferenceTypeName)bound, interfaceBoundsList, _range(name.get(0), token));}
4983		} else {
4984	0	{if (true) throw new ParseError("Primitives are not allowed as bound"+
4985		"types, and array types are temporarily disabled due to a "+
4986		"DynamicJava AST hierarchy bug!", first.getSourceInfo());}
4987		}
4988	0	throw new Error("Missing return statement in function");
4989		}
4990
4991	288	final public Option<List<TypeName>> optionalTypeArguments() throws ParseException {
4992	288	List<TypeName> targs = null;
4993	288	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
4994	0	case LESS:
4995	0	targs = typeArguments();
4996	0	break;
4997	288	default:
4998	288	jj_la1[137] = jj_gen;
4999		;
5000		}
5001	288	{if (true) return Option.wrap(targs);}
5002	0	throw new Error("Missing return statement in function");
5003		}
5004
5005	507	final public List<TypeName> typeArguments() throws ParseException {
5006	507	List<TypeName> typeArgs = new LinkedList<TypeName>();
5007	507	TypeName arg;
5008	507	jj_consume_token(LESS);
5009	507	arg = TypeArgument();
5010	507	typeArgs.add(arg);
5011	507	label_44:
5012		while (true) {
5013	507	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5014	0	case COMMA:
5015		;
5016	0	break;
5017	507	default:
5018	507	jj_la1[138] = jj_gen;
5019	507	break label_44;
5020		}
5021	0	jj_consume_token(COMMA);
5022	0	arg = TypeArgument();
5023	0	typeArgs.add(arg);
5024		}
5025	507	RightAngledBracket();
5026	507	{if (true) return typeArgs;}
5027	0	throw new Error("Missing return statement in function");
5028		}
5029
5030	507	final public TypeName TypeArgument() throws ParseException {
5031	507	Token hook; TypeName upper = null; TypeName lower = null;
5032	507	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5033	51	case HOOK:
5034	51	hook = jj_consume_token(HOOK);
5035	51	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5036	32	case EXTENDS:
5037	32	jj_consume_token(EXTENDS);
5038	32	upper = type();
5039	32	break;
5040	19	default:
5041	19	jj_la1[139] = jj_gen;
5042		;
5043		}
5044	51	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5045	22	case SUPER:
5046	22	jj_consume_token(SUPER);
5047	22	lower = type();
5048	22	break;
5049	29	default:
5050	29	jj_la1[140] = jj_gen;
5051		;
5052		}
5053	51	{if (true) return new HookTypeName(Option.wrap(upper), Option.wrap(lower), _range(hook, token));}
5054	0	break;
5055	0	case BOOLEAN:
5056	0	case BYTE:
5057	0	case CHAR:
5058	0	case DOUBLE:
5059	0	case FLOAT:
5060	1	case INT:
5061	0	case LONG:
5062	0	case SHORT:
5063	455	case IDENTIFIER:
5064	456	upper = type();
5065	456	{if (true) return upper;}
5066	0	break;
5067	0	default:
5068	0	jj_la1[141] = jj_gen;
5069	0	jj_consume_token(-1);
5070	0	throw new ParseException();
5071		}
5072	0	throw new Error("Missing return statement in function");
5073		}
5074
5075	576	final public Token RightAngledBracket() throws ParseException {
5076	576	Token t;
5077	576	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5078	511	case GREATER_THAN:
5079	511	t = jj_consume_token(GREATER_THAN);
5080	511	break;
5081	28	case RSSHIFT1:
5082	28	t = jj_consume_token(RSSHIFT1);
5083	28	break;
5084	28	case RSSHIFT2:
5085	28	t = jj_consume_token(RSSHIFT2);
5086	28	break;
5087	3	case RUSHIFT1:
5088	3	t = jj_consume_token(RUSHIFT1);
5089	3	break;
5090	3	case RUSHIFT2:
5091	3	t = jj_consume_token(RUSHIFT2);
5092	3	break;
5093	3	case RUSHIFT3:
5094	3	t = jj_consume_token(RUSHIFT3);
5095	3	break;
5096	0	default:
5097	0	jj_la1[142] = jj_gen;
5098	0	jj_consume_token(-1);
5099	0	throw new ParseException();
5100		}
5101	576	{if (true) return t;}
5102	0	throw new Error("Missing return statement in function");
5103		}
5104
5105		// Productions for Annotations /////////////////////////////////////////////////////
5106	8	final public Annotation annotation() throws ParseException {
5107	8	Token first;
5108	8	ReferenceTypeName type;
5109	8	Token id;
5110	8	Expression exp;
5111	8	List<Pair<String, Expression>> vals = new LinkedList<Pair<String, Expression>>();
5112	8	first = jj_consume_token(132);
5113	8	type = referenceTypeName();
5114	8	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5115	7	case LPAREN:
5116	7	jj_consume_token(LPAREN);
5117	7	if (jj_2_44(2)) {
5118	1	id = jj_consume_token(IDENTIFIER);
5119	1	jj_consume_token(ASSIGN);
5120	1	exp = annotationValue();
5121	1	vals.add(Pair.make(id.image, exp));
5122	1	label_45:
5123		while (true) {
5124	3	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5125	2	case COMMA:
5126		;
5127	2	break;
5128	1	default:
5129	1	jj_la1[143] = jj_gen;
5130	1	break label_45;
5131		}
5132	2	jj_consume_token(COMMA);
5133	2	id = jj_consume_token(IDENTIFIER);
5134	2	jj_consume_token(ASSIGN);
5135	2	exp = annotationValue();
5136	2	vals.add(Pair.make(id.image, exp));
5137		}
5138		} else {
5139	6	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5140	0	case BOOLEAN:
5141	0	case BYTE:
5142	0	case CHAR:
5143	0	case DOUBLE:
5144	0	case FALSE:
5145	0	case FLOAT:
5146	0	case INT:
5147	0	case LONG:
5148	0	case NEW:
5149	0	case NULL:
5150	0	case SHORT:
5151	0	case SUPER:
5152	0	case THIS:
5153	0	case TRUE:
5154	0	case VOID:
5155	2	case INTEGER_LITERAL:
5156	0	case LONG_LITERAL:
5157	0	case FLOAT_LITERAL:
5158	0	case DOUBLE_LITERAL:
5159	0	case CHARACTER_LITERAL:
5160	0	case STRING_LITERAL:
5161	0	case IDENTIFIER:
5162	0	case LPAREN:
5163	3	case LBRACE:
5164	0	case LESS:
5165	0	case BANG:
5166	0	case TILDE:
5167	0	case INCREMENT:
5168	0	case DECREMENT:
5169	0	case PLUS:
5170	0	case MINUS:
5171	1	case 132:
5172	6	exp = annotationValue();
5173	6	vals.add(Pair.make("value", exp));
5174	6	break;
5175	0	default:
5176	0	jj_la1[144] = jj_gen;
5177	0	jj_consume_token(-1);
5178	0	throw new ParseException();
5179		}
5180		}
5181	7	jj_consume_token(RPAREN);
5182	7	break;
5183	1	default:
5184	1	jj_la1[145] = jj_gen;
5185		;
5186		}
5187	8	{if (true) return new Annotation(type, vals, _range(first, token));}
5188	0	throw new Error("Missing return statement in function");
5189		}
5190
5191	15	final public Expression annotationValue() throws ParseException {
5192	15	Expression exp;
5193	15	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5194	0	case BOOLEAN:
5195	0	case BYTE:
5196	0	case CHAR:
5197	0	case DOUBLE:
5198	0	case FALSE:
5199	0	case FLOAT:
5200	0	case INT:
5201	0	case LONG:
5202	0	case NEW:
5203	0	case NULL:
5204	0	case SHORT:
5205	0	case SUPER:
5206	0	case THIS:
5207	0	case TRUE:
5208	0	case VOID:
5209	9	case INTEGER_LITERAL:
5210	0	case LONG_LITERAL:
5211	0	case FLOAT_LITERAL:
5212	0	case DOUBLE_LITERAL:
5213	0	case CHARACTER_LITERAL:
5214	2	case STRING_LITERAL:
5215	0	case IDENTIFIER:
5216	0	case LPAREN:
5217	0	case LESS:
5218	0	case BANG:
5219	0	case TILDE:
5220	0	case INCREMENT:
5221	0	case DECREMENT:
5222	0	case PLUS:
5223	0	case MINUS:
5224	11	exp = conditionalExpression();
5225	11	{if (true) return exp;}
5226	0	break;
5227	1	case 132:
5228	1	exp = annotation();
5229	1	{if (true) return exp;}
5230	0	break;
5231	3	case LBRACE:
5232	3	exp = annotationArrayValue();
5233	3	{if (true) return exp;}
5234	0	break;
5235	0	default:
5236	0	jj_la1[146] = jj_gen;
5237	0	jj_consume_token(-1);
5238	0	throw new ParseException();
5239		}
5240	0	throw new Error("Missing return statement in function");
5241		}
5242
5243	3	final public ArrayInitializer annotationArrayValue() throws ParseException {
5244	3	Token first; Expression val; List<Expression> vals = new LinkedList<Expression>();
5245	3	first = jj_consume_token(LBRACE);
5246	3	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5247	0	case BOOLEAN:
5248	0	case BYTE:
5249	0	case CHAR:
5250	0	case DOUBLE:
5251	0	case FALSE:
5252	0	case FLOAT:
5253	0	case INT:
5254	0	case LONG:
5255	0	case NEW:
5256	0	case NULL:
5257	0	case SHORT:
5258	0	case SUPER:
5259	0	case THIS:
5260	0	case TRUE:
5261	0	case VOID:
5262	2	case INTEGER_LITERAL:
5263	0	case LONG_LITERAL:
5264	0	case FLOAT_LITERAL:
5265	0	case DOUBLE_LITERAL:
5266	0	case CHARACTER_LITERAL:
5267	0	case STRING_LITERAL:
5268	0	case IDENTIFIER:
5269	0	case LPAREN:
5270	0	case LBRACE:
5271	0	case LESS:
5272	0	case BANG:
5273	0	case TILDE:
5274	0	case INCREMENT:
5275	0	case DECREMENT:
5276	0	case PLUS:
5277	0	case MINUS:
5278	0	case 132:
5279	2	val = annotationValue();
5280	2	vals.add(val);
5281	2	label_46:
5282		while (true) {
5283	6	if (jj_2_45(2)) {
5284		;
5285		} else {
5286	2	break label_46;
5287		}
5288	4	jj_consume_token(COMMA);
5289	4	val = annotationValue();
5290	4	vals.add(val);
5291		}
5292	2	break;
5293	1	default:
5294	1	jj_la1[147] = jj_gen;
5295		;
5296		}
5297	3	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5298	1	case COMMA:
5299	1	jj_consume_token(COMMA);
5300	1	break;
5301	2	default:
5302	2	jj_la1[148] = jj_gen;
5303		;
5304		}
5305	3	jj_consume_token(RBRACE);
5306	3	{if (true) return new ArrayInitializer(vals, _range(first, token));}
5307	0	throw new Error("Missing return statement in function");
5308		}
5309
5310		// Lookahead productions ////////////////////////////////////////////////////////
5311
5312		/** Distinguish a cast expression from a parenthesized expression. */
5313	0	final public void castLookahead() throws ParseException {
5314	0	jj_consume_token(LPAREN);
5315	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5316	0	case BOOLEAN:
5317	0	case BYTE:
5318	0	case CHAR:
5319	0	case DOUBLE:
5320	0	case FLOAT:
5321	0	case INT:
5322	0	case LONG:
5323	0	case SHORT:
5324	0	primitiveType();
5325	0	break;
5326	0	case IDENTIFIER:
5327	0	type();
5328	0	jj_consume_token(RPAREN);
5329	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5330	0	case TILDE:
5331	0	jj_consume_token(TILDE);
5332	0	break;
5333	0	case BANG:
5334	0	jj_consume_token(BANG);
5335	0	break;
5336	0	case LPAREN:
5337	0	jj_consume_token(LPAREN);
5338	0	break;
5339	0	case IDENTIFIER:
5340	0	jj_consume_token(IDENTIFIER);
5341	0	break;
5342	0	case THIS:
5343	0	jj_consume_token(THIS);
5344	0	break;
5345	0	case SUPER:
5346	0	jj_consume_token(SUPER);
5347	0	break;
5348	0	case NEW:
5349	0	jj_consume_token(NEW);
5350	0	break;
5351	0	case FALSE:
5352	0	case NULL:
5353	0	case TRUE:
5354	0	case INTEGER_LITERAL:
5355	0	case LONG_LITERAL:
5356	0	case FLOAT_LITERAL:
5357	0	case DOUBLE_LITERAL:
5358	0	case CHARACTER_LITERAL:
5359	0	case STRING_LITERAL:
5360	0	literal();
5361	0	break;
5362	0	default:
5363	0	jj_la1[149] = jj_gen;
5364	0	jj_consume_token(-1);
5365	0	throw new ParseException();
5366		}
5367	0	break;
5368	0	default:
5369	0	jj_la1[150] = jj_gen;
5370	0	jj_consume_token(-1);
5371	0	throw new ParseException();
5372		}
5373		}
5374
5375		/** Distinguish an unmodified constructor declaration from other declarations. */
5376	0	final public void constructorLookahead() throws ParseException {
5377	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5378	0	case LESS:
5379	0	typeParameters();
5380	0	break;
5381	0	default:
5382	0	jj_la1[151] = jj_gen;
5383		;
5384		}
5385	0	jj_consume_token(IDENTIFIER);
5386	0	jj_consume_token(LPAREN);
5387		}
5388
5389		/** Distinguish an unmodified method declaration from other declarations. */
5390	0	final public void methodLookahead() throws ParseException {
5391	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5392	0	case LESS:
5393	0	typeParameters();
5394	0	break;
5395	0	default:
5396	0	jj_la1[152] = jj_gen;
5397		;
5398		}
5399	0	resultType();
5400	0	jj_consume_token(IDENTIFIER);
5401	0	jj_consume_token(LPAREN);
5402		}
5403
5404		/** Distinguish an unmodified variable or field declaration from other declarations. */
5405	0	final public void variableLookahead() throws ParseException {
5406	0	type();
5407	0	jj_consume_token(IDENTIFIER);
5408	0	switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
5409	0	case LBRACKET:
5410	0	jj_consume_token(LBRACKET);
5411	0	break;
5412	0	case ASSIGN:
5413	0	jj_consume_token(ASSIGN);
5414	0	break;
5415	0	case COMMA:
5416	0	jj_consume_token(COMMA);
5417	0	break;
5418	0	case SEMICOLON:
5419	0	jj_consume_token(SEMICOLON);
5420	0	break;
5421	0	case RBRACE:
5422	0	jj_consume_token(RBRACE);
5423	0	break;
5424	0	case 0:
5425	0	jj_consume_token(0);
5426	0	break;
5427	0	default:
5428	0	jj_la1[153] = jj_gen;
5429	0	jj_consume_token(-1);
5430	0	throw new ParseException();
5431		}
5432		}
5433
5434	1798	final private boolean jj_2_1(int xla) {
5435	1798	jj_la = xla; jj_lastpos = jj_scanpos = token;
5436	1798	try { return !jj_3_1(); }
5437	1005	catch(LookaheadSuccess ls) { return true; }
5438	1798	finally { jj_save(0, xla); }
5439		}
5440
5441	8	final private boolean jj_2_2(int xla) {
5442	8	jj_la = xla; jj_lastpos = jj_scanpos = token;
5443	8	try { return !jj_3_2(); }
5444	0	catch(LookaheadSuccess ls) { return true; }
5445	8	finally { jj_save(1, xla); }
5446		}
5447
5448	7	final private boolean jj_2_3(int xla) {
5449	7	jj_la = xla; jj_lastpos = jj_scanpos = token;
5450	7	try { return !jj_3_3(); }
5451	0	catch(LookaheadSuccess ls) { return true; }
5452	7	finally { jj_save(2, xla); }
5453		}
5454
5455	847	final private boolean jj_2_4(int xla) {
5456	847	jj_la = xla; jj_lastpos = jj_scanpos = token;
5457	847	try { return !jj_3_4(); }
5458	0	catch(LookaheadSuccess ls) { return true; }
5459	847	finally { jj_save(3, xla); }
5460		}
5461
5462	664	final private boolean jj_2_5(int xla) {
5463	664	jj_la = xla; jj_lastpos = jj_scanpos = token;
5464	664	try { return !jj_3_5(); }
5465	0	catch(LookaheadSuccess ls) { return true; }
5466	664	finally { jj_save(4, xla); }
5467		}
5468
5469	223	final private boolean jj_2_6(int xla) {
5470	223	jj_la = xla; jj_lastpos = jj_scanpos = token;
5471	223	try { return !jj_3_6(); }
5472	223	catch(LookaheadSuccess ls) { return true; }
5473	223	finally { jj_save(5, xla); }
5474		}
5475
5476	1005	final private boolean jj_2_7(int xla) {
5477	1005	jj_la = xla; jj_lastpos = jj_scanpos = token;
5478	1005	try { return !jj_3_7(); }
5479	44	catch(LookaheadSuccess ls) { return true; }
5480	1005	finally { jj_save(6, xla); }
5481		}
5482
5483	959	final private boolean jj_2_8(int xla) {
5484	959	jj_la = xla; jj_lastpos = jj_scanpos = token;
5485	959	try { return !jj_3_8(); }
5486	9	catch(LookaheadSuccess ls) { return true; }
5487	959	finally { jj_save(7, xla); }
5488		}
5489
5490	950	final private boolean jj_2_9(int xla) {
5491	950	jj_la = xla; jj_lastpos = jj_scanpos = token;
5492	950	try { return !jj_3_9(); }
5493	950	catch(LookaheadSuccess ls) { return true; }
5494	950	finally { jj_save(8, xla); }
5495		}
5496
5497	261	final private boolean jj_2_10(int xla) {
5498	261	jj_la = xla; jj_lastpos = jj_scanpos = token;
5499	261	try { return !jj_3_10(); }
5500	0	catch(LookaheadSuccess ls) { return true; }
5501	261	finally { jj_save(9, xla); }
5502		}
5503
5504	69	final private boolean jj_2_11(int xla) {
5505	69	jj_la = xla; jj_lastpos = jj_scanpos = token;
5506	69	try { return !jj_3_11(); }
5507	0	catch(LookaheadSuccess ls) { return true; }
5508	69	finally { jj_save(10, xla); }
5509		}
5510
5511	2131	final private boolean jj_2_12(int xla) {
5512	2131	jj_la = xla; jj_lastpos = jj_scanpos = token;
5513	2131	try { return !jj_3_12(); }
5514	402	catch(LookaheadSuccess ls) { return true; }
5515	2131	finally { jj_save(11, xla); }
5516		}
5517
5518	251	final private boolean jj_2_13(int xla) {
5519	251	jj_la = xla; jj_lastpos = jj_scanpos = token;
5520	251	try { return !jj_3_13(); }
5521	0	catch(LookaheadSuccess ls) { return true; }
5522	251	finally { jj_save(12, xla); }
5523		}
5524
5525	182	final private boolean jj_2_14(int xla) {
5526	182	jj_la = xla; jj_lastpos = jj_scanpos = token;
5527	182	try { return !jj_3_14(); }
5528	0	catch(LookaheadSuccess ls) { return true; }
5529	182	finally { jj_save(13, xla); }
5530		}
5531
5532	23	final private boolean jj_2_15(int xla) {
5533	23	jj_la = xla; jj_lastpos = jj_scanpos = token;
5534	23	try { return !jj_3_15(); }
5535	0	catch(LookaheadSuccess ls) { return true; }
5536	23	finally { jj_save(14, xla); }
5537		}
5538
5539	251	final private boolean jj_2_16(int xla) {
5540	251	jj_la = xla; jj_lastpos = jj_scanpos = token;
5541	251	try { return !jj_3_16(); }
5542	0	catch(LookaheadSuccess ls) { return true; }
5543	251	finally { jj_save(15, xla); }
5544		}
5545
5546	138	final private boolean jj_2_17(int xla) {
5547	138	jj_la = xla; jj_lastpos = jj_scanpos = token;
5548	138	try { return !jj_3_17(); }
5549	69	catch(LookaheadSuccess ls) { return true; }
5550	138	finally { jj_save(16, xla); }
5551		}
5552
5553	0	final private boolean jj_2_18(int xla) {
5554	0	jj_la = xla; jj_lastpos = jj_scanpos = token;
5555	0	try { return !jj_3_18(); }
5556	0	catch(LookaheadSuccess ls) { return true; }
5557	0	finally { jj_save(17, xla); }
5558		}
5559
5560	0	final private boolean jj_2_19(int xla) {
5561	0	jj_la = xla; jj_lastpos = jj_scanpos = token;
5562	0	try { return !jj_3_19(); }
5563	0	catch(LookaheadSuccess ls) { return true; }
5564	0	finally { jj_save(18, xla); }
5565		}
5566
5567	0	final private boolean jj_2_20(int xla) {
5568	0	jj_la = xla; jj_lastpos = jj_scanpos = token;
5569	0	try { return !jj_3_20(); }
5570	0	catch(LookaheadSuccess ls) { return true; }
5571	0	finally { jj_save(19, xla); }
5572		}
5573
5574	41	final private boolean jj_2_21(int xla) {
5575	41	jj_la = xla; jj_lastpos = jj_scanpos = token;
5576	41	try { return !jj_3_21(); }
5577	28	catch(LookaheadSuccess ls) { return true; }
5578	41	finally { jj_save(20, xla); }
5579		}
5580
5581	1215	final private boolean jj_2_22(int xla) {
5582	1215	jj_la = xla; jj_lastpos = jj_scanpos = token;
5583	1215	try { return !jj_3_22(); }
5584	728	catch(LookaheadSuccess ls) { return true; }
5585	1215	finally { jj_save(21, xla); }
5586		}
5587
5588	0	final private boolean jj_2_23(int xla) {
5589	0	jj_la = xla; jj_lastpos = jj_scanpos = token;
5590	0	try { return !jj_3_23(); }
5591	0	catch(LookaheadSuccess ls) { return true; }
5592	0	finally { jj_save(22, xla); }
5593		}
5594
5595	358	final private boolean jj_2_24(int xla) {
5596	358	jj_la = xla; jj_lastpos = jj_scanpos = token;
5597	358	try { return !jj_3_24(); }
5598	0	catch(LookaheadSuccess ls) { return true; }
5599	358	finally { jj_save(23, xla); }
5600		}
5601
5602	249	final private boolean jj_2_25(int xla) {
5603	249	jj_la = xla; jj_lastpos = jj_scanpos = token;
5604	249	try { return !jj_3_25(); }
5605	249	catch(LookaheadSuccess ls) { return true; }
5606	249	finally { jj_save(24, xla); }
5607		}
5608
5609	801	final private boolean jj_2_26(int xla) {
5610	801	jj_la = xla; jj_lastpos = jj_scanpos = token;
5611	801	try { return !jj_3_26(); }
5612	432	catch(LookaheadSuccess ls) { return true; }
5613	801	finally { jj_save(25, xla); }
5614		}
5615
5616	358	final private boolean jj_2_27(int xla) {
5617	358	jj_la = xla; jj_lastpos = jj_scanpos = token;
5618	358	try { return !jj_3_27(); }
5619	0	catch(LookaheadSuccess ls) { return true; }
5620	358	finally { jj_save(26, xla); }
5621		}
5622
5623	358	final private boolean jj_2_28(int xla) {
5624	358	jj_la = xla; jj_lastpos = jj_scanpos = token;
5625	358	try { return !jj_3_28(); }
5626	358	catch(LookaheadSuccess ls) { return true; }
5627	358	finally { jj_save(27, xla); }
5628		}
5629
5630	11	final private boolean jj_2_29(int xla) {
5631	11	jj_la = xla; jj_lastpos = jj_scanpos = token;
5632	11	try { return !jj_3_29(); }
5633	11	catch(LookaheadSuccess ls) { return true; }
5634	11	finally { jj_save(28, xla); }
5635		}
5636
5637	483	final private boolean jj_2_30(int xla) {
5638	483	jj_la = xla; jj_lastpos = jj_scanpos = token;
5639	483	try { return !jj_3_30(); }
5640	1	catch(LookaheadSuccess ls) { return true; }
5641	483	finally { jj_save(29, xla); }
5642		}
5643
5644	482	final private boolean jj_2_31(int xla) {
5645	482	jj_la = xla; jj_lastpos = jj_scanpos = token;
5646	482	try { return !jj_3_31(); }
5647	482	catch(LookaheadSuccess ls) { return true; }
5648	482	finally { jj_save(30, xla); }
5649		}
5650
5651	7	final private boolean jj_2_32(int xla) {
5652	7	jj_la = xla; jj_lastpos = jj_scanpos = token;
5653	7	try { return !jj_3_32(); }
5654	4	catch(LookaheadSuccess ls) { return true; }
5655	7	finally { jj_save(31, xla); }
5656		}
5657
5658	0	final private boolean jj_2_33(int xla) {
5659	0	jj_la = xla; jj_lastpos = jj_scanpos = token;
5660	0	try { return !jj_3_33(); }
5661	0	catch(LookaheadSuccess ls) { return true; }
5662	0	finally { jj_save(32, xla); }
5663		}
5664
5665	0	final private boolean jj_2_34(int xla) {
5666	0	jj_la = xla; jj_lastpos = jj_scanpos = token;
5667	0	try { return !jj_3_34(); }
5668	0	catch(LookaheadSuccess ls) { return true; }
5669	0	finally { jj_save(33, xla); }
5670		}
5671
5672	119	final private boolean jj_2_35(int xla) {
5673	119	jj_la = xla; jj_lastpos = jj_scanpos = token;
5674	119	try { return !jj_3_35(); }
5675	0	catch(LookaheadSuccess ls) { return true; }
5676	119	finally { jj_save(34, xla); }
5677		}
5678
5679	112	final private boolean jj_2_36(int xla) {
5680	112	jj_la = xla; jj_lastpos = jj_scanpos = token;
5681	112	try { return !jj_3_36(); }
5682	0	catch(LookaheadSuccess ls) { return true; }
5683	112	finally { jj_save(35, xla); }
5684		}
5685
5686	222	final private boolean jj_2_37(int xla) {
5687	222	jj_la = xla; jj_lastpos = jj_scanpos = token;
5688	222	try { return !jj_3_37(); }
5689	0	catch(LookaheadSuccess ls) { return true; }
5690	222	finally { jj_save(36, xla); }
5691		}
5692
5693	3063	final private boolean jj_2_38(int xla) {
5694	3063	jj_la = xla; jj_lastpos = jj_scanpos = token;
5695	3063	try { return !jj_3_38(); }
5696	0	catch(LookaheadSuccess ls) { return true; }
5697	3063	finally { jj_save(37, xla); }
5698		}
5699
5700	16	final private boolean jj_2_39(int xla) {
5701	16	jj_la = xla; jj_lastpos = jj_scanpos = token;
5702	16	try { return !jj_3_39(); }
5703	14	catch(LookaheadSuccess ls) { return true; }
5704	16	finally { jj_save(38, xla); }
5705		}
5706
5707	4652	final private boolean jj_2_40(int xla) {
5708	4652	jj_la = xla; jj_lastpos = jj_scanpos = token;
5709	4652	try { return !jj_3_40(); }
5710	0	catch(LookaheadSuccess ls) { return true; }
5711	4652	finally { jj_save(39, xla); }
5712		}
5713
5714	1	final private boolean jj_2_41(int xla) {
5715	1	jj_la = xla; jj_lastpos = jj_scanpos = token;
5716	1	try { return !jj_3_41(); }
5717	0	catch(LookaheadSuccess ls) { return true; }
5718	1	finally { jj_save(40, xla); }
5719		}
5720
5721	1	final private boolean jj_2_42(int xla) {
5722	1	jj_la = xla; jj_lastpos = jj_scanpos = token;
5723	1	try { return !jj_3_42(); }
5724	0	catch(LookaheadSuccess ls) { return true; }
5725	1	finally { jj_save(41, xla); }
5726		}
5727
5728	14	final private boolean jj_2_43(int xla) {
5729	14	jj_la = xla; jj_lastpos = jj_scanpos = token;
5730	14	try { return !jj_3_43(); }
5731	1	catch(LookaheadSuccess ls) { return true; }
5732	14	finally { jj_save(42, xla); }
5733		}
5734
5735	7	final private boolean jj_2_44(int xla) {
5736	7	jj_la = xla; jj_lastpos = jj_scanpos = token;
5737	7	try { return !jj_3_44(); }
5738	1	catch(LookaheadSuccess ls) { return true; }
5739	7	finally { jj_save(43, xla); }
5740		}
5741
5742	6	final private boolean jj_2_45(int xla) {
5743	6	jj_la = xla; jj_lastpos = jj_scanpos = token;
5744	6	try { return !jj_3_45(); }
5745	4	catch(LookaheadSuccess ls) { return true; }
5746	6	finally { jj_save(44, xla); }
5747		}
5748
5749	782	final private boolean jj_3R_184() {
5750	782	if (jj_3R_195()) return true;
5751	0	return false;
5752		}
5753
5754	3766	final private boolean jj_3R_183() {
5755	3766	Token xsp;
5756	3766	xsp = jj_scanpos;
5757	3766	if (jj_scan_token(132)) jj_scanpos = xsp;
5758	3764	if (jj_scan_token(INTERFACE)) return true;
5759	0	return false;
5760		}
5761
5762	782	final private boolean jj_3R_164() {
5763	782	Token xsp;
5764	782	xsp = jj_scanpos;
5765	782	if (jj_3R_184()) {
5766	782	jj_scanpos = xsp;
5767	782	if (jj_3R_185()) {
5768	782	jj_scanpos = xsp;
5769	396	if (jj_3R_186()) return true;
5770		}
5771		}
5772	0	return false;
5773		}
5774
5775	8745	final private boolean jj_3R_127() {
5776	8707	if (jj_scan_token(SHORT)) return true;
5777	26	return false;
5778		}
5779
5780	222	final private boolean jj_3_37() {
5781	222	Token xsp;
5782	222	xsp = jj_scanpos;
5783	222	if (jj_scan_token(0)) {
5784	195	jj_scanpos = xsp;
5785	195	if (jj_scan_token(83)) return true;
5786		}
5787	27	return false;
5788		}
5789
5790	8783	final private boolean jj_3R_126() {
5791	8745	if (jj_scan_token(BYTE)) return true;
5792	26	return false;
5793		}
5794
5795	4537	final private boolean jj_3R_145() {
5796	4537	if (jj_scan_token(ASSERT)) return true;
5797	0	if (jj_3R_90()) return true;
5798	0	return false;
5799		}
5800
5801	1854	final private boolean jj_3R_233() {
5802	1854	if (jj_scan_token(MINUS)) return true;
5803	0	return false;
5804		}
5805
5806	8815	final private boolean jj_3R_125() {
5807	8783	if (jj_scan_token(CHAR)) return true;
5808	16	return false;
5809		}
5810
5811	1854	final private boolean jj_3R_232() {
5812	1854	if (jj_scan_token(PLUS)) return true;
5813	0	return false;
5814		}
5815
5816	3944	final private boolean jj_3R_181() {
5817	3766	if (jj_scan_token(CLASS)) return true;
5818	0	return false;
5819		}
5820
5821	1854	final private boolean jj_3R_231() {
5822	1854	Token xsp;
5823	1854	xsp = jj_scanpos;
5824	1854	if (jj_3R_232()) {
5825	1854	jj_scanpos = xsp;
5826	1854	if (jj_3R_233()) {
5827	1854	jj_scanpos = xsp;
5828	1850	if (jj_3R_234()) {
5829	1850	jj_scanpos = xsp;
5830	1850	if (jj_3R_235()) {
5831	1850	jj_scanpos = xsp;
5832	1366	if (jj_3R_236()) return true;
5833		}
5834		}
5835		}
5836		}
5837	0	return false;
5838		}
5839
5840	1849	final private boolean jj_3R_90() {
5841	1365	if (jj_3R_133()) return true;
5842	0	return false;
5843		}
5844
5845	0	final private boolean jj_3R_173() {
5846	0	if (true) { jj_la = 0; jj_scanpos = jj_lastpos; return false;}
5847	0	return false;
5848		}
5849
5850	9011	final private boolean jj_3R_88() {
5851	9011	Token xsp;
5852	9011	xsp = jj_scanpos;
5853	9011	if (jj_3R_124()) {
5854	8815	jj_scanpos = xsp;
5855	8815	if (jj_3R_125()) {
5856	8783	jj_scanpos = xsp;
5857	8783	if (jj_3R_126()) {
5858	8745	jj_scanpos = xsp;
5859	8745	if (jj_3R_127()) {
5860	8707	jj_scanpos = xsp;
5861	8707	if (jj_3R_128()) {
5862	8033	jj_scanpos = xsp;
5863	8033	if (jj_3R_129()) {
5864	8021	jj_scanpos = xsp;
5865	8021	if (jj_3R_130()) {
5866	7961	jj_scanpos = xsp;
5867	7933	if (jj_3R_131()) return true;
5868		}
5869		}
5870		}
5871		}
5872		}
5873		}
5874		}
5875	674	return false;
5876		}
5877
5878	9011	final private boolean jj_3R_124() {
5879	8815	if (jj_scan_token(BOOLEAN)) return true;
5880	98	return false;
5881		}
5882
5883	664	final private boolean jj_3_5() {
5884	223	if (jj_3R_49()) return true;
5885	441	return false;
5886		}
5887
5888	847	final private boolean jj_3_4() {
5889	664	if (jj_3R_48()) return true;
5890	183	return false;
5891		}
5892
5893	2951	final private boolean jj_3R_139() {
5894	847	if (jj_3R_94()) return true;
5895	812	return false;
5896		}
5897
5898	0	final private boolean jj_3R_179() {
5899	0	Token xsp;
5900	0	xsp = jj_scanpos;
5901	0	if (jj_scan_token(86)) {
5902	0	jj_scanpos = xsp;
5903	0	lookingAhead = true;
5904	0	jj_semLA = !opt.requireSemicolon();
5905	0	lookingAhead = false;
5906	0	if (!jj_semLA \|\| jj_scan_token(0)) return true;
5907		}
5908	0	return false;
5909		}
5910
5911	7	final private boolean jj_3_3() {
5912	0	if (jj_3R_49()) return true;
5913	7	return false;
5914		}
5915
5916	8	final private boolean jj_3_2() {
5917	7	if (jj_3R_48()) return true;
5918	1	return false;
5919		}
5920
5921	1052	final private boolean jj_3_6() {
5922	793	if (jj_3R_50()) return true;
5923	0	return false;
5924		}
5925
5926	829	final private boolean jj_3R_62() {
5927	829	if (jj_3R_112()) return true;
5928	0	return false;
5929		}
5930
5931	2487	final private boolean jj_3R_61() {
5932	829	if (jj_3R_111()) return true;
5933	0	return false;
5934		}
5935
5936	2667	final private boolean jj_3R_60() {
5937	2487	if (jj_3R_110()) return true;
5938	0	return false;
5939		}
5940
5941	1667	final private boolean jj_3R_121() {
5942	1352	if (jj_3R_90()) return true;
5943	0	return false;
5944		}
5945
5946	2691	final private boolean jj_3R_59() {
5947	2667	if (jj_3R_113()) return true;
5948	0	return false;
5949		}
5950
5951	4937	final private boolean jj_3R_144() {
5952	4537	if (jj_scan_token(IF)) return true;
5953	200	Token xsp;
5954	200	xsp = jj_scanpos;
5955	0	if (jj_scan_token(80)) {
5956	0	jj_scanpos = xsp;
5957	0	if (jj_3R_173()) return true;
5958		}
5959	0	return false;
5960		}
5961
5962	782	final private boolean jj_3R_120() {
5963	396	if (jj_3R_164()) return true;
5964	0	return false;
5965		}
5966
5967	2693	final private boolean jj_3R_58() {
5968	2691	if (jj_3R_109()) return true;
5969	0	return false;
5970		}
5971
5972	3524	final private boolean jj_3R_93() {
5973	3524	Token xsp;
5974	3524	xsp = jj_scanpos;
5975	3524	if (jj_3R_138()) {
5976	2951	jj_scanpos = xsp;
5977	847	if (jj_3R_139()) return true;
5978		}
5979	1019	return false;
5980		}
5981
5982	3524	final private boolean jj_3R_138() {
5983	2951	if (jj_scan_token(VOID)) return true;
5984	207	return false;
5985		}
5986
5987	0	final private boolean jj_3R_56() {
5988	0	if (jj_3R_112()) return true;
5989	0	return false;
5990		}
5991
5992	2693	final private boolean jj_3_9() {
5993	0	if (jj_3R_57()) return true;
5994	2693	Token xsp;
5995	2693	xsp = jj_scanpos;
5996	2691	if (jj_3R_58()) {
5997	2691	jj_scanpos = xsp;
5998	2667	if (jj_3R_59()) {
5999	2667	jj_scanpos = xsp;
6000	2487	if (jj_3R_60()) {
6001	2487	jj_scanpos = xsp;
6002	829	if (jj_3R_61()) {
6003	829	jj_scanpos = xsp;
6004	829	if (jj_3R_62()) {
6005	829	jj_scanpos = xsp;
6006	793	if (jj_3_6()) return true;
6007		}
6008		}
6009		}
6010		}
6011		}
6012	0	return false;
6013		}
6014
6015	0	final private boolean jj_3R_55() {
6016	0	if (jj_3R_111()) return true;
6017	0	return false;
6018		}
6019
6020	2053	final private boolean jj_3R_85() {
6021	2053	Token xsp;
6022	2053	xsp = jj_scanpos;
6023	2053	lookingAhead = true;
6024	2053	jj_semLA = lookaheadFlag;
6025	2053	lookingAhead = false;
6026	1667	if (!jj_semLA \|\| jj_3R_120()) {
6027	1667	jj_scanpos = xsp;
6028	1352	if (jj_3R_121()) return true;
6029		}
6030	0	return false;
6031		}
6032
6033	1854	final private boolean jj_3R_230() {
6034	1366	if (jj_3R_231()) return true;
6035	0	return false;
6036		}
6037
6038	0	final private boolean jj_3R_54() {
6039	0	if (jj_3R_110()) return true;
6040	0	return false;
6041		}
6042
6043	0	final private boolean jj_3R_53() {
6044	0	if (jj_3R_109()) return true;
6045	0	return false;
6046		}
6047
6048	2711	final private boolean jj_3_8() {
6049	2693	if (jj_3R_52()) return true;
6050	0	Token xsp;
6051	0	xsp = jj_scanpos;
6052	0	if (jj_3R_53()) {
6053	0	jj_scanpos = xsp;
6054	0	if (jj_3R_54()) {
6055	0	jj_scanpos = xsp;
6056	0	if (jj_3R_55()) {
6057	0	jj_scanpos = xsp;
6058	0	if (jj_3R_56()) return true;
6059		}
6060		}
6061		}
6062	0	return false;
6063		}
6064
6065	2803	final private boolean jj_3_7() {
6066	2711	if (jj_3R_51()) return true;
6067	2	return false;
6068		}
6069
6070	138	final private boolean jj_3_17() {
6071	69	if (jj_3R_77()) return true;
6072	0	return false;
6073		}
6074
6075	1798	final private boolean jj_3R_47() {
6076	1798	Token xsp;
6077	1798	xsp = jj_scanpos;
6078	1752	if (jj_3_7()) {
6079	1752	jj_scanpos = xsp;
6080	1743	if (jj_3_8()) {
6081	1743	jj_scanpos = xsp;
6082	793	if (jj_3_9()) return true;
6083		}
6084		}
6085	0	return false;
6086		}
6087
6088	4963	final private boolean jj_3R_143() {
6089	4937	if (jj_scan_token(SEMICOLON)) return true;
6090	13	return false;
6091		}
6092
6093	2646	final private boolean jj_3R_142() {
6094	2634	if (jj_scan_token(LBRACKET)) return true;
6095	2	if (jj_scan_token(RBRACKET)) return true;
6096	10	return false;
6097		}
6098
6099	5931	final private boolean jj_3R_141() {
6100	2445	if (jj_3R_160()) return true;
6101	1990	return false;
6102		}
6103
6104	6981	final private boolean jj_3R_140() {
6105	5931	if (jj_3R_88()) return true;
6106	646	return false;
6107		}
6108
6109	6981	final private boolean jj_3R_94() {
6110	6981	Token xsp;
6111	6981	xsp = jj_scanpos;
6112	6981	if (jj_3R_140()) {
6113	5931	jj_scanpos = xsp;
6114	2445	if (jj_3R_141()) return true;
6115		}
6116	2636	while (true) {
6117	2646	xsp = jj_scanpos;
6118	2636	if (jj_3R_142()) { jj_scanpos = xsp; break; }
6119		}
6120	2636	return false;
6121		}
6122
6123	1854	final private boolean jj_3R_229() {
6124	1366	if (jj_3R_230()) return true;
6125	0	return false;
6126		}
6127
6128	1798	final private boolean jj_3_1() {
6129	793	if (jj_3R_47()) return true;
6130	0	return false;
6131		}
6132
6133	0	final private boolean jj_3R_180() {
6134	0	if (true) { jj_la = 0; jj_scanpos = jj_lastpos; return false;}
6135	0	return false;
6136		}
6137
6138	236	final private boolean jj_3R_211() {
6139	230	if (jj_3R_132()) return true;
6140	6	return false;
6141		}
6142
6143	3991	final private boolean jj_3R_155() {
6144	3989	if (jj_scan_token(TRY)) return true;
6145	0	if (jj_3R_116()) return true;
6146	0	return false;
6147		}
6148
6149	4357	final private boolean jj_3_12() {
6150	3700	if (jj_scan_token(DOT)) return true;
6151	19	if (jj_scan_token(IDENTIFIER)) return true;
6152	236	Token xsp;
6153	236	xsp = jj_scanpos;
6154	230	if (jj_3R_211()) jj_scanpos = xsp;
6155	236	return false;
6156		}
6157
6158	2465	final private boolean jj_3R_84() {
6159	1644	if (jj_scan_token(IDENTIFIER)) return true;
6160	409	if (jj_scan_token(COLON)) return true;
6161	0	return false;
6162		}
6163
6164	1990	final private boolean jj_3R_193() {
6165	1511	if (jj_3R_132()) return true;
6166	479	return false;
6167		}
6168
6169	1995	final private boolean jj_3R_206() {
6170	1995	if (jj_scan_token(NULL)) return true;
6171	0	return false;
6172		}
6173
6174	5938	final private boolean jj_3R_160() {
6175	2445	if (jj_scan_token(IDENTIFIER)) return true;
6176	1990	Token xsp;
6177	1990	xsp = jj_scanpos;
6178	1511	if (jj_3R_193()) jj_scanpos = xsp;
6179	1990	while (true) {
6180	2226	xsp = jj_scanpos;
6181	1990	if (jj_3_12()) { jj_scanpos = xsp; break; }
6182		}
6183	1990	return false;
6184		}
6185
6186	2053	final private boolean jj_3_31() {
6187	1352	if (jj_3R_85()) return true;
6188	0	return false;
6189		}
6190
6191	1982	final private boolean jj_3R_50() {
6192	1982	Token xsp;
6193	1982	xsp = jj_scanpos;
6194	1571	if (jj_3_30()) {
6195	1571	jj_scanpos = xsp;
6196	1352	if (jj_3_31()) return true;
6197		}
6198	0	return false;
6199		}
6200
6201	2465	final private boolean jj_3_30() {
6202	2053	if (jj_3R_84()) return true;
6203	0	return false;
6204		}
6205
6206	1995	final private boolean jj_3R_205() {
6207	1995	if (jj_scan_token(FALSE)) return true;
6208	0	return false;
6209		}
6210
6211	3991	final private boolean jj_3R_108() {
6212	3989	if (jj_3R_155()) return true;
6213	0	return false;
6214		}
6215
6216	1854	final private boolean jj_3R_228() {
6217	1366	if (jj_3R_229()) return true;
6218	0	return false;
6219		}
6220
6221	1996	final private boolean jj_3R_204() {
6222	1995	if (jj_scan_token(TRUE)) return true;
6223	0	return false;
6224		}
6225
6226	251	final private boolean jj_3R_76() {
6227	251	Token xsp;
6228	251	xsp = jj_scanpos;
6229	251	if (jj_scan_token(53)) jj_scanpos = xsp;
6230	251	if (jj_3R_116()) return true;
6231	0	return false;
6232		}
6233
6234	3993	final private boolean jj_3R_107() {
6235	3991	if (jj_3R_154()) return true;
6236	0	return false;
6237		}
6238
6239	3993	final private boolean jj_3R_154() {
6240	3991	if (jj_scan_token(SYNCHRONIZED)) return true;
6241	1	Token xsp;
6242	1	xsp = jj_scanpos;
6243	0	if (jj_scan_token(80)) {
6244	0	jj_scanpos = xsp;
6245	0	if (jj_3R_180()) return true;
6246		}
6247	0	return false;
6248		}
6249
6250	3999	final private boolean jj_3R_106() {
6251	3993	if (jj_3R_153()) return true;
6252	0	return false;
6253		}
6254
6255	4273	final private boolean jj_3R_105() {
6256	3999	if (jj_3R_152()) return true;
6257	0	return false;
6258		}
6259
6260	4275	final private boolean jj_3R_104() {
6261	4273	if (jj_3R_151()) return true;
6262	0	return false;
6263		}
6264
6265	4281	final private boolean jj_3R_103() {
6266	4275	if (jj_3R_150()) return true;
6267	0	return false;
6268		}
6269
6270	2014	final private boolean jj_3R_203() {
6271	1996	if (jj_scan_token(STRING_LITERAL)) return true;
6272	0	return false;
6273		}
6274
6275	4519	final private boolean jj_3R_102() {
6276	4281	if (jj_3R_149()) return true;
6277	0	return false;
6278		}
6279
6280	4521	final private boolean jj_3R_101() {
6281	4519	if (jj_3R_148()) return true;
6282	0	return false;
6283		}
6284
6285	4529	final private boolean jj_3R_100() {
6286	4521	if (jj_3R_147()) return true;
6287	0	return false;
6288		}
6289
6290	4537	final private boolean jj_3R_99() {
6291	4529	if (jj_3R_146()) return true;
6292	0	return false;
6293		}
6294
6295	4537	final private boolean jj_3R_98() {
6296	4537	if (jj_3R_145()) return true;
6297	0	return false;
6298		}
6299
6300	2014	final private boolean jj_3R_202() {
6301	2014	if (jj_scan_token(CHARACTER_LITERAL)) return true;
6302	0	return false;
6303		}
6304
6305	4937	final private boolean jj_3R_97() {
6306	4537	if (jj_3R_144()) return true;
6307	0	return false;
6308		}
6309
6310	4963	final private boolean jj_3R_96() {
6311	4937	if (jj_3R_143()) return true;
6312	13	return false;
6313		}
6314
6315	4970	final private boolean jj_3R_95() {
6316	4963	if (jj_3R_116()) return true;
6317	0	return false;
6318		}
6319
6320	2014	final private boolean jj_3R_201() {
6321	2014	if (jj_scan_token(DOUBLE_LITERAL)) return true;
6322	0	return false;
6323		}
6324
6325	69	final private boolean jj_3_11() {
6326	69	if (jj_scan_token(DOT)) return true;
6327	0	if (jj_scan_token(IDENTIFIER)) return true;
6328	0	return false;
6329		}
6330
6331	4970	final private boolean jj_3R_51() {
6332	4970	Token xsp;
6333	4970	xsp = jj_scanpos;
6334	4963	if (jj_3R_95()) {
6335	4963	jj_scanpos = xsp;
6336	4963	if (jj_3R_96()) {
6337	4937	jj_scanpos = xsp;
6338	4537	if (jj_3R_97()) {
6339	4537	jj_scanpos = xsp;
6340	4537	if (jj_3R_98()) {
6341	4537	jj_scanpos = xsp;
6342	4529	if (jj_3R_99()) {
6343	4529	jj_scanpos = xsp;
6344	4521	if (jj_3R_100()) {
6345	4521	jj_scanpos = xsp;
6346	4519	if (jj_3R_101()) {
6347	4519	jj_scanpos = xsp;
6348	4281	if (jj_3R_102()) {
6349	4281	jj_scanpos = xsp;
6350	4275	if (jj_3R_103()) {
6351	4275	jj_scanpos = xsp;
6352	4273	if (jj_3R_104()) {
6353	4273	jj_scanpos = xsp;
6354	3999	if (jj_3R_105()) {
6355	3999	jj_scanpos = xsp;
6356	3993	if (jj_3R_106()) {
6357	3993	jj_scanpos = xsp;
6358	3991	if (jj_3R_107()) {
6359	3991	jj_scanpos = xsp;
6360	3989	if (jj_3R_108()) return true;
6361		}
6362		}
6363		}
6364		}
6365		}
6366		}
6367		}
6368		}
6369		}
6370		}
6371		}
6372		}
6373		}
6374	13	return false;
6375		}
6376
6377	2014	final private boolean jj_3R_200() {
6378	2014	if (jj_scan_token(FLOAT_LITERAL)) return true;
6379	0	return false;
6380		}
6381
6382	0	final private boolean jj_3R_191() {
6383	0	if (jj_scan_token(IDENTIFIER)) return true;
6384	0	Token xsp;
6385	0	while (true) {
6386	0	xsp = jj_scanpos;
6387	0	if (jj_3_11()) { jj_scanpos = xsp; break; }
6388		}
6389	0	return false;
6390		}
6391
6392	3999	final private boolean jj_3R_153() {
6393	3993	if (jj_scan_token(THROW)) return true;
6394	0	if (jj_3R_90()) return true;
6395	0	return false;
6396		}
6397
6398	358	final private boolean jj_3_24() {
6399	249	if (jj_3R_49()) return true;
6400	109	return false;
6401		}
6402
6403	12	final private boolean jj_3_29() {
6404	0	if (jj_3R_50()) return true;
6405	0	return false;
6406		}
6407
6408	4	final private boolean jj_3R_194() {
6409	1	if (jj_3R_51()) return true;
6410	0	return false;
6411		}
6412
6413	4	final private boolean jj_3R_175() {
6414	4	Token xsp;
6415	4	xsp = jj_scanpos;
6416	1	if (jj_3R_194()) {
6417	1	jj_scanpos = xsp;
6418	0	if (jj_3_29()) return true;
6419		}
6420	0	return false;
6421		}
6422
6423	2014	final private boolean jj_3R_199() {
6424	2014	if (jj_scan_token(LONG_LITERAL)) return true;
6425	0	return false;
6426		}
6427
6428	137	final private boolean jj_3R_178() {
6429	0	if (jj_3R_90()) return true;
6430	0	return false;
6431		}
6432
6433	0	final private boolean jj_3_23() {
6434	0	if (jj_3R_49()) return true;
6435	0	return false;
6436		}
6437
6438	1854	final private boolean jj_3R_227() {
6439	1366	if (jj_3R_228()) return true;
6440	0	return false;
6441		}
6442
6443	918	final private boolean jj_3_25() {
6444	559	if (jj_3R_50()) return true;
6445	0	return false;
6446		}
6447
6448	1277	final private boolean jj_3R_83() {
6449	669	if (jj_3R_112()) return true;
6450	0	return false;
6451		}
6452
6453	2037	final private boolean jj_3R_198() {
6454	2014	if (jj_scan_token(INTEGER_LITERAL)) return true;
6455	0	return false;
6456		}
6457
6458	1277	final private boolean jj_3R_82() {
6459	1277	if (jj_3R_110()) return true;
6460	0	return false;
6461		}
6462
6463	2037	final private boolean jj_3R_187() {
6464	2037	Token xsp;
6465	2037	xsp = jj_scanpos;
6466	2014	if (jj_3R_198()) {
6467	2014	jj_scanpos = xsp;
6468	2014	if (jj_3R_199()) {
6469	2014	jj_scanpos = xsp;
6470	2014	if (jj_3R_200()) {
6471	2014	jj_scanpos = xsp;
6472	2014	if (jj_3R_201()) {
6473	2014	jj_scanpos = xsp;
6474	2014	if (jj_3R_202()) {
6475	2014	jj_scanpos = xsp;
6476	1996	if (jj_3R_203()) {
6477	1996	jj_scanpos = xsp;
6478	1995	if (jj_3R_204()) {
6479	1995	jj_scanpos = xsp;
6480	1995	if (jj_3R_205()) {
6481	1995	jj_scanpos = xsp;
6482	1995	if (jj_3R_206()) return true;
6483		}
6484		}
6485		}
6486		}
6487		}
6488		}
6489		}
6490		}
6491	0	return false;
6492		}
6493
6494	1277	final private boolean jj_3_28() {
6495	0	if (jj_3R_57()) return true;
6496	1277	Token xsp;
6497	1277	xsp = jj_scanpos;
6498	1277	if (jj_3R_82()) {
6499	1277	jj_scanpos = xsp;
6500	669	if (jj_3R_83()) {
6501	669	jj_scanpos = xsp;
6502	559	if (jj_3_25()) return true;
6503		}
6504		}
6505	0	return false;
6506		}
6507
6508	3766	final private boolean jj_3R_158() {
6509	3764	if (jj_3R_183()) return true;
6510	0	return false;
6511		}
6512
6513	0	final private boolean jj_3R_81() {
6514	0	if (jj_3R_112()) return true;
6515	0	return false;
6516		}
6517
6518	3766	final private boolean jj_3R_157() {
6519	3766	if (jj_3R_182()) return true;
6520	0	return false;
6521		}
6522
6523	0	final private boolean jj_3R_80() {
6524	0	if (jj_3R_110()) return true;
6525	0	return false;
6526		}
6527
6528	3944	final private boolean jj_3R_156() {
6529	3766	if (jj_3R_181()) return true;
6530	0	return false;
6531		}
6532
6533	4273	final private boolean jj_3R_152() {
6534	3999	if (jj_scan_token(RETURN)) return true;
6535	137	Token xsp;
6536	137	xsp = jj_scanpos;
6537	0	if (jj_3R_178()) jj_scanpos = xsp;
6538	0	if (jj_3R_179()) return true;
6539	0	return false;
6540		}
6541
6542	1277	final private boolean jj_3_27() {
6543	1277	if (jj_3R_52()) return true;
6544	0	Token xsp;
6545	0	xsp = jj_scanpos;
6546	0	if (jj_3R_80()) {
6547	0	jj_scanpos = xsp;
6548	0	if (jj_3R_81()) return true;
6549		}
6550	0	return false;
6551		}
6552
6553	3944	final private boolean jj_3R_110() {
6554	3944	Token xsp;
6555	3944	xsp = jj_scanpos;
6556	3766	if (jj_3R_156()) {
6557	3766	jj_scanpos = xsp;
6558	3766	if (jj_3R_157()) {
6559	3766	jj_scanpos = xsp;
6560	3764	if (jj_3R_158()) return true;
6561		}
6562		}
6563	0	return false;
6564		}
6565
6566	2163	final private boolean jj_3_26() {
6567	1277	if (jj_3R_51()) return true;
6568	11	return false;
6569		}
6570
6571	1854	final private boolean jj_3R_226() {
6572	1366	if (jj_3R_227()) return true;
6573	0	return false;
6574		}
6575
6576	5	final private boolean jj_3R_165() {
6577	5	if (jj_3R_187()) return true;
6578	0	return false;
6579		}
6580
6581	1362	final private boolean jj_3R_77() {
6582	1362	Token xsp;
6583	1362	xsp = jj_scanpos;
6584	919	if (jj_3_26()) {
6585	919	jj_scanpos = xsp;
6586	919	if (jj_3_27()) {
6587	919	jj_scanpos = xsp;
6588	559	if (jj_3_28()) return true;
6589		}
6590		}
6591	0	return false;
6592		}
6593
6594	4275	final private boolean jj_3R_151() {
6595	4273	if (jj_scan_token(CONTINUE)) return true;
6596	1	Token xsp;
6597	1	xsp = jj_scanpos;
6598	1	if (jj_scan_token(77)) jj_scanpos = xsp;
6599	0	if (jj_scan_token(SEMICOLON)) return true;
6600	0	return false;
6601		}
6602
6603	1	final private boolean jj_3_42() {
6604	1	if (jj_scan_token(LBRACKET)) return true;
6605	0	if (jj_scan_token(RBRACKET)) return true;
6606	0	return false;
6607		}
6608
6609	1217	final private boolean jj_3_22() {
6610	487