Attachment #146602 for bug #287648

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




				true);
			assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
			CompilationUnit unit = (CompilationUnit) node;
			assertProblemsSize(unit, 1, "Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration");
			node = getASTNode(unit, 0, 0, 0);
			assertEquals("Not an expression statement", ASTNode.EXPRESSION_STATEMENT, node.getNodeType());
			assertTrue("Not recovered", isRecovered(node));

			CompilationUnit unit = (CompilationUnit) node;
			assertProblemsSize(
					unit,
					1,
					"Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration");
					"Syntax error, insert \"AssignmentOperator Expression\" to complete Expression");
			node = getASTNode(unit, 0, 0);
			assertEquals("Not a field declaration statement", ASTNode.INITIALIZER, node.getNodeType());
			Initializer initializer = (Initializer) node;

				"}");

		assertASTResult(
				"===== AST =====\n" + 
				"import java.nio.ByteBuffer;\n" + 
				"import java.nio.CharBuffer;\n" + 
				"import java.nio.charset.Charset;\n" + 
				"import java.nio.charset.CharsetDecoder;\n" + 
				"import java.nio.charset.CharsetEncoder;\n" + 
				"import java.nio.charset.CoderResult;\n" + 
				"public class TestCharset extends Charset {\n" + 
				"  public CharsetDecoder newDecoder(){\n" + 
				"    return new CharsetDecoder(this,2.0,2.0){\n" + 
				"      void CharsetDecoder(){\n" + 
				"      }\n" + 
				"      protected CoderResult decodeLoop(      ByteBuffer in,      CharBuffer out){\n" + 
				"        return null;\n" + 
				"      }\n" + 
				"    }\n" + 
				";\n" + 
				"    ;\n" + 
				"  }\n" + 
				"  public CharsetEncoder newEncoder(){\n" + 
				"    return null;\n" + 
				"  }\n" + 
				"}\n" + 
				"\n" + 
				"===== Details =====\n" + 
				"===== Problems =====\n" + 
				"1. ERROR in /Converter/src/TestCharset.java (at line 1)\n" + 
				"	import java.nio.ByteBuffer;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"2. ERROR in /Converter/src/TestCharset.java (at line 2)\n" + 
				"	import java.nio.CharBuffer;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"3. ERROR in /Converter/src/TestCharset.java (at line 3)\n" + 
				"	import java.nio.charset.Charset;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"4. ERROR in /Converter/src/TestCharset.java (at line 4)\n" + 
				"	import java.nio.charset.CharsetDecoder;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"5. ERROR in /Converter/src/TestCharset.java (at line 5)\n" + 
				"	import java.nio.charset.CharsetEncoder;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"6. ERROR in /Converter/src/TestCharset.java (at line 6)\n" + 
				"	import java.nio.charset.CoderResult;\n" + 
				"	       ^^^^^^^^\n" + 
				"The import java.nio cannot be resolved\n" + 
				"7. ERROR in /Converter/src/TestCharset.java (at line 7)\n" + 
				"	public class TestCharset extends Charset {\n" + 
				"	                                 ^^^^^^^\n" + 
				"Charset cannot be resolved to a type\n" + 
				"8. ERROR in /Converter/src/TestCharset.java (at line 8)\n" + 
				"	public CharsetDecoder newDecoder() {\n" + 
				"	       ^^^^^^^^^^^^^^\n" + 
				"CharsetDecoder cannot be resolved to a type\n" + 
				"9. ERROR in /Converter/src/TestCharset.java (at line 9)\n" + 
				"	return new CharsetDecoder(this, 2.0, 2.0) {\n" + 
				"	           ^^^^^^^^^^^^^^\n" + 
				"CharsetDecoder cannot be resolved to a type\n" + 
				"10. ERROR in /Converter/src/TestCharset.java (at line 10)\n" + 
				"	CharsetDecoder(CharSet\n" + 
				"	               ^^^^^^^\n" + 
				"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameter\n" + 
				"11. ERROR in /Converter/src/TestCharset.java (at line 10)\n" + 
				"	CharsetDecoder(CharSet\n" + 
				"	               ^^^^^^^\n" + 
				"Syntax error, insert \")\" to complete ConstructorDeclaration\n" + 
				"12. ERROR in /Converter/src/TestCharset.java (at line 10)\n" + 
				"	CharsetDecoder(CharSet\n" + 
				"	               ^^^^^^^\n" + 
				"Syntax error, insert \";\" to complete ClassBodyDeclarations\n" + 
				"13. ERROR in /Converter/src/TestCharset.java (at line 17)\n" + 
				"	public CharsetEncoder newEncoder() {\n" + 
				"	       ^^^^^^^^^^^^^^\n" + 
				"CharsetEncoder cannot be resolved to a type\n",
				result);
		}

Lines 4939-4959 Link Here

(-)Eclipse Java Tests Compiler/org/eclipse/jdt/tests/compiler/regression/NegativeTest.java (-15 / +15 lines)
4939	" }\n" +	4939	" }\n" +
4940	"}",	4940	"}",
4941	},	4941	},
4942	"----------\n" +	4942	"----------\n" +
4943	"1. ERROR in p\\NA.java (at line 7)\n" +	4943	"1. ERROR in p\\NA.java (at line 7)\n" +
4944	" (new Class1).run();\n" +	4944	" (new Class1).run();\n" +
4945	" ^^^\n" +	4945	" ^^^^^^\n" +
4946	"Syntax error on token \"new\", delete this token\n" +	4946	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4947	"----------\n" +	4947	"----------\n" +
4948	"2. ERROR in p\\NA.java (at line 8)\n" +	4948	"2. ERROR in p\\NA.java (at line 8)\n" +
4949	" (new Class2).run();\n" +	4949	" (new Class2).run();\n" +
4950	" ^^^\n" +	4950	" ^^^^^^\n" +
4951	"Syntax error on token \"new\", delete this token\n" +	4951	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4952	"----------\n" +	4952	"----------\n" +
4953	"3. ERROR in p\\NA.java (at line 9)\n" +	4953	"3. ERROR in p\\NA.java (at line 9)\n" +
4954	" (new Class3).run();\n" +	4954	" (new Class3).run();\n" +
4955	" ^^^\n" +	4955	" ^^^^^^\n" +
4956	"Syntax error on token \"new\", delete this token\n" +	4956	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
4957	"----------\n"	4957	"----------\n"
4958	);	4958	);
4959	}	4959	}

Lines 178-185 Link Here

(-)grammar/java.g (-27 / +202 lines)
178	Goal ::= '>>' Initializer	178	Goal ::= '>>' Initializer
179	-- error recovery	179	-- error recovery
180	-- Modifiersopt is used to properly consume a header and exit the rule reduction at the end of the parse() method	180	-- Modifiersopt is used to properly consume a header and exit the rule reduction at the end of the parse() method
181	Goal ::= '>>>' Header1 Modifiersopt	181	-- 1.7, we now use NonAnnotModifiersopt, since using Modifiersopt here pollutes the follow set of
182	Goal ::= '!' Header2 Modifiersopt	182	-- various non terminals and results in shift/reduce conflicts in various places. (e.g, ConstructorHeader
		183	-- cannot really have Modifiers in its follow set.)
		184	Goal ::= '>>>' Header1 NonAnnotModifiersopt
		185	Goal ::= '!' Header2 NonAnnotModifiersopt
183	Goal ::= '*' BlockStatements	186	Goal ::= '*' BlockStatements
184	Goal ::= '*' CatchHeader	187	Goal ::= '*' CatchHeader
185	-- JDOM	188	-- JDOM
Lines 213-221 Link Here
213	BooleanLiteral -> false	216	BooleanLiteral -> false
214	/:$readableName BooleanLiteral:/	217	/:$readableName BooleanLiteral:/
215		218
216	Type ::= PrimitiveType	219	Type ::= UnannotatedType
		220	Type ::= OneOrMoreAnnotations UnannotatedType
		221	/:$compliance 1.7:/
		222	/:$readableName Type:/
		223
		224	UnannotatedType ::= PrimitiveType
217	/.$putCase consumePrimitiveType(); $break ./	225	/.$putCase consumePrimitiveType(); $break ./
218	Type -> ReferenceType	226	UnannotatedType -> ReferenceType
219	/:$readableName Type:/	227	/:$readableName Type:/
220		228
221	PrimitiveType -> NumericType	229	PrimitiveType -> NumericType
Lines 250-263 Link Here
250		258
251	ClassOrInterface ::= Name	259	ClassOrInterface ::= Name
252	/.$putCase consumeClassOrInterfaceName(); $break ./	260	/.$putCase consumeClassOrInterfaceName(); $break ./
253	ClassOrInterface ::= GenericType '.' Name	261	ClassOrInterface ::= GenericTypeDotName
254	/.$putCase consumeClassOrInterface(); $break ./
255	/:$readableName Type:/	262	/:$readableName Type:/
256		263
257	GenericType ::= ClassOrInterface TypeArguments	264	GenericType ::= ClassOrInterface TypeArguments
258	/.$putCase consumeGenericType(); $break ./	265	/.$putCase consumeGenericType(); $break ./
259	/:$readableName GenericType:/	266	/:$readableName GenericType:/
260		267
		268	GenericTypeDotName ::= GenericType '.' Name
		269	/.$putCase consumeClassOrInterface(); $break ./
		270	/:$readableName GenericTypeDotName:/
		271
261	--	272	--
262	-- These rules have been rewritten to avoid some conflicts introduced	273	-- These rules have been rewritten to avoid some conflicts introduced
263	-- by adding the 1.1 features	274	-- by adding the 1.1 features
Lines 267-274 Link Here
267	-- ArrayType ::= ArrayType '[' ']'	278	-- ArrayType ::= ArrayType '[' ']'
268	--	279	--
269		280
270	ArrayTypeWithTypeArgumentsName ::= GenericType '.' Name	281	ArrayTypeWithTypeArgumentsName ::= GenericTypeDotName
271	/.$putCase consumeArrayTypeWithTypeArgumentsName(); $break ./
272	/:$readableName ArrayTypeWithTypeArgumentsName:/	282	/:$readableName ArrayTypeWithTypeArgumentsName:/
273		283
274	ArrayType ::= PrimitiveType Dims	284	ArrayType ::= PrimitiveType Dims
Lines 282-287 Link Here
282	/:$readableName ArrayType:/	292	/:$readableName ArrayType:/
283		293
284	ClassType -> ClassOrInterfaceType	294	ClassType -> ClassOrInterfaceType
		295	ClassType ::= OneOrMoreAnnotations ClassOrInterfaceType
		296	/:$compliance 1.7:/
285	/:$readableName ClassType:/	297	/:$readableName ClassType:/
286		298
287	--------------------------------------------------------------	299	--------------------------------------------------------------
Lines 422-432 Link Here
422		434
423	--18.7 Only in the LALR(1) Grammar	435	--18.7 Only in the LALR(1) Grammar
424		436
		437	NonAnnotModifiers -> NonAnnotModifier
		438	NonAnnotModifiers -> NonAnnotModifiers NonAnnotModifier
		439	/.$putCase consumeModifiers2(); $break ./
		440	/:$readableName Modifiers:/
		441
425	Modifiers -> Modifier	442	Modifiers -> Modifier
426	Modifiers ::= Modifiers Modifier	443	Modifiers ::= Modifiers Modifier
427	/.$putCase consumeModifiers2(); $break ./	444	/.$putCase consumeModifiers2(); $break ./
428	/:$readableName Modifiers:/	445	/:$readableName Modifiers:/
429		446
		447	NonAnnotModifier -> 'public'
		448	NonAnnotModifier -> 'protected'
		449	NonAnnotModifier -> 'private'
		450	NonAnnotModifier -> 'static'
		451	NonAnnotModifier -> 'abstract'
		452	NonAnnotModifier -> 'final'
		453	NonAnnotModifier -> 'native'
		454	NonAnnotModifier -> 'synchronized'
		455	NonAnnotModifier -> 'transient'
		456	NonAnnotModifier -> 'volatile'
		457	NonAnnotModifier -> 'strictfp'
		458	/:$readableName Modifier:/
		459
430	Modifier -> 'public'	460	Modifier -> 'public'
431	Modifier -> 'protected'	461	Modifier -> 'protected'
432	Modifier -> 'private'	462	Modifier -> 'private'
Lines 485-490 Link Here
485		515
486	InterfaceType ::= ClassOrInterfaceType	516	InterfaceType ::= ClassOrInterfaceType
487	/.$putCase consumeInterfaceType(); $break ./	517	/.$putCase consumeInterfaceType(); $break ./
		518	InterfaceType ::= OneOrMoreAnnotations ClassOrInterfaceType
		519	/:$compliance 1.7:/
		520	/.$putCase consumeInterfaceType(); $break ./
488	/:$readableName InterfaceType:/	521	/:$readableName InterfaceType:/
489		522
490	ClassBody ::= '{' ClassBodyDeclarationsopt '}'	523	ClassBody ::= '{' ClassBodyDeclarationsopt '}'
Lines 548-554 Link Here
548	-- \| 'transient'	581	-- \| 'transient'
549	-- \| 'volatile'	582	-- \| 'volatile'
550		583
551	FieldDeclaration ::= Modifiersopt Type VariableDeclarators ';'	584	FieldDeclaration ::= Modifiersopt UnannotatedType VariableDeclarators ';'
552	/.$putCase consumeFieldDeclaration(); $break ./	585	/.$putCase consumeFieldDeclaration(); $break ./
553	/:$readableName FieldDeclaration:/	586	/:$readableName FieldDeclaration:/
554		587
Lines 619-625 Link Here
619		652
620	MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	653	MethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
621	/.$putCase consumeMethodHeaderNameWithTypeParameters(false); $break ./	654	/.$putCase consumeMethodHeaderNameWithTypeParameters(false); $break ./
622	MethodHeaderName ::= Modifiersopt Type 'Identifier' '('	655	MethodHeaderName ::= Modifiersopt UnannotatedType 'Identifier' '('
623	/.$putCase consumeMethodHeaderName(false); $break ./	656	/.$putCase consumeMethodHeaderName(false); $break ./
624	/:$readableName MethodHeaderName:/	657	/:$readableName MethodHeaderName:/
625		658
Lines 628-634 Link Here
628	/:$readableName ):/	661	/:$readableName ):/
629	/:$recovery_template ):/	662	/:$recovery_template ):/
630		663
631	MethodHeaderExtendedDims ::= Dimsopt	664	MethodHeaderExtendedDims ::= DimsoptAnnotsopt
632	/.$putCase consumeMethodHeaderExtendedDims(); $break ./	665	/.$putCase consumeMethodHeaderExtendedDims(); $break ./
633	/:$readableName MethodHeaderExtendedDims:/	666	/:$readableName MethodHeaderExtendedDims:/
634		667
Lines 638-643 Link Here
638		671
639	ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderThrowsClauseopt	672	ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen MethodHeaderThrowsClauseopt
640	/.$putCase consumeConstructorHeader(); $break ./	673	/.$putCase consumeConstructorHeader(); $break ./
		674	ConstructorHeader ::= ConstructorHeaderName FormalParameterListopt MethodHeaderRightParen OneOrMoreAnnotations MethodHeaderThrowsClauseopt
		675	/:$compliance 1.7:/
		676	/.$putCase consumeConstructorHeader(); $break ./
641	/:$readableName ConstructorDeclaration:/	677	/:$readableName ConstructorDeclaration:/
642		678
643	ConstructorHeaderName ::= Modifiersopt TypeParameters 'Identifier' '('	679	ConstructorHeaderName ::= Modifiersopt TypeParameters 'Identifier' '('
Lines 651-660 Link Here
651	/.$putCase consumeFormalParameterList(); $break ./	687	/.$putCase consumeFormalParameterList(); $break ./
652	/:$readableName FormalParameterList:/	688	/:$readableName FormalParameterList:/
653		689
		690	PotentialNameArray -> $empty
		691	/.$putCase consumePotentialNameArrayType(); $break ./
		692	/:$readableName PotentialNameArray:/
		693
654	--1.1 feature	694	--1.1 feature
655	FormalParameter ::= Modifiersopt Type VariableDeclaratorId	695	--FormalParameter ::= Modifiersopt Type VariableDeclaratorId
		696	--FormalParameter ::= Modifiersopt Type '...' VariableDeclaratorId
		697	--The above rules have been rewritten by inlinng the type subgrammar
		698	--to avoid the conflicts resulting from jsr308 changes.
		699	FormalParameter ::= Modifiersopt PrimitiveType DimsoptAnnotsopt VariableDeclaratorId
		700	/.$putCase consumeFormalParameter(false); $break ./
		701	FormalParameter ::= Modifiersopt PrimitiveType DimsoptAnnotsopt '...' VariableDeclaratorId
		702	/.$putCase consumeFormalParameter(true); $break ./
		703	/:$compliance 1.5:/
		704	FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray VariableDeclaratorId
		705	/.$putCase consumeFormalParameter(false); $break ./
		706	FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray '...' VariableDeclaratorId
		707	/.$putCase consumeFormalParameter(true); $break ./
		708	/:$compliance 1.5:/
		709	FormalParameter ::= Modifiersopt GenericType DimsoptAnnotsopt VariableDeclaratorId
656	/.$putCase consumeFormalParameter(false); $break ./	710	/.$putCase consumeFormalParameter(false); $break ./
657	FormalParameter ::= Modifiersopt Type '...' VariableDeclaratorId	711	FormalParameter ::= Modifiersopt GenericType DimsoptAnnotsopt '...' VariableDeclaratorId
		712	/.$putCase consumeFormalParameter(true); $break ./
		713	/:$compliance 1.5:/
		714	FormalParameter ::= Modifiersopt GenericTypeDotName DimsoptAnnotsopt VariableDeclaratorId
		715	/.$putCase consumeFormalParameter(false); $break ./
		716	FormalParameter ::= Modifiersopt GenericTypeDotName DimsoptAnnotsopt '...' VariableDeclaratorId
658	/.$putCase consumeFormalParameter(true); $break ./	717	/.$putCase consumeFormalParameter(true); $break ./
659	/:$readableName FormalParameter:/	718	/:$readableName FormalParameter:/
660	/:$compliance 1.5:/	719	/:$compliance 1.5:/
Lines 865-877 Link Here
865	/.$putCase consumeLocalVariableDeclarationStatement(); $break ./	924	/.$putCase consumeLocalVariableDeclarationStatement(); $break ./
866	/:$readableName LocalVariableDeclarationStatement:/	925	/:$readableName LocalVariableDeclarationStatement:/
867		926
868	LocalVariableDeclaration ::= Type PushModifiers VariableDeclarators	927	LocalVariableDeclaration ::= UnannotatedType PushModifiers VariableDeclarators
869	/.$putCase consumeLocalVariableDeclaration(); $break ./	928	/.$putCase consumeLocalVariableDeclaration(); $break ./
870	-- 1.1 feature	929	-- 1.1 feature
871	-- The modifiers part of this rule makes the grammar more permissive.	930	-- The modifiers part of this rule makes the grammar more permissive.
872	-- The only modifier here is final. We put Modifiers to allow multiple modifiers	931	-- The only modifier here is final. We put Modifiers to allow multiple modifiers
873	-- This will require to check the validity of the modifier	932	-- This will require to check the validity of the modifier
874	LocalVariableDeclaration ::= Modifiers Type PushRealModifiers VariableDeclarators	933	LocalVariableDeclaration ::= Modifiers UnannotatedType PushRealModifiers VariableDeclarators
875	/.$putCase consumeLocalVariableDeclaration(); $break ./	934	/.$putCase consumeLocalVariableDeclaration(); $break ./
876	/:$readableName LocalVariableDeclaration:/	935	/:$readableName LocalVariableDeclaration:/
877		936
Lines 1219-1242 Link Here
1219		1278
1220	ArrayCreationHeader ::= 'new' PrimitiveType DimWithOrWithOutExprs	1279	ArrayCreationHeader ::= 'new' PrimitiveType DimWithOrWithOutExprs
1221	/.$putCase consumeArrayCreationHeader(); $break ./	1280	/.$putCase consumeArrayCreationHeader(); $break ./
		1281	ArrayCreationHeader ::= 'new' OneOrMoreAnnotations PrimitiveType DimWithOrWithOutExprs
		1282	/:$compliance 1.7:/
		1283	/.$putCase consumeArrayCreationHeader(); $break ./
1222		1284
1223	ArrayCreationHeader ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs	1285	ArrayCreationHeader ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs
1224	/.$putCase consumeArrayCreationHeader(); $break ./	1286	/.$putCase consumeArrayCreationHeader(); $break ./
		1287	ArrayCreationHeader ::= 'new' OneOrMoreAnnotations ClassOrInterfaceType DimWithOrWithOutExprs
		1288	/:$compliance 1.7:/
		1289	/.$putCase consumeArrayCreationHeader(); $break ./
1225	/:$readableName ArrayCreationHeader:/	1290	/:$readableName ArrayCreationHeader:/
1226		1291
1227	ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs	1292	ArrayCreationWithoutArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs
1228	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./	1293	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./
		1294	ArrayCreationWithoutArrayInitializer ::= 'new' OneOrMoreAnnotations PrimitiveType DimWithOrWithOutExprs
		1295	/:$compliance 1.7:/
		1296	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./
1229	/:$readableName ArrayCreationWithoutArrayInitializer:/	1297	/:$readableName ArrayCreationWithoutArrayInitializer:/
1230		1298
1231	ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer	1299	ArrayCreationWithArrayInitializer ::= 'new' PrimitiveType DimWithOrWithOutExprs ArrayInitializer
1232	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./	1300	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./
		1301	ArrayCreationWithArrayInitializer ::= 'new' OneOrMoreAnnotations PrimitiveType DimWithOrWithOutExprs ArrayInitializer
		1302	/:$compliance 1.7:/
		1303	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./
1233	/:$readableName ArrayCreationWithArrayInitializer:/	1304	/:$readableName ArrayCreationWithArrayInitializer:/
1234		1305
1235	ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs	1306	ArrayCreationWithoutArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs
1236	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./	1307	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./
		1308	ArrayCreationWithoutArrayInitializer ::= 'new' OneOrMoreAnnotations ClassOrInterfaceType DimWithOrWithOutExprs
		1309	/:$compliance 1.7:/
		1310	/.$putCase consumeArrayCreationExpressionWithoutInitializer(); $break ./
1237		1311
1238	ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer	1312	ArrayCreationWithArrayInitializer ::= 'new' ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer
1239	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./	1313	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./
		1314	ArrayCreationWithArrayInitializer ::= 'new' OneOrMoreAnnotations ClassOrInterfaceType DimWithOrWithOutExprs ArrayInitializer
		1315	/:$compliance 1.7:/
		1316	/.$putCase consumeArrayCreationExpressionWithInitializer(); $break ./
1240		1317
1241	DimWithOrWithOutExprs ::= DimWithOrWithOutExpr	1318	DimWithOrWithOutExprs ::= DimWithOrWithOutExpr
1242	DimWithOrWithOutExprs ::= DimWithOrWithOutExprs DimWithOrWithOutExpr	1319	DimWithOrWithOutExprs ::= DimWithOrWithOutExprs DimWithOrWithOutExpr
Lines 1249-1254 Link Here
1249	/:$readableName Dimension:/	1326	/:$readableName Dimension:/
1250	-- -----------------------------------------------	1327	-- -----------------------------------------------
1251		1328
		1329	-- jsr 308
		1330
		1331	DimsoptAnnotsopt -> $empty
		1332	/. $putCase consumeEmptyDimsoptAnnotsopt(); $break ./
		1333	/:$readableName AnnotationsDimensionsSequence:/
		1334	DimsoptAnnotsopt -> DimsAnnotLoop
		1335	/. $putCase consumeDimsWithTrailingAnnotsopt(); $break ./
		1336	/:$readableName Dimensionsoptannotsopt:/
		1337	DimsAnnotLoop ::= OneDimOrAnnot
		1338	DimsAnnotLoop ::= DimsAnnotLoop OneDimOrAnnot
		1339	/:$readableName DimsAnnotLoop:/
		1340
		1341	OneDimOrAnnot -> Annotation
		1342	/:$compliance 1.7:/
		1343	OneDimOrAnnot -> '[' ']'
		1344	/. $putCase consumeOneDimLoop(); $break ./
		1345	/:$readableName OneDimensionOrAnnotation:/
		1346
		1347	OneOrMoreAnnotations -> Annotation
		1348	/:$compliance 1.7:/
		1349	OneOrMoreAnnotations ::= OneOrMoreAnnotations Annotation
		1350	/:$compliance 1.7:/
		1351	/:$readableName OneOrMoreAnnotations:/
		1352
1252	Dims ::= DimsLoop	1353	Dims ::= DimsLoop
1253	/. $putCase consumeDims(); $break ./	1354	/. $putCase consumeDims(); $break ./
1254	/:$readableName Dimensions:/	1355	/:$readableName Dimensions:/
Lines 1258-1263 Link Here
1258	OneDimLoop ::= '[' ']'	1359	OneDimLoop ::= '[' ']'
1259	/. $putCase consumeOneDimLoop(); $break ./	1360	/. $putCase consumeOneDimLoop(); $break ./
1260	/:$readableName Dimension:/	1361	/:$readableName Dimension:/
		1362	OneDimLoop ::= OneOrMoreAnnotations '[' ']'
		1363	/:$compliance 1.7:/
		1364	/. $putCase consumeOneDimLoopWithAnnotations(); $break ./
		1365	/:$readableName DimensionWithAnnotations:/
1261		1366
1262	FieldAccess ::= Primary '.' 'Identifier'	1367	FieldAccess ::= Primary '.' 'Identifier'
1263	/.$putCase consumeFieldAccess(false); $break ./	1368	/.$putCase consumeFieldAccess(false); $break ./
Lines 1340-1353 Link Here
1340		1445
1341	CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression	1446	CastExpression ::= PushLPAREN PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression
1342	/.$putCase consumeCastExpressionWithPrimitiveType(); $break ./	1447	/.$putCase consumeCastExpressionWithPrimitiveType(); $break ./
		1448	CastExpression ::= PushLPAREN OneOrMoreAnnotations PrimitiveType Dimsopt PushRPAREN InsideCastExpression UnaryExpression
		1449	/:$compliance 1.7:/
		1450	/.$putCase consumeCastExpressionWithPrimitiveType(); $break ./
1343	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	1451	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
1344	/.$putCase consumeCastExpressionWithGenericsArray(); $break ./	1452	/.$putCase consumeCastExpressionWithGenericsArray(); $break ./
		1453	CastExpression ::= PushLPAREN OneOrMoreAnnotations Name OnlyTypeArgumentsForCastExpression Dimsopt PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
		1454	/:$compliance 1.7:/
		1455	/.$putCase consumeCastExpressionWithGenericsArray(); $break ./
1345	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus	1456	CastExpression ::= PushLPAREN Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus
1346	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./	1457	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./
		1458	CastExpression ::= PushLPAREN OneOrMoreAnnotations Name OnlyTypeArgumentsForCastExpression '.' ClassOrInterfaceType Dimsopt PushRPAREN InsideCastExpressionWithQualifiedGenerics UnaryExpressionNotPlusMinus
		1459	/:$compliance 1.7:/
		1460	/.$putCase consumeCastExpressionWithQualifiedGenericsArray(); $break ./
1347	CastExpression ::= PushLPAREN Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus	1461	CastExpression ::= PushLPAREN Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus
1348	/.$putCase consumeCastExpressionLL1(); $break ./	1462	/.$putCase consumeCastExpressionLL1(); $break ./
		1463	CastExpression ::= PushLPAREN OneOrMoreAnnotations Name PushRPAREN InsideCastExpressionLL1 UnaryExpressionNotPlusMinus
		1464	/:$compliance 1.7:/
		1465	/.$putCase consumeCastExpressionLL1(); $break ./
1349	CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus	1466	CastExpression ::= PushLPAREN Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
1350	/.$putCase consumeCastExpressionWithNameArray(); $break ./	1467	/.$putCase consumeCastExpressionWithNameArray(); $break ./
		1468	CastExpression ::= PushLPAREN OneOrMoreAnnotations Name Dims PushRPAREN InsideCastExpression UnaryExpressionNotPlusMinus
		1469	/:$compliance 1.7:/
		1470	/.$putCase consumeCastExpressionWithNameArray(); $break ./
1351	/:$readableName CastExpression:/	1471	/:$readableName CastExpression:/
1352		1472
1353	OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments	1473	OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments
Lines 1403-1408 Link Here
1403	InstanceofExpression -> RelationalExpression	1523	InstanceofExpression -> RelationalExpression
1404	InstanceofExpression ::= InstanceofExpression 'instanceof' ReferenceType	1524	InstanceofExpression ::= InstanceofExpression 'instanceof' ReferenceType
1405	/.$putCase consumeInstanceOfExpression(); $break ./	1525	/.$putCase consumeInstanceOfExpression(); $break ./
		1526	InstanceofExpression ::= InstanceofExpression 'instanceof' OneOrMoreAnnotations ReferenceType
		1527	/:$compliance 1.7:/
		1528	/.$putCase consumeInstanceOfExpression(); $break ./
1406	/:$readableName Expression:/	1529	/:$readableName Expression:/
1407		1530
1408	EqualityExpression -> InstanceofExpression	1531	EqualityExpression -> InstanceofExpression
Lines 1526-1531 Link Here
1526	/.$putCase consumeClassBodyDeclarationsopt(); $break ./	1649	/.$putCase consumeClassBodyDeclarationsopt(); $break ./
1527	/:$readableName ClassBodyDeclarations:/	1650	/:$readableName ClassBodyDeclarations:/
1528		1651
		1652	NonAnnotModifiersopt ::= $empty
		1653	/. $putCase consumeDefaultModifiers(); $break ./
		1654	NonAnnotModifiersopt ::= NonAnnotModifiers
		1655	/.$putCase consumeModifiers(); $break ./
		1656	/:$readableName Modifiers:/
		1657
1529	Modifiersopt ::= $empty	1658	Modifiersopt ::= $empty
1530	/. $putCase consumeDefaultModifiers(); $break ./	1659	/. $putCase consumeDefaultModifiers(); $break ./
1531	Modifiersopt ::= Modifiers	1660	Modifiersopt ::= Modifiers
Lines 1666-1676 Link Here
1666	/.$putCase consumeEnhancedForStatement(); $break ./	1795	/.$putCase consumeEnhancedForStatement(); $break ./
1667	/:$readableName EnhancedForStatementNoShortIf:/	1796	/:$readableName EnhancedForStatementNoShortIf:/
1668		1797
1669	EnhancedForStatementHeaderInit ::= 'for' '(' Type PushModifiers Identifier Dimsopt	1798	EnhancedForStatementHeaderInit ::= 'for' '(' UnannotatedType PushModifiers Identifier Dimsopt
1670	/.$putCase consumeEnhancedForStatementHeaderInit(false); $break ./	1799	/.$putCase consumeEnhancedForStatementHeaderInit(false); $break ./
1671	/:$readableName EnhancedForStatementHeaderInit:/	1800	/:$readableName EnhancedForStatementHeaderInit:/
1672		1801
1673	EnhancedForStatementHeaderInit ::= 'for' '(' Modifiers Type PushRealModifiers Identifier Dimsopt	1802	EnhancedForStatementHeaderInit ::= 'for' '(' Modifiers UnannotatedType PushRealModifiers Identifier Dimsopt
1674	/.$putCase consumeEnhancedForStatementHeaderInit(true); $break ./	1803	/.$putCase consumeEnhancedForStatementHeaderInit(true); $break ./
1675	/:$readableName EnhancedForStatementHeaderInit:/	1804	/:$readableName EnhancedForStatementHeaderInit:/
1676		1805
Lines 1730-1735 Link Here
1730	TypeArgument ::= ReferenceType	1859	TypeArgument ::= ReferenceType
1731	/.$putCase consumeTypeArgument(); $break ./	1860	/.$putCase consumeTypeArgument(); $break ./
1732	/:$compliance 1.5:/	1861	/:$compliance 1.5:/
		1862	TypeArgument ::= OneOrMoreAnnotations ReferenceType
		1863	/:$compliance 1.7:/
		1864	/.$putCase consumeTypeArgument(); $break ./
1733	TypeArgument -> Wildcard	1865	TypeArgument -> Wildcard
1734	/:$readableName TypeArgument:/	1866	/:$readableName TypeArgument:/
1735	/:$compliance 1.5:/	1867	/:$compliance 1.5:/
Lines 1743-1752 Link Here
1743	ReferenceType1 ::= ReferenceType '>'	1875	ReferenceType1 ::= ReferenceType '>'
1744	/.$putCase consumeReferenceType1(); $break ./	1876	/.$putCase consumeReferenceType1(); $break ./
1745	/:$compliance 1.5:/	1877	/:$compliance 1.5:/
		1878	ReferenceType1 ::= OneOrMoreAnnotations ReferenceType '>'
		1879	/:$compliance 1.7:/
		1880	/.$putCase consumeReferenceType1(); $break ./
1746	ReferenceType1 ::= ClassOrInterface '<' TypeArgumentList2	1881	ReferenceType1 ::= ClassOrInterface '<' TypeArgumentList2
1747	/.$putCase consumeTypeArgumentReferenceType1(); $break ./	1882	/.$putCase consumeTypeArgumentReferenceType1(); $break ./
1748	/:$readableName ReferenceType1:/
1749	/:$compliance 1.5:/	1883	/:$compliance 1.5:/
		1884	ReferenceType1 ::= OneOrMoreAnnotations ClassOrInterface '<' TypeArgumentList2
		1885	/:$compliance 1.7:/
		1886	/.$putCase consumeTypeArgumentReferenceType1(); $break ./
		1887	/:$readableName ReferenceType1:/
1750		1888
1751	TypeArgumentList2 -> TypeArgument2	1889	TypeArgumentList2 -> TypeArgument2
1752	/:$compliance 1.5:/	1890	/:$compliance 1.5:/
Lines 1764-1773 Link Here
1764	ReferenceType2 ::= ReferenceType '>>'	1902	ReferenceType2 ::= ReferenceType '>>'
1765	/.$putCase consumeReferenceType2(); $break ./	1903	/.$putCase consumeReferenceType2(); $break ./
1766	/:$compliance 1.5:/	1904	/:$compliance 1.5:/
		1905	ReferenceType2 ::= OneOrMoreAnnotations ReferenceType '>>'
		1906	/:$compliance 1.7:/
		1907	/.$putCase consumeReferenceType2(); $break ./
1767	ReferenceType2 ::= ClassOrInterface '<' TypeArgumentList3	1908	ReferenceType2 ::= ClassOrInterface '<' TypeArgumentList3
1768	/.$putCase consumeTypeArgumentReferenceType2(); $break ./	1909	/.$putCase consumeTypeArgumentReferenceType2(); $break ./
1769	/:$readableName ReferenceType2:/
1770	/:$compliance 1.5:/	1910	/:$compliance 1.5:/
		1911	ReferenceType2 ::= OneOrMoreAnnotations ClassOrInterface '<' TypeArgumentList3
		1912	/:$compliance 1.7:/
		1913	/.$putCase consumeTypeArgumentReferenceType2(); $break ./
		1914	/:$readableName ReferenceType2:/
1771		1915
1772	TypeArgumentList3 -> TypeArgument3	1916	TypeArgumentList3 -> TypeArgument3
1773	TypeArgumentList3 ::= TypeArgumentList ',' TypeArgument3	1917	TypeArgumentList3 ::= TypeArgumentList ',' TypeArgument3
Lines 1782-1789 Link Here
1782		1926
1783	ReferenceType3 ::= ReferenceType '>>>'	1927	ReferenceType3 ::= ReferenceType '>>>'
1784	/.$putCase consumeReferenceType3(); $break ./	1928	/.$putCase consumeReferenceType3(); $break ./
1785	/:$readableName ReferenceType3:/
1786	/:$compliance 1.5:/	1929	/:$compliance 1.5:/
		1930	ReferenceType3 ::= OneOrMoreAnnotations ReferenceType '>>>'
		1931	/:$compliance 1.7:/
		1932	/.$putCase consumeReferenceType3(); $break ./
		1933	/:$readableName ReferenceType3:/
1787		1934
1788	Wildcard ::= '?'	1935	Wildcard ::= '?'
1789	/.$putCase consumeWildcard(); $break ./	1936	/.$putCase consumeWildcard(); $break ./
Lines 1796-1805 Link Here
1796	WildcardBounds ::= 'extends' ReferenceType	1943	WildcardBounds ::= 'extends' ReferenceType
1797	/.$putCase consumeWildcardBoundsExtends(); $break ./	1944	/.$putCase consumeWildcardBoundsExtends(); $break ./
1798	/:$compliance 1.5:/	1945	/:$compliance 1.5:/
		1946	WildcardBounds ::= 'extends' OneOrMoreAnnotations ReferenceType
		1947	/:$compliance 1.7:/
		1948	/.$putCase consumeWildcardBoundsExtends(); $break ./
1799	WildcardBounds ::= 'super' ReferenceType	1949	WildcardBounds ::= 'super' ReferenceType
1800	/.$putCase consumeWildcardBoundsSuper(); $break ./	1950	/.$putCase consumeWildcardBoundsSuper(); $break ./
1801	/:$readableName WildcardBounds:/
1802	/:$compliance 1.5:/	1951	/:$compliance 1.5:/
		1952	WildcardBounds ::= 'super' OneOrMoreAnnotations ReferenceType
		1953	/:$compliance 1.7:/
		1954	/.$putCase consumeWildcardBoundsSuper(); $break ./
		1955	/:$readableName WildcardBounds:/
1803		1956
1804	Wildcard1 ::= '?' '>'	1957	Wildcard1 ::= '?' '>'
1805	/.$putCase consumeWildcard1(); $break ./	1958	/.$putCase consumeWildcard1(); $break ./
Lines 1851-1858 Link Here
1851		2004
1852	TypeParameterHeader ::= Identifier	2005	TypeParameterHeader ::= Identifier
1853	/.$putCase consumeTypeParameterHeader(); $break ./	2006	/.$putCase consumeTypeParameterHeader(); $break ./
1854	/:$readableName TypeParameter:/
1855	/:$compliance 1.5:/	2007	/:$compliance 1.5:/
		2008	TypeParameterHeader ::= OneOrMoreAnnotations Identifier
		2009	/:$compliance 1.7:/
		2010	/.$putCase consumeTypeParameterHeader(); $break ./
		2011	/:$readableName TypeParameter:/
1856		2012
1857	TypeParameters ::= '<' TypeParameterList1	2013	TypeParameters ::= '<' TypeParameterList1
1858	/.$putCase consumeTypeParameters(); $break ./	2014	/.$putCase consumeTypeParameters(); $break ./
Lines 1871-1880 Link Here
1871	TypeParameter ::= TypeParameterHeader 'extends' ReferenceType	2027	TypeParameter ::= TypeParameterHeader 'extends' ReferenceType
1872	/.$putCase consumeTypeParameterWithExtends(); $break ./	2028	/.$putCase consumeTypeParameterWithExtends(); $break ./
1873	/:$compliance 1.5:/	2029	/:$compliance 1.5:/
		2030	TypeParameter ::= TypeParameterHeader 'extends' OneOrMoreAnnotations ReferenceType
		2031	/:$compliance 1.7:/
		2032	/.$putCase consumeTypeParameterWithExtends(); $break ./
1874	TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList	2033	TypeParameter ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList
1875	/.$putCase consumeTypeParameterWithExtendsAndBounds(); $break ./	2034	/.$putCase consumeTypeParameterWithExtendsAndBounds(); $break ./
1876	/:$readableName TypeParameter:/
1877	/:$compliance 1.5:/	2035	/:$compliance 1.5:/
		2036	TypeParameter ::= TypeParameterHeader 'extends' OneOrMoreAnnotations ReferenceType AdditionalBoundList
		2037	/:$compliance 1.7:/
		2038	/.$putCase consumeTypeParameterWithExtendsAndBounds(); $break ./
		2039	/:$readableName TypeParameter:/
1878		2040
1879	AdditionalBoundList -> AdditionalBound	2041	AdditionalBoundList -> AdditionalBound
1880	/:$compliance 1.5:/	2042	/:$compliance 1.5:/
Lines 1884-1891 Link Here
1884		2046
1885	AdditionalBound ::= '&' ReferenceType	2047	AdditionalBound ::= '&' ReferenceType
1886	/.$putCase consumeAdditionalBound(); $break ./	2048	/.$putCase consumeAdditionalBound(); $break ./
1887	/:$readableName AdditionalBound:/
1888	/:$compliance 1.5:/	2049	/:$compliance 1.5:/
		2050	AdditionalBound ::= '&' OneOrMoreAnnotations ReferenceType
		2051	/:$compliance 1.7:/
		2052	/.$putCase consumeAdditionalBound(); $break ./
		2053	/:$readableName AdditionalBound:/
1889		2054
1890	TypeParameterList1 -> TypeParameter1	2055	TypeParameterList1 -> TypeParameter1
1891	/:$compliance 1.5:/	2056	/:$compliance 1.5:/
Lines 1902-1909 Link Here
1902	/:$compliance 1.5:/	2067	/:$compliance 1.5:/
1903	TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1	2068	TypeParameter1 ::= TypeParameterHeader 'extends' ReferenceType AdditionalBoundList1
1904	/.$putCase consumeTypeParameter1WithExtendsAndBounds(); $break ./	2069	/.$putCase consumeTypeParameter1WithExtendsAndBounds(); $break ./
1905	/:$readableName TypeParameter1:/
1906	/:$compliance 1.5:/	2070	/:$compliance 1.5:/
		2071	TypeParameter1 ::= TypeParameterHeader 'extends' OneOrMoreAnnotations ReferenceType AdditionalBoundList1
		2072	/:$compliance 1.7:/
		2073	/.$putCase consumeTypeParameter1WithExtendsAndBounds(); $break ./
		2074	/:$readableName TypeParameter1:/
1907		2075
1908	AdditionalBoundList1 -> AdditionalBound1	2076	AdditionalBoundList1 -> AdditionalBound1
1909	/:$compliance 1.5:/	2077	/:$compliance 1.5:/
Lines 2005-2012 Link Here
2005	InstanceofExpression_NotName -> RelationalExpression_NotName	2173	InstanceofExpression_NotName -> RelationalExpression_NotName
2006	InstanceofExpression_NotName ::= Name 'instanceof' ReferenceType	2174	InstanceofExpression_NotName ::= Name 'instanceof' ReferenceType
2007	/.$putCase consumeInstanceOfExpressionWithName(); $break ./	2175	/.$putCase consumeInstanceOfExpressionWithName(); $break ./
		2176	InstanceofExpression_NotName ::= Name 'instanceof' OneOrMoreAnnotations ReferenceType
		2177	/:$compliance 1.7:/
		2178	/.$putCase consumeInstanceOfExpressionWithName(); $break ./
2008	InstanceofExpression_NotName ::= InstanceofExpression_NotName 'instanceof' ReferenceType	2179	InstanceofExpression_NotName ::= InstanceofExpression_NotName 'instanceof' ReferenceType
2009	/.$putCase consumeInstanceOfExpression(); $break ./	2180	/.$putCase consumeInstanceOfExpression(); $break ./
		2181	InstanceofExpression_NotName ::= InstanceofExpression_NotName 'instanceof' OneOrMoreAnnotations ReferenceType
		2182	/:$compliance 1.7:/
		2183	/.$putCase consumeInstanceOfExpression(); $break ./
2010	/:$readableName Expression:/	2184	/:$readableName Expression:/
2011		2185
2012	EqualityExpression_NotName -> InstanceofExpression_NotName	2186	EqualityExpression_NotName -> InstanceofExpression_NotName
Lines 2119-2125 Link Here
2119		2293
2120	AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	2294	AnnotationMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
2121	/.$putCase consumeMethodHeaderNameWithTypeParameters(true); $break ./	2295	/.$putCase consumeMethodHeaderNameWithTypeParameters(true); $break ./
2122	AnnotationMethodHeaderName ::= Modifiersopt Type 'Identifier' '('	2296	AnnotationMethodHeaderName ::= Modifiersopt UnannotatedType 'Identifier' '('
2123	/.$putCase consumeMethodHeaderName(true); $break ./	2297	/.$putCase consumeMethodHeaderName(true); $break ./
2124	/:$readableName MethodHeaderName:/	2298	/:$readableName MethodHeaderName:/
2125	/:$compliance 1.5:/	2299	/:$compliance 1.5:/
Lines 2262-2268 Link Here
2262	RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('	2436	RecoveryMethodHeaderName ::= Modifiersopt TypeParameters Type 'Identifier' '('
2263	/.$putCase consumeRecoveryMethodHeaderNameWithTypeParameters(); $break ./	2437	/.$putCase consumeRecoveryMethodHeaderNameWithTypeParameters(); $break ./
2264	/:$compliance 1.5:/	2438	/:$compliance 1.5:/
2265	RecoveryMethodHeaderName ::= Modifiersopt Type 'Identifier' '('	2439	RecoveryMethodHeaderName ::= Modifiersopt UnannotatedType 'Identifier' '('
2266	/.$putCase consumeRecoveryMethodHeaderName(); $break ./	2440	/.$putCase consumeRecoveryMethodHeaderName(); $break ./
2267	/:$readableName MethodHeaderName:/	2441	/:$readableName MethodHeaderName:/
2268		2442
Lines 2331-2333 Link Here
2331		2505
2332	$end	2506	$end
2333	-- need a carriage return after the $end	2507	-- need a carriage return after the $end
		2508




protected void consumeModifiers2() {
	this.expressionLengthStack[this.expressionLengthPtr - 1] += this.expressionLengthStack[this.expressionLengthPtr--];
}

protected void consumePotentialNameArrayType () {
	
	// FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray VariableDeclaratorId
	// FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt PotentialNameArray '...' VariableDeclaratorId
	// PotentialNameArray -> $empty
	// Dimensions including lack of have been pushed appropriately by action attached to DimsoptAnnotsopt
	pushOnGenericsLengthStack(0); // handle type arguments
	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);
}

protected void consumeNameArrayType() {
	pushOnGenericsLengthStack(0); // handle type arguments
	pushOnGenericsIdentifiersLengthStack(this.identifierLengthStack[this.identifierLengthPtr]);

// This method is part of an automatic generation : do NOT edit-modify  
protected void consumeRule(int act) {
  switch ( act ) {
    case 32 : if (DEBUG) { System.out.println("UnannotatedType ::= PrimitiveType"); }  //$NON-NLS-1$
		    consumePrimitiveType();  
			break;
 
    case 46 : if (DEBUG) { System.out.println("ReferenceType ::= ClassOrInterfaceType"); }  //$NON-NLS-1$
		    consumeReferenceType();   
			break;
 
    case 50 : if (DEBUG) { System.out.println("ClassOrInterface ::= Name"); }  //$NON-NLS-1$
		    consumeClassOrInterfaceName();   
			break;
 
    case 52 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments"); }  //$NON-NLS-1$
		    consumeClassOrInterface();   
			break;
 
    case 50 : if (DEBUG) { System.out.println("GenericType ::= ClassOrInterface TypeArguments"); }  //$NON-NLS-1$
		    consumeGenericType();   
			break;
 
    case 53 : if (DEBUG) { System.out.println("GenericTypeDotName ::= GenericType DOT Name"); }  //$NON-NLS-1$
		    consumeClassOrInterface();   
			break;
 
    case 55 : if (DEBUG) { System.out.println("ArrayType ::= PrimitiveType Dims"); }  //$NON-NLS-1$
		    consumePrimitiveArrayType();   
			break;
 
    case 56 : if (DEBUG) { System.out.println("ArrayType ::= Name Dims"); }  //$NON-NLS-1$
		    consumeNameArrayType();   
			break;
 
    case 57 : if (DEBUG) { System.out.println("ArrayType ::= ArrayTypeWithTypeArgumentsName Dims"); }  //$NON-NLS-1$
		    consumeGenericTypeNameArrayType();   
			break;
 
    case 58 : if (DEBUG) { System.out.println("ArrayType ::= GenericType Dims"); }  //$NON-NLS-1$
		    consumeGenericTypeArrayType();   
			break;
 
    case 64 : if (DEBUG) { System.out.println("QualifiedName ::= Name DOT SimpleName"); }  //$NON-NLS-1$
		    consumeQualifiedName();  
			break;
 
    case 65 : if (DEBUG) { System.out.println("CompilationUnit ::= EnterCompilationUnit..."); }  //$NON-NLS-1$
		    consumeCompilationUnit();  
			break;
 
    case 66 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration"); }  //$NON-NLS-1$
		    consumeInternalCompilationUnit();  
			break;
 
    case 67 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); }  //$NON-NLS-1$
		    consumeInternalCompilationUnit();  
			break;
 
    case 68 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); }  //$NON-NLS-1$
		    consumeInternalCompilationUnitWithTypes();  
			break;
 
    case 69 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= PackageDeclaration..."); }  //$NON-NLS-1$
		    consumeInternalCompilationUnitWithTypes();  
			break;
 
    case 70 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); }  //$NON-NLS-1$
		    consumeInternalCompilationUnit();  
			break;
 
    case 71 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= TypeDeclarations"); }  //$NON-NLS-1$
		    consumeInternalCompilationUnitWithTypes();  
			break;
 
    case 72 : if (DEBUG) { System.out.println("InternalCompilationUnit ::= ImportDeclarations..."); }  //$NON-NLS-1$
		    consumeInternalCompilationUnitWithTypes();  
			break;
 
    case 73 : if (DEBUG) { System.out.println("InternalCompilationUnit ::="); }  //$NON-NLS-1$
		    consumeEmptyInternalCompilationUnit();  
			break;
 
    case 74 : if (DEBUG) { System.out.println("ReduceImports ::="); }  //$NON-NLS-1$
		    consumeReduceImports();  
			break;
 
    case 75 : if (DEBUG) { System.out.println("EnterCompilationUnit ::="); }  //$NON-NLS-1$
		    consumeEnterCompilationUnit();  
			break;
 
    case 91 : if (DEBUG) { System.out.println("CatchHeader ::= catch LPAREN FormalParameter RPAREN..."); }  //$NON-NLS-1$
		    consumeCatchHeader();  
			break;
 
    case 93 : if (DEBUG) { System.out.println("ImportDeclarations ::= ImportDeclarations..."); }  //$NON-NLS-1$
		    consumeImportDeclarations();  
			break;
 
    case 95 : if (DEBUG) { System.out.println("TypeDeclarations ::= TypeDeclarations TypeDeclaration"); }  //$NON-NLS-1$
		    consumeTypeDeclarations();  
			break;
 
    case 96 : if (DEBUG) { System.out.println("PackageDeclaration ::= PackageDeclarationName SEMICOLON"); }  //$NON-NLS-1$
		     consumePackageDeclaration();  
			break;
 
    case 97 : if (DEBUG) { System.out.println("PackageDeclarationName ::= Modifiers package..."); }  //$NON-NLS-1$
		     consumePackageDeclarationNameWithModifiers();  
			break;
 
    case 98 : if (DEBUG) { System.out.println("PackageDeclarationName ::= PackageComment package Name"); }  //$NON-NLS-1$
		     consumePackageDeclarationName();  
			break;
 
    case 99 : if (DEBUG) { System.out.println("PackageComment ::="); }  //$NON-NLS-1$
		     consumePackageComment();  
			break;
 
    case 104 : if (DEBUG) { System.out.println("SingleTypeImportDeclaration ::=..."); }  //$NON-NLS-1$
		    consumeImportDeclaration();  
			break;
 
    case 105 : if (DEBUG) { System.out.println("SingleTypeImportDeclarationName ::= import Name"); }  //$NON-NLS-1$
		    consumeSingleTypeImportDeclarationName();  
			break;
 
    case 106 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclaration ::=..."); }  //$NON-NLS-1$
		    consumeImportDeclaration();  
			break;
 
    case 107 : if (DEBUG) { System.out.println("TypeImportOnDemandDeclarationName ::= import Name DOT..."); }  //$NON-NLS-1$
		    consumeTypeImportOnDemandDeclarationName();  
			break;
 
     case 110 : if (DEBUG) { System.out.println("TypeDeclaration ::= SEMICOLON"); }  //$NON-NLS-1$
		    consumeEmptyTypeDeclaration();  
			break;
 
    case 114 : if (DEBUG) { System.out.println("NonAnnotModifiers ::= NonAnnotModifiers NonAnnotModifier"); }  //$NON-NLS-1$
		    consumeModifiers2();  
			break;
 
    case 116 : if (DEBUG) { System.out.println("Modifiers ::= Modifiers Modifier"); }  //$NON-NLS-1$
		    consumeModifiers2();  
			break;
 
    case 139 : if (DEBUG) { System.out.println("Modifier ::= Annotation"); }  //$NON-NLS-1$
		    consumeAnnotationAsModifier();  
			break;
 
    case 140 : if (DEBUG) { System.out.println("ClassDeclaration ::= ClassHeader ClassBody"); }  //$NON-NLS-1$
		    consumeClassDeclaration();  
			break;
 
    case 141 : if (DEBUG) { System.out.println("ClassHeader ::= ClassHeaderName ClassHeaderExtendsopt..."); }  //$NON-NLS-1$
		    consumeClassHeader();  
			break;
 
    case 142 : if (DEBUG) { System.out.println("ClassHeaderName ::= ClassHeaderName1 TypeParameters"); }  //$NON-NLS-1$
		    consumeTypeHeaderNameWithTypeParameters();  
			break;
 
    case 144 : if (DEBUG) { System.out.println("ClassHeaderName1 ::= Modifiersopt class Identifier"); }  //$NON-NLS-1$
		    consumeClassHeaderName1();  
			break;
 
    case 145 : if (DEBUG) { System.out.println("ClassHeaderExtends ::= extends ClassType"); }  //$NON-NLS-1$
		    consumeClassHeaderExtends();  
			break;
 
    case 146 : if (DEBUG) { System.out.println("ClassHeaderImplements ::= implements InterfaceTypeList"); }  //$NON-NLS-1$
		    consumeClassHeaderImplements();  
			break;
 
    case 148 : if (DEBUG) { System.out.println("InterfaceTypeList ::= InterfaceTypeList COMMA..."); }  //$NON-NLS-1$
		    consumeInterfaceTypeList();  
			break;
 
    case 149 : if (DEBUG) { System.out.println("InterfaceType ::= ClassOrInterfaceType"); }  //$NON-NLS-1$
		    consumeInterfaceType();  
			break;
 
    case 150 : if (DEBUG) { System.out.println("InterfaceType ::= OneOrMoreAnnotations..."); }  //$NON-NLS-1$
		    consumeInterfaceType();  
			break;
 
    case 153 : if (DEBUG) { System.out.println("ClassBodyDeclarations ::= ClassBodyDeclarations..."); }  //$NON-NLS-1$
		    consumeClassBodyDeclarations();  
			break;
 
    case 157 : if (DEBUG) { System.out.println("ClassBodyDeclaration ::= Diet NestedMethod..."); }  //$NON-NLS-1$
		    consumeClassBodyDeclaration();  
			break;
 
    case 158 : if (DEBUG) { System.out.println("Diet ::="); }  //$NON-NLS-1$
		    consumeDiet();  
			break;

    case 159 : if (DEBUG) { System.out.println("Initializer ::= Diet NestedMethod CreateInitializer..."); }  //$NON-NLS-1$
		    consumeClassBodyDeclaration();  
			break;
 
    case 160 : if (DEBUG) { System.out.println("CreateInitializer ::="); }  //$NON-NLS-1$
		    consumeCreateInitializer();  
			break;

    case 167 : if (DEBUG) { System.out.println("ClassMemberDeclaration ::= SEMICOLON"); }  //$NON-NLS-1$
		    consumeEmptyTypeDeclaration();  
			break;

    case 170 : if (DEBUG) { System.out.println("FieldDeclaration ::= Modifiersopt UnannotatedType..."); }  //$NON-NLS-1$
		    consumeFieldDeclaration();  
			break;
 
    case 172 : if (DEBUG) { System.out.println("VariableDeclarators ::= VariableDeclarators COMMA..."); }  //$NON-NLS-1$
		    consumeVariableDeclarators();  
			break;
 
    case 175 : if (DEBUG) { System.out.println("EnterVariable ::="); }  //$NON-NLS-1$
		    consumeEnterVariable();  
			break;
 
    case 176 : if (DEBUG) { System.out.println("ExitVariableWithInitialization ::="); }  //$NON-NLS-1$
		    consumeExitVariableWithInitialization();  
			break;
 
    case 177 : if (DEBUG) { System.out.println("ExitVariableWithoutInitialization ::="); }  //$NON-NLS-1$
		    consumeExitVariableWithoutInitialization();  
			break;
 
    case 178 : if (DEBUG) { System.out.println("ForceNoDiet ::="); }  //$NON-NLS-1$
		    consumeForceNoDiet();  
			break;
 
    case 179 : if (DEBUG) { System.out.println("RestoreDiet ::="); }  //$NON-NLS-1$
		    consumeRestoreDiet();  
			break;
 
    case 184 : if (DEBUG) { System.out.println("MethodDeclaration ::= MethodHeader MethodBody"); }  //$NON-NLS-1$
		    // set to true to consume a method with a body
  consumeMethodDeclaration(true);   
			break;
 
    case 185 : if (DEBUG) { System.out.println("AbstractMethodDeclaration ::= MethodHeader SEMICOLON"); }  //$NON-NLS-1$
		    // set to false to consume a method without body
  consumeMethodDeclaration(false);  
			break;
 
    case 186 : if (DEBUG) { System.out.println("MethodHeader ::= MethodHeaderName FormalParameterListopt"); }  //$NON-NLS-1$
		    consumeMethodHeader();  
			break;
 
    case 187 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt TypeParameters Type..."); }  //$NON-NLS-1$
		    consumeMethodHeaderNameWithTypeParameters(false);  
			break;
 
    case 188 : if (DEBUG) { System.out.println("MethodHeaderName ::= Modifiersopt UnannotatedType..."); }  //$NON-NLS-1$
		    consumeMethodHeaderName(false);  
			break;
 
    case 189 : if (DEBUG) { System.out.println("MethodHeaderRightParen ::= RPAREN"); }  //$NON-NLS-1$
		    consumeMethodHeaderRightParen();  
			break;
 
    case 190 : if (DEBUG) { System.out.println("MethodHeaderExtendedDims ::= DimsoptAnnotsopt"); }  //$NON-NLS-1$
		    consumeMethodHeaderExtendedDims();  
			break;
 
    case 191 : if (DEBUG) { System.out.println("MethodHeaderThrowsClause ::= throws ClassTypeList"); }  //$NON-NLS-1$
		    consumeMethodHeaderThrowsClause();  
			break;
 
    case 192 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); }  //$NON-NLS-1$
		    consumeConstructorHeader();  
			break;
 
    case 193 : if (DEBUG) { System.out.println("ConstructorHeader ::= ConstructorHeaderName..."); }  //$NON-NLS-1$
		    consumeConstructorHeader();  
			break;
 
    case 194 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt TypeParameters..."); }  //$NON-NLS-1$
		    consumeConstructorHeaderNameWithTypeParameters();  
			break;
 
    case 195 : if (DEBUG) { System.out.println("ConstructorHeaderName ::= Modifiersopt Identifier LPAREN"); }  //$NON-NLS-1$
		    consumeConstructorHeaderName();  
			break;
 
    case 197 : if (DEBUG) { System.out.println("FormalParameterList ::= FormalParameterList COMMA..."); }  //$NON-NLS-1$
		    consumeFormalParameterList();  
			break;
 
    case 198 : if (DEBUG) { System.out.println("PotentialNameArray ::="); }  //$NON-NLS-1$
		    consumePotentialNameArrayType();  
			break;
 
    case 199 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt PrimitiveType..."); }  //$NON-NLS-1$
		    consumeFormalParameter(false);  
			break;
 
    case 200 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt PrimitiveType..."); }  //$NON-NLS-1$
		    consumeFormalParameter(true);  
			break;
 
    case 201 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt"); }  //$NON-NLS-1$
		    consumeFormalParameter(false);  
			break;
 
    case 202 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt Name DimsoptAnnotsopt"); }  //$NON-NLS-1$
		    consumeFormalParameter(true);  
			break;
 
    case 203 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericType..."); }  //$NON-NLS-1$
		    consumeFormalParameter(false);  
			break;
 
    case 204 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericType..."); }  //$NON-NLS-1$
		    consumeFormalParameter(true);  
			break;
 
    case 205 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericTypeDotName..."); }  //$NON-NLS-1$
		    consumeFormalParameter(false);  
			break;
 
    case 206 : if (DEBUG) { System.out.println("FormalParameter ::= Modifiersopt GenericTypeDotName..."); }  //$NON-NLS-1$
		    consumeFormalParameter(true);  
			break;
 
    case 208 : if (DEBUG) { System.out.println("ClassTypeList ::= ClassTypeList COMMA ClassTypeElt"); }  //$NON-NLS-1$
		    consumeClassTypeList();  
			break;
 
    case 209 : if (DEBUG) { System.out.println("ClassTypeElt ::= ClassType"); }  //$NON-NLS-1$
		    consumeClassTypeElt();  
			break;
 
    case 210 : if (DEBUG) { System.out.println("MethodBody ::= NestedMethod LBRACE BlockStatementsopt..."); }  //$NON-NLS-1$
		    consumeMethodBody();  
			break;
 
    case 211 : if (DEBUG) { System.out.println("NestedMethod ::="); }  //$NON-NLS-1$
		    consumeNestedMethod();  
			break;
 
    case 212 : if (DEBUG) { System.out.println("StaticInitializer ::= StaticOnly Block"); }  //$NON-NLS-1$
		    consumeStaticInitializer();  
			break;

    case 213 : if (DEBUG) { System.out.println("StaticOnly ::= static"); }  //$NON-NLS-1$
		    consumeStaticOnly();  
			break;
 
    case 214 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader MethodBody"); }  //$NON-NLS-1$
		    consumeConstructorDeclaration() ;  
			break;
 
    case 215 : if (DEBUG) { System.out.println("ConstructorDeclaration ::= ConstructorHeader SEMICOLON"); }  //$NON-NLS-1$
		    consumeInvalidConstructorDeclaration() ;  
			break;
 
    case 216 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= this LPAREN..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocation(0, THIS_CALL);  
			break;
 
    case 217 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments this"); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocationWithTypeArguments(0,THIS_CALL);  
			break;
 
    case 218 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= super LPAREN..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocation(0,SUPER_CALL);  
			break;
 
    case 219 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= OnlyTypeArguments..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocationWithTypeArguments(0,SUPER_CALL);  
			break;
 
    case 220 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT super..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocation(1, SUPER_CALL);  
			break;
 
    case 221 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocationWithTypeArguments(1, SUPER_CALL);  
			break;
 
    case 222 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT super LPAREN"); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocation(2, SUPER_CALL);  
			break;
 
    case 223 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocationWithTypeArguments(2, SUPER_CALL);  
			break;
 
    case 224 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT this..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocation(1, THIS_CALL);  
			break;
 
    case 225 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Primary DOT..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocationWithTypeArguments(1, THIS_CALL);  
			break;
 
    case 226 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT this LPAREN"); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocation(2, THIS_CALL);  
			break;
 
    case 227 : if (DEBUG) { System.out.println("ExplicitConstructorInvocation ::= Name DOT..."); }  //$NON-NLS-1$
		    consumeExplicitConstructorInvocationWithTypeArguments(2, THIS_CALL);  
			break;
 
    case 228 : if (DEBUG) { System.out.println("InterfaceDeclaration ::= InterfaceHeader InterfaceBody"); }  //$NON-NLS-1$
		    consumeInterfaceDeclaration();  
			break;
 
    case 229 : if (DEBUG) { System.out.println("InterfaceHeader ::= InterfaceHeaderName..."); }  //$NON-NLS-1$
		    consumeInterfaceHeader();  
			break;
 
    case 230 : if (DEBUG) { System.out.println("InterfaceHeaderName ::= InterfaceHeaderName1..."); }  //$NON-NLS-1$
		    consumeTypeHeaderNameWithTypeParameters();  
			break;
 
    case 232 : if (DEBUG) { System.out.println("InterfaceHeaderName1 ::= Modifiersopt interface..."); }  //$NON-NLS-1$
		    consumeInterfaceHeaderName1();  
			break;
 
    case 233 : if (DEBUG) { System.out.println("InterfaceHeaderExtends ::= extends InterfaceTypeList"); }  //$NON-NLS-1$
		    consumeInterfaceHeaderExtends();  
			break;
 
    case 236 : if (DEBUG) { System.out.println("InterfaceMemberDeclarations ::=..."); }  //$NON-NLS-1$
		    consumeInterfaceMemberDeclarations();  
			break;
 
    case 237 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= SEMICOLON"); }  //$NON-NLS-1$
		    consumeEmptyTypeDeclaration();  
			break;
 
    case 239 : if (DEBUG) { System.out.println("InterfaceMemberDeclaration ::= MethodHeader MethodBody"); }  //$NON-NLS-1$
		    consumeInvalidMethodDeclaration();  
			break;
 
    case 240 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); }  //$NON-NLS-1$
		    consumeInvalidConstructorDeclaration(true);   
			break;
 
    case 241 : if (DEBUG) { System.out.println("InvalidConstructorDeclaration ::= ConstructorHeader..."); }  //$NON-NLS-1$
		    consumeInvalidConstructorDeclaration(false);   
			break;
 
    case 249 : if (DEBUG) { System.out.println("PushLeftBrace ::="); }  //$NON-NLS-1$
		    consumePushLeftBrace();  
			break;
 
    case 250 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace ,opt RBRACE"); }  //$NON-NLS-1$
		    consumeEmptyArrayInitializer();  
			break;
 
    case 251 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); }  //$NON-NLS-1$
		    consumeArrayInitializer();  
			break;
 
    case 252 : if (DEBUG) { System.out.println("ArrayInitializer ::= LBRACE PushLeftBrace..."); }  //$NON-NLS-1$
		    consumeArrayInitializer();  
			break;
 
    case 254 : if (DEBUG) { System.out.println("VariableInitializers ::= VariableInitializers COMMA..."); }  //$NON-NLS-1$
		    consumeVariableInitializers();  
			break;
 
    case 255 : if (DEBUG) { System.out.println("Block ::= OpenBlock LBRACE BlockStatementsopt RBRACE"); }  //$NON-NLS-1$
		    consumeBlock();  
			break;
 
    case 256 : if (DEBUG) { System.out.println("OpenBlock ::="); }  //$NON-NLS-1$
		    consumeOpenBlock() ;  
			break;
 
    case 258 : if (DEBUG) { System.out.println("BlockStatements ::= BlockStatements BlockStatement"); }  //$NON-NLS-1$
		    consumeBlockStatements() ;  
			break;
 
    case 262 : if (DEBUG) { System.out.println("BlockStatement ::= InterfaceDeclaration"); }  //$NON-NLS-1$
		    consumeInvalidInterfaceDeclaration();  
			break;
 
    case 263 : if (DEBUG) { System.out.println("BlockStatement ::= AnnotationTypeDeclaration"); }  //$NON-NLS-1$
		    consumeInvalidAnnotationTypeDeclaration();  
			break;
 
    case 264 : if (DEBUG) { System.out.println("BlockStatement ::= EnumDeclaration"); }  //$NON-NLS-1$
		    consumeInvalidEnumDeclaration();  
			break;
 
    case 265 : if (DEBUG) { System.out.println("LocalVariableDeclarationStatement ::=..."); }  //$NON-NLS-1$
		    consumeLocalVariableDeclarationStatement();  
			break;
 
    case 266 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= UnannotatedType..."); }  //$NON-NLS-1$
		    consumeLocalVariableDeclaration();  
			break;
 
    case 267 : if (DEBUG) { System.out.println("LocalVariableDeclaration ::= Modifiers UnannotatedType"); }  //$NON-NLS-1$
		    consumeLocalVariableDeclaration();  
			break;
 
    case 268 : if (DEBUG) { System.out.println("PushModifiers ::="); }  //$NON-NLS-1$
		    consumePushModifiers();  
			break;
 
    case 269 : if (DEBUG) { System.out.println("PushModifiersForHeader ::="); }  //$NON-NLS-1$
		    consumePushModifiersForHeader();  
			break;
 
    case 270 : if (DEBUG) { System.out.println("PushRealModifiers ::="); }  //$NON-NLS-1$
		    consumePushRealModifiers();  
			break;
 
    case 296 : if (DEBUG) { System.out.println("EmptyStatement ::= SEMICOLON"); }  //$NON-NLS-1$
		    consumeEmptyStatement();  
			break;
 
    case 297 : if (DEBUG) { System.out.println("LabeledStatement ::= Label COLON Statement"); }  //$NON-NLS-1$
		    consumeStatementLabel() ;  
			break;
 
    case 298 : if (DEBUG) { System.out.println("LabeledStatementNoShortIf ::= Label COLON..."); }  //$NON-NLS-1$
		    consumeStatementLabel() ;  
			break;
 
    case 299 : if (DEBUG) { System.out.println("Label ::= Identifier"); }  //$NON-NLS-1$
		    consumeLabel() ;  
			break;
 
     case 300 : if (DEBUG) { System.out.println("ExpressionStatement ::= StatementExpression SEMICOLON"); }  //$NON-NLS-1$
		    consumeExpressionStatement();  
			break;
 
    case 309 : if (DEBUG) { System.out.println("IfThenStatement ::= if LPAREN Expression RPAREN..."); }  //$NON-NLS-1$
		    consumeStatementIfNoElse();  
			break;
 
    case 310 : if (DEBUG) { System.out.println("IfThenElseStatement ::= if LPAREN Expression RPAREN..."); }  //$NON-NLS-1$
		    consumeStatementIfWithElse();  
			break;
 
    case 311 : if (DEBUG) { System.out.println("IfThenElseStatementNoShortIf ::= if LPAREN Expression..."); }  //$NON-NLS-1$
		    consumeStatementIfWithElse();  
			break;
 
    case 312 : if (DEBUG) { System.out.println("SwitchStatement ::= switch LPAREN Expression RPAREN..."); }  //$NON-NLS-1$
		    consumeStatementSwitch() ;  
			break;
 
    case 313 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE RBRACE"); }  //$NON-NLS-1$
		    consumeEmptySwitchBlock() ;  
			break;
 
    case 316 : if (DEBUG) { System.out.println("SwitchBlock ::= LBRACE SwitchBlockStatements..."); }  //$NON-NLS-1$
		    consumeSwitchBlock() ;  
			break;
 
    case 318 : if (DEBUG) { System.out.println("SwitchBlockStatements ::= SwitchBlockStatements..."); }  //$NON-NLS-1$
		    consumeSwitchBlockStatements() ;  
			break;
 
    case 319 : if (DEBUG) { System.out.println("SwitchBlockStatement ::= SwitchLabels BlockStatements"); }  //$NON-NLS-1$
		    consumeSwitchBlockStatement() ;  
			break;
 
    case 321 : if (DEBUG) { System.out.println("SwitchLabels ::= SwitchLabels SwitchLabel"); }  //$NON-NLS-1$
		    consumeSwitchLabels() ;  
			break;
 
     case 322 : if (DEBUG) { System.out.println("SwitchLabel ::= case ConstantExpression COLON"); }  //$NON-NLS-1$
		    consumeCaseLabel();  
			break;
 
     case 323 : if (DEBUG) { System.out.println("SwitchLabel ::= default COLON"); }  //$NON-NLS-1$
		    consumeDefaultLabel();  
			break;
 
    case 324 : if (DEBUG) { System.out.println("WhileStatement ::= while LPAREN Expression RPAREN..."); }  //$NON-NLS-1$
		    consumeStatementWhile() ;  
			break;
 
    case 325 : if (DEBUG) { System.out.println("WhileStatementNoShortIf ::= while LPAREN Expression..."); }  //$NON-NLS-1$
		    consumeStatementWhile() ;  
			break;
 
    case 326 : if (DEBUG) { System.out.println("DoStatement ::= do Statement while LPAREN Expression..."); }  //$NON-NLS-1$
		    consumeStatementDo() ;  
			break;
 
    case 327 : if (DEBUG) { System.out.println("ForStatement ::= for LPAREN ForInitopt SEMICOLON..."); }  //$NON-NLS-1$
		    consumeStatementFor() ;  
			break;
 
    case 328 : if (DEBUG) { System.out.println("ForStatementNoShortIf ::= for LPAREN ForInitopt..."); }  //$NON-NLS-1$
		    consumeStatementFor() ;  
			break;
 
    case 329 : if (DEBUG) { System.out.println("ForInit ::= StatementExpressionList"); }  //$NON-NLS-1$
		    consumeForInit() ;  
			break;
 
    case 333 : if (DEBUG) { System.out.println("StatementExpressionList ::= StatementExpressionList..."); }  //$NON-NLS-1$
		    consumeStatementExpressionList() ;  
			break;
 
    case 334 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression SEMICOLON"); }  //$NON-NLS-1$
		    consumeSimpleAssertStatement() ;  
			break;
 
    case 335 : if (DEBUG) { System.out.println("AssertStatement ::= assert Expression COLON Expression"); }  //$NON-NLS-1$
		    consumeAssertStatement() ;  
			break;
 
    case 336 : if (DEBUG) { System.out.println("BreakStatement ::= break SEMICOLON"); }  //$NON-NLS-1$
		    consumeStatementBreak() ;  
			break;
 
    case 337 : if (DEBUG) { System.out.println("BreakStatement ::= break Identifier SEMICOLON"); }  //$NON-NLS-1$
		    consumeStatementBreakWithLabel() ;  
			break;
 
    case 338 : if (DEBUG) { System.out.println("ContinueStatement ::= continue SEMICOLON"); }  //$NON-NLS-1$
		    consumeStatementContinue() ;  
			break;
 
    case 339 : if (DEBUG) { System.out.println("ContinueStatement ::= continue Identifier SEMICOLON"); }  //$NON-NLS-1$
		    consumeStatementContinueWithLabel() ;  
			break;
 
    case 340 : if (DEBUG) { System.out.println("ReturnStatement ::= return Expressionopt SEMICOLON"); }  //$NON-NLS-1$
		    consumeStatementReturn() ;  
			break;
 
    case 341 : if (DEBUG) { System.out.println("ThrowStatement ::= throw Expression SEMICOLON"); }  //$NON-NLS-1$
		    consumeStatementThrow();  
			break;
 
    case 342 : if (DEBUG) { System.out.println("SynchronizedStatement ::= OnlySynchronized LPAREN..."); }  //$NON-NLS-1$
		    consumeStatementSynchronized();  
			break;
 
    case 343 : if (DEBUG) { System.out.println("OnlySynchronized ::= synchronized"); }  //$NON-NLS-1$
		    consumeOnlySynchronized();  
			break;
 
    case 344 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catches"); }  //$NON-NLS-1$
		    consumeStatementTry(false);  
			break;
 
    case 345 : if (DEBUG) { System.out.println("TryStatement ::= try TryBlock Catchesopt Finally"); }  //$NON-NLS-1$
		    consumeStatementTry(true);  
			break;
 
    case 347 : if (DEBUG) { System.out.println("ExitTryBlock ::="); }  //$NON-NLS-1$
		    consumeExitTryBlock();  
			break;
 
    case 349 : if (DEBUG) { System.out.println("Catches ::= Catches CatchClause"); }  //$NON-NLS-1$
		    consumeCatches();  
			break;
 
    case 350 : if (DEBUG) { System.out.println("CatchClause ::= catch LPAREN FormalParameter RPAREN..."); }  //$NON-NLS-1$
		    consumeStatementCatch() ;  
			break;
 
    case 352 : if (DEBUG) { System.out.println("PushLPAREN ::= LPAREN"); }  //$NON-NLS-1$
		    consumeLeftParen();  
			break;
 
    case 353 : if (DEBUG) { System.out.println("PushRPAREN ::= RPAREN"); }  //$NON-NLS-1$
		    consumeRightParen();  
			break;
 
    case 358 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= this"); }  //$NON-NLS-1$
		    consumePrimaryNoNewArrayThis();  
			break;
 
    case 359 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Expression_NotName..."); }  //$NON-NLS-1$
		    consumePrimaryNoNewArray();  
			break;
 
    case 360 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PushLPAREN Name PushRPAREN"); }  //$NON-NLS-1$
		    consumePrimaryNoNewArrayWithName();  
			break;
 
    case 363 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT this"); }  //$NON-NLS-1$
		    consumePrimaryNoNewArrayNameThis();  
			break;
 
    case 364 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT super"); }  //$NON-NLS-1$
		    consumePrimaryNoNewArrayNameSuper();  
			break;
 
    case 365 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name DOT class"); }  //$NON-NLS-1$
		    consumePrimaryNoNewArrayName();  
			break;
 
    case 366 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= Name Dims DOT class"); }  //$NON-NLS-1$
		    consumePrimaryNoNewArrayArrayType();  
			break;
 
    case 367 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType Dims DOT class"); }  //$NON-NLS-1$
		    consumePrimaryNoNewArrayPrimitiveArrayType();  
			break;
 
    case 368 : if (DEBUG) { System.out.println("PrimaryNoNewArray ::= PrimitiveType DOT class"); }  //$NON-NLS-1$
		    consumePrimaryNoNewArrayPrimitiveType();  
			break;
 
    case 371 : if (DEBUG) { System.out.println("AllocationHeader ::= new ClassType LPAREN..."); }  //$NON-NLS-1$
		    consumeAllocationHeader();  
			break;
 
    case 372 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new..."); }  //$NON-NLS-1$
		    consumeClassInstanceCreationExpressionWithTypeArguments();  
			break;
 
    case 373 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= new ClassType LPAREN"); }  //$NON-NLS-1$
		    consumeClassInstanceCreationExpression();  
			break;
 
    case 374 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); }  //$NON-NLS-1$
		    consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;  
			break;
 
    case 375 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::= Primary DOT new..."); }  //$NON-NLS-1$
		    consumeClassInstanceCreationExpressionQualified() ;  
			break;
 
    case 376 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); }  //$NON-NLS-1$
		    consumeClassInstanceCreationExpressionQualified() ;  
			break;
 
    case 377 : if (DEBUG) { System.out.println("ClassInstanceCreationExpression ::=..."); }  //$NON-NLS-1$
		    consumeClassInstanceCreationExpressionQualifiedWithTypeArguments() ;  
			break;
 
    case 378 : if (DEBUG) { System.out.println("ClassInstanceCreationExpressionName ::= Name DOT"); }  //$NON-NLS-1$
		    consumeClassInstanceCreationExpressionName() ;  
			break;
 
    case 379 : if (DEBUG) { System.out.println("UnqualifiedClassBodyopt ::="); }  //$NON-NLS-1$
		    consumeClassBodyopt();  
			break;
 
    case 381 : if (DEBUG) { System.out.println("UnqualifiedEnterAnonymousClassBody ::="); }  //$NON-NLS-1$
		    consumeEnterAnonymousClassBody(false);  
			break;
 
    case 382 : if (DEBUG) { System.out.println("QualifiedClassBodyopt ::="); }  //$NON-NLS-1$
		    consumeClassBodyopt();  
			break;
 
    case 384 : if (DEBUG) { System.out.println("QualifiedEnterAnonymousClassBody ::="); }  //$NON-NLS-1$
		    consumeEnterAnonymousClassBody(true);  
			break;
 
    case 386 : if (DEBUG) { System.out.println("ArgumentList ::= ArgumentList COMMA Expression"); }  //$NON-NLS-1$
		    consumeArgumentList();  
			break;
 
    case 387 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new PrimitiveType..."); }  //$NON-NLS-1$
		    consumeArrayCreationHeader();  
			break;
 
    case 388 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new OneOrMoreAnnotations..."); }  //$NON-NLS-1$
		    consumeArrayCreationHeader();  
			break;
 
    case 389 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new ClassOrInterfaceType..."); }  //$NON-NLS-1$
		    consumeArrayCreationHeader();  
			break;
 
    case 390 : if (DEBUG) { System.out.println("ArrayCreationHeader ::= new OneOrMoreAnnotations..."); }  //$NON-NLS-1$
		    consumeArrayCreationHeader();  
			break;
 
    case 391 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); }  //$NON-NLS-1$
		    consumeArrayCreationExpressionWithoutInitializer();  
			break;
 
    case 392 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); }  //$NON-NLS-1$
		    consumeArrayCreationExpressionWithoutInitializer();  
			break;
 
    case 393 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new PrimitiveType"); }  //$NON-NLS-1$
		    consumeArrayCreationExpressionWithInitializer();  
			break;
 
    case 394 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); }  //$NON-NLS-1$
		    consumeArrayCreationExpressionWithInitializer();  
			break;
 
    case 395 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); }  //$NON-NLS-1$
		    consumeArrayCreationExpressionWithoutInitializer();  
			break;
 
    case 396 : if (DEBUG) { System.out.println("ArrayCreationWithoutArrayInitializer ::= new..."); }  //$NON-NLS-1$
		    consumeArrayCreationExpressionWithoutInitializer();  
			break;
 
    case 397 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); }  //$NON-NLS-1$
		    consumeArrayCreationExpressionWithInitializer();  
			break;
 
    case 398 : if (DEBUG) { System.out.println("ArrayCreationWithArrayInitializer ::= new..."); }  //$NON-NLS-1$
		    consumeArrayCreationExpressionWithInitializer();  
			break;
 
    case 400 : if (DEBUG) { System.out.println("DimWithOrWithOutExprs ::= DimWithOrWithOutExprs..."); }  //$NON-NLS-1$
		    consumeDimWithOrWithOutExprs();  
			break;
 
     case 402 : if (DEBUG) { System.out.println("DimWithOrWithOutExpr ::= LBRACKET RBRACKET"); }  //$NON-NLS-1$
		    consumeDimWithOrWithOutExpr();  
			break;
 
     case 403 : if (DEBUG) { System.out.println("DimsoptAnnotsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyDimsoptAnnotsopt();  
			break;
 
     case 404 : if (DEBUG) { System.out.println("DimsoptAnnotsopt -> DimsAnnotLoop"); }  //$NON-NLS-1$
		    consumeDimsWithTrailingAnnotsopt();  
			break;
 
     case 408 : if (DEBUG) { System.out.println("OneDimOrAnnot ::= LBRACKET RBRACKET"); }  //$NON-NLS-1$
		    consumeOneDimLoop();  
			break;
 
     case 411 : if (DEBUG) { System.out.println("Dims ::= DimsLoop"); }  //$NON-NLS-1$
		    consumeDims();  
			break;
 
     case 414 : if (DEBUG) { System.out.println("OneDimLoop ::= LBRACKET RBRACKET"); }  //$NON-NLS-1$
		    consumeOneDimLoop();  
			break;
 
     case 415 : if (DEBUG) { System.out.println("OneDimLoop ::= OneOrMoreAnnotations LBRACKET RBRACKET"); }  //$NON-NLS-1$
		    consumeOneDimLoopWithAnnotations();  
			break;
 
    case 416 : if (DEBUG) { System.out.println("FieldAccess ::= Primary DOT Identifier"); }  //$NON-NLS-1$
		    consumeFieldAccess(false);  
			break;
 
    case 417 : if (DEBUG) { System.out.println("FieldAccess ::= super DOT Identifier"); }  //$NON-NLS-1$
		    consumeFieldAccess(true);  
			break;
 
    case 418 : if (DEBUG) { System.out.println("MethodInvocation ::= Name LPAREN ArgumentListopt RPAREN"); }  //$NON-NLS-1$
		    consumeMethodInvocationName();  
			break;
 
    case 419 : if (DEBUG) { System.out.println("MethodInvocation ::= Name DOT OnlyTypeArguments..."); }  //$NON-NLS-1$
		    consumeMethodInvocationNameWithTypeArguments();  
			break;
 
    case 420 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT OnlyTypeArguments..."); }  //$NON-NLS-1$
		    consumeMethodInvocationPrimaryWithTypeArguments();  
			break;
 
    case 421 : if (DEBUG) { System.out.println("MethodInvocation ::= Primary DOT Identifier LPAREN..."); }  //$NON-NLS-1$
		    consumeMethodInvocationPrimary();  
			break;
 
    case 422 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT OnlyTypeArguments..."); }  //$NON-NLS-1$
		    consumeMethodInvocationSuperWithTypeArguments();  
			break;
 
    case 423 : if (DEBUG) { System.out.println("MethodInvocation ::= super DOT Identifier LPAREN..."); }  //$NON-NLS-1$
		    consumeMethodInvocationSuper();  
			break;
 
    case 424 : if (DEBUG) { System.out.println("ArrayAccess ::= Name LBRACKET Expression RBRACKET"); }  //$NON-NLS-1$
		    consumeArrayAccess(true);  
			break;
 
    case 425 : if (DEBUG) { System.out.println("ArrayAccess ::= PrimaryNoNewArray LBRACKET Expression..."); }  //$NON-NLS-1$
		    consumeArrayAccess(false);  
			break;
 
    case 426 : if (DEBUG) { System.out.println("ArrayAccess ::= ArrayCreationWithArrayInitializer..."); }  //$NON-NLS-1$
		    consumeArrayAccess(false);  
			break;
 
    case 428 : if (DEBUG) { System.out.println("PostfixExpression ::= Name"); }  //$NON-NLS-1$
		    consumePostfixExpression();  
			break;
 
    case 431 : if (DEBUG) { System.out.println("PostIncrementExpression ::= PostfixExpression PLUS_PLUS"); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.PLUS,true);  
			break;
 
    case 432 : if (DEBUG) { System.out.println("PostDecrementExpression ::= PostfixExpression..."); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.MINUS,true);  
			break;
 
    case 433 : if (DEBUG) { System.out.println("PushPosition ::="); }  //$NON-NLS-1$
		    consumePushPosition();  
			break;
 
    case 436 : if (DEBUG) { System.out.println("UnaryExpression ::= PLUS PushPosition UnaryExpression"); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.PLUS);  
			break;
 
    case 437 : if (DEBUG) { System.out.println("UnaryExpression ::= MINUS PushPosition UnaryExpression"); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.MINUS);  
			break;
 
    case 439 : if (DEBUG) { System.out.println("PreIncrementExpression ::= PLUS_PLUS PushPosition..."); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.PLUS,false);  
			break;
 
    case 440 : if (DEBUG) { System.out.println("PreDecrementExpression ::= MINUS_MINUS PushPosition..."); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.MINUS,false);  
			break;
 
    case 442 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= TWIDDLE PushPosition..."); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.TWIDDLE);  
			break;
 
    case 443 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus ::= NOT PushPosition..."); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.NOT);  
			break;
 
    case 445 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN PrimitiveType Dimsopt..."); }  //$NON-NLS-1$
		    consumeCastExpressionWithPrimitiveType();  
			break;
 
    case 446 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations..."); }  //$NON-NLS-1$
		    consumeCastExpressionWithPrimitiveType();  
			break;
 
    case 447 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); }  //$NON-NLS-1$
		    consumeCastExpressionWithGenericsArray();  
			break;
 
    case 448 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); }  //$NON-NLS-1$
		    consumeCastExpressionWithGenericsArray();  
			break;
 
    case 449 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name..."); }  //$NON-NLS-1$
		    consumeCastExpressionWithQualifiedGenericsArray();  
			break;
 
    case 450 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); }  //$NON-NLS-1$
		    consumeCastExpressionWithQualifiedGenericsArray();  
			break;
 
    case 451 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name PushRPAREN..."); }  //$NON-NLS-1$
		    consumeCastExpressionLL1();  
			break;
 
    case 452 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); }  //$NON-NLS-1$
		    consumeCastExpressionLL1();  
			break;
 
    case 453 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN Name Dims PushRPAREN..."); }  //$NON-NLS-1$
		    consumeCastExpressionWithNameArray();  
			break;
 
    case 454 : if (DEBUG) { System.out.println("CastExpression ::= PushLPAREN OneOrMoreAnnotations Name"); }  //$NON-NLS-1$
		    consumeCastExpressionWithNameArray();  
			break;
 
    case 455 : if (DEBUG) { System.out.println("OnlyTypeArgumentsForCastExpression ::= OnlyTypeArguments"); }  //$NON-NLS-1$
		    consumeOnlyTypeArgumentsForCastExpression();  
			break;
 
    case 456 : if (DEBUG) { System.out.println("InsideCastExpression ::="); }  //$NON-NLS-1$
		    consumeInsideCastExpression();  
			break;
 
    case 457 : if (DEBUG) { System.out.println("InsideCastExpressionLL1 ::="); }  //$NON-NLS-1$
		    consumeInsideCastExpressionLL1();  
			break;
 
    case 458 : if (DEBUG) { System.out.println("InsideCastExpressionWithQualifiedGenerics ::="); }  //$NON-NLS-1$
		    consumeInsideCastExpressionWithQualifiedGenerics();  
			break;
 
    case 460 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.MULTIPLY);  
			break;
 
    case 461 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.DIVIDE);  
			break;
 
    case 462 : if (DEBUG) { System.out.println("MultiplicativeExpression ::= MultiplicativeExpression..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.REMAINDER);  
			break;
 
    case 464 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression PLUS..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.PLUS);  
			break;
 
    case 465 : if (DEBUG) { System.out.println("AdditiveExpression ::= AdditiveExpression MINUS..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.MINUS);  
			break;
 
    case 467 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression LEFT_SHIFT..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.LEFT_SHIFT);  
			break;
 
    case 468 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression RIGHT_SHIFT..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);  
			break;
 
    case 469 : if (DEBUG) { System.out.println("ShiftExpression ::= ShiftExpression UNSIGNED_RIGHT_SHIFT"); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);  
			break;
 
    case 471 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.LESS);  
			break;
 
    case 472 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression GREATER..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.GREATER);  
			break;
 
    case 473 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression LESS_EQUAL"); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.LESS_EQUAL);  
			break;
 
    case 474 : if (DEBUG) { System.out.println("RelationalExpression ::= RelationalExpression..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.GREATER_EQUAL);  
			break;
 
    case 476 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); }  //$NON-NLS-1$
		    consumeInstanceOfExpression();  
			break;
 
    case 477 : if (DEBUG) { System.out.println("InstanceofExpression ::= InstanceofExpression instanceof"); }  //$NON-NLS-1$
		    consumeInstanceOfExpression();  
			break;
 
    case 479 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression EQUAL_EQUAL..."); }  //$NON-NLS-1$
		    consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);  
			break;
 
    case 480 : if (DEBUG) { System.out.println("EqualityExpression ::= EqualityExpression NOT_EQUAL..."); }  //$NON-NLS-1$
		    consumeEqualityExpression(OperatorIds.NOT_EQUAL);  
			break;
 
    case 482 : if (DEBUG) { System.out.println("AndExpression ::= AndExpression AND EqualityExpression"); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.AND);  
			break;
 
    case 484 : if (DEBUG) { System.out.println("ExclusiveOrExpression ::= ExclusiveOrExpression XOR..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.XOR);  
			break;
 
    case 486 : if (DEBUG) { System.out.println("InclusiveOrExpression ::= InclusiveOrExpression OR..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.OR);  
			break;
 
    case 488 : if (DEBUG) { System.out.println("ConditionalAndExpression ::= ConditionalAndExpression..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.AND_AND);  
			break;
 
    case 490 : if (DEBUG) { System.out.println("ConditionalOrExpression ::= ConditionalOrExpression..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.OR_OR);  
			break;
 
    case 492 : if (DEBUG) { System.out.println("ConditionalExpression ::= ConditionalOrExpression..."); }  //$NON-NLS-1$
		    consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;  
			break;
 
    case 495 : if (DEBUG) { System.out.println("Assignment ::= PostfixExpression AssignmentOperator..."); }  //$NON-NLS-1$
		    consumeAssignment();  
			break;
 
    case 497 : if (DEBUG) { System.out.println("Assignment ::= InvalidArrayInitializerAssignement"); }  //$NON-NLS-1$
		    ignoreExpressionAssignment(); 
			break;
 
    case 498 : if (DEBUG) { System.out.println("AssignmentOperator ::= EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(EQUAL);  
			break;
 
    case 499 : if (DEBUG) { System.out.println("AssignmentOperator ::= MULTIPLY_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(MULTIPLY);  
			break;
 
    case 500 : if (DEBUG) { System.out.println("AssignmentOperator ::= DIVIDE_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(DIVIDE);  
			break;
 
    case 501 : if (DEBUG) { System.out.println("AssignmentOperator ::= REMAINDER_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(REMAINDER);  
			break;
 
    case 502 : if (DEBUG) { System.out.println("AssignmentOperator ::= PLUS_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(PLUS);  
			break;
 
    case 503 : if (DEBUG) { System.out.println("AssignmentOperator ::= MINUS_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(MINUS);  
			break;
 
    case 504 : if (DEBUG) { System.out.println("AssignmentOperator ::= LEFT_SHIFT_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(LEFT_SHIFT);  
			break;
 
    case 505 : if (DEBUG) { System.out.println("AssignmentOperator ::= RIGHT_SHIFT_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(RIGHT_SHIFT);  
			break;
 
    case 506 : if (DEBUG) { System.out.println("AssignmentOperator ::= UNSIGNED_RIGHT_SHIFT_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(UNSIGNED_RIGHT_SHIFT);  
			break;
 
    case 507 : if (DEBUG) { System.out.println("AssignmentOperator ::= AND_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(AND);  
			break;
 
    case 508 : if (DEBUG) { System.out.println("AssignmentOperator ::= XOR_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(XOR);  
			break;
 
    case 509 : if (DEBUG) { System.out.println("AssignmentOperator ::= OR_EQUAL"); }  //$NON-NLS-1$
		    consumeAssignmentOperator(OR);  
			break;
 
    case 513 : if (DEBUG) { System.out.println("Expressionopt ::="); }  //$NON-NLS-1$
		    consumeEmptyExpression();  
			break;
 
    case 518 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyClassBodyDeclarationsopt();  
			break;
 
    case 519 : if (DEBUG) { System.out.println("ClassBodyDeclarationsopt ::= NestedType..."); }  //$NON-NLS-1$
		    consumeClassBodyDeclarationsopt();  
			break;
 
     case 520 : if (DEBUG) { System.out.println("NonAnnotModifiersopt ::="); }  //$NON-NLS-1$
		    consumeDefaultModifiers();  
			break;
 
    case 521 : if (DEBUG) { System.out.println("NonAnnotModifiersopt ::= NonAnnotModifiers"); }  //$NON-NLS-1$
		    consumeModifiers();  
			break;
 
     case 522 : if (DEBUG) { System.out.println("Modifiersopt ::="); }  //$NON-NLS-1$
		    consumeDefaultModifiers();  
			break;
 
    case 523 : if (DEBUG) { System.out.println("Modifiersopt ::= Modifiers"); }  //$NON-NLS-1$
		    consumeModifiers();  
			break;
 
    case 524 : if (DEBUG) { System.out.println("BlockStatementsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyBlockStatementsopt();  
			break;
 
     case 526 : if (DEBUG) { System.out.println("Dimsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyDimsopt();  
			break;
 
     case 528 : if (DEBUG) { System.out.println("ArgumentListopt ::="); }  //$NON-NLS-1$
		    consumeEmptyArgumentListopt();  
			break;
 
    case 532 : if (DEBUG) { System.out.println("FormalParameterListopt ::="); }  //$NON-NLS-1$
		    consumeFormalParameterListopt();  
			break;
 
     case 536 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyInterfaceMemberDeclarationsopt();  
			break;
 
     case 537 : if (DEBUG) { System.out.println("InterfaceMemberDeclarationsopt ::= NestedType..."); }  //$NON-NLS-1$
		    consumeInterfaceMemberDeclarationsopt();  
			break;
 
    case 538 : if (DEBUG) { System.out.println("NestedType ::="); }  //$NON-NLS-1$
		    consumeNestedType();  
			break;

     case 539 : if (DEBUG) { System.out.println("ForInitopt ::="); }  //$NON-NLS-1$
		    consumeEmptyForInitopt();  
			break;
 
     case 541 : if (DEBUG) { System.out.println("ForUpdateopt ::="); }  //$NON-NLS-1$
		    consumeEmptyForUpdateopt();  
			break;
 
     case 545 : if (DEBUG) { System.out.println("Catchesopt ::="); }  //$NON-NLS-1$
		    consumeEmptyCatchesopt();  
			break;
 
     case 547 : if (DEBUG) { System.out.println("EnumDeclaration ::= EnumHeader EnumBody"); }  //$NON-NLS-1$
		    consumeEnumDeclaration();  
			break;
 
     case 548 : if (DEBUG) { System.out.println("EnumHeader ::= EnumHeaderName ClassHeaderImplementsopt"); }  //$NON-NLS-1$
		    consumeEnumHeader();  
			break;
 
     case 549 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier"); }  //$NON-NLS-1$
		    consumeEnumHeaderName();  
			break;
 
     case 550 : if (DEBUG) { System.out.println("EnumHeaderName ::= Modifiersopt enum Identifier..."); }  //$NON-NLS-1$
		    consumeEnumHeaderNameWithTypeParameters();  
			break;
 
     case 551 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumBodyDeclarationsopt RBRACE"); }  //$NON-NLS-1$
		    consumeEnumBodyNoConstants();  
			break;
 
     case 552 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE COMMA EnumBodyDeclarationsopt..."); }  //$NON-NLS-1$
		    consumeEnumBodyNoConstants();  
			break;
 
     case 553 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants COMMA..."); }  //$NON-NLS-1$
		    consumeEnumBodyWithConstants();  
			break;
 
     case 554 : if (DEBUG) { System.out.println("EnumBody ::= LBRACE EnumConstants..."); }  //$NON-NLS-1$
		    consumeEnumBodyWithConstants();  
			break;
 
    case 556 : if (DEBUG) { System.out.println("EnumConstants ::= EnumConstants COMMA EnumConstant"); }  //$NON-NLS-1$
		    consumeEnumConstants();  
			break;
 
    case 557 : if (DEBUG) { System.out.println("EnumConstantHeaderName ::= Modifiersopt Identifier"); }  //$NON-NLS-1$
		    consumeEnumConstantHeaderName();  
			break;
 
    case 558 : if (DEBUG) { System.out.println("EnumConstantHeader ::= EnumConstantHeaderName..."); }  //$NON-NLS-1$
		    consumeEnumConstantHeader();  
			break;
 
    case 559 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader ForceNoDiet..."); }  //$NON-NLS-1$
		    consumeEnumConstantWithClassBody();  
			break;
 
    case 560 : if (DEBUG) { System.out.println("EnumConstant ::= EnumConstantHeader"); }  //$NON-NLS-1$
		    consumeEnumConstantNoClassBody();  
			break;
 
    case 561 : if (DEBUG) { System.out.println("Arguments ::= LPAREN ArgumentListopt RPAREN"); }  //$NON-NLS-1$
		    consumeArguments();  
			break;
 
    case 562 : if (DEBUG) { System.out.println("Argumentsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyArguments();  
			break;
 
    case 564 : if (DEBUG) { System.out.println("EnumDeclarations ::= SEMICOLON ClassBodyDeclarationsopt"); }  //$NON-NLS-1$
		    consumeEnumDeclarations();  
			break;
 
    case 565 : if (DEBUG) { System.out.println("EnumBodyDeclarationsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyEnumDeclarations();  
			break;
 
    case 567 : if (DEBUG) { System.out.println("EnhancedForStatement ::= EnhancedForStatementHeader..."); }  //$NON-NLS-1$
		    consumeEnhancedForStatement();  
			break;
 
    case 568 : if (DEBUG) { System.out.println("EnhancedForStatementNoShortIf ::=..."); }  //$NON-NLS-1$
		    consumeEnhancedForStatement();  
			break;
 
    case 569 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN..."); }  //$NON-NLS-1$
		    consumeEnhancedForStatementHeaderInit(false);  
			break;
 
    case 570 : if (DEBUG) { System.out.println("EnhancedForStatementHeaderInit ::= for LPAREN Modifiers"); }  //$NON-NLS-1$
		    consumeEnhancedForStatementHeaderInit(true);  
			break;
 
    case 571 : if (DEBUG) { System.out.println("EnhancedForStatementHeader ::=..."); }  //$NON-NLS-1$
		    consumeEnhancedForStatementHeader();  
			break;
 
    case 572 : if (DEBUG) { System.out.println("SingleStaticImportDeclaration ::=..."); }  //$NON-NLS-1$
		    consumeImportDeclaration();  
			break;
 
    case 573 : if (DEBUG) { System.out.println("SingleStaticImportDeclarationName ::= import static Name"); }  //$NON-NLS-1$
		    consumeSingleStaticImportDeclarationName();  
			break;
 
    case 574 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclaration ::=..."); }  //$NON-NLS-1$
		    consumeImportDeclaration();  
			break;
 
    case 575 : if (DEBUG) { System.out.println("StaticImportOnDemandDeclarationName ::= import static..."); }  //$NON-NLS-1$
		    consumeStaticImportOnDemandDeclarationName();  
			break;
 
    case 576 : if (DEBUG) { System.out.println("TypeArguments ::= LESS TypeArgumentList1"); }  //$NON-NLS-1$
		    consumeTypeArguments();  
			break;
 
    case 577 : if (DEBUG) { System.out.println("OnlyTypeArguments ::= LESS TypeArgumentList1"); }  //$NON-NLS-1$
		    consumeOnlyTypeArguments();  
			break;
 
    case 579 : if (DEBUG) { System.out.println("TypeArgumentList1 ::= TypeArgumentList COMMA..."); }  //$NON-NLS-1$
		    consumeTypeArgumentList1();  
			break;
 
    case 581 : if (DEBUG) { System.out.println("TypeArgumentList ::= TypeArgumentList COMMA TypeArgument"); }  //$NON-NLS-1$
		    consumeTypeArgumentList();  
			break;
 
    case 582 : if (DEBUG) { System.out.println("TypeArgument ::= ReferenceType"); }  //$NON-NLS-1$
		    consumeTypeArgument();  
			break;
 
    case 583 : if (DEBUG) { System.out.println("TypeArgument ::= OneOrMoreAnnotations ReferenceType"); }  //$NON-NLS-1$
		    consumeTypeArgument();  
			break;
 
    case 587 : if (DEBUG) { System.out.println("ReferenceType1 ::= ReferenceType GREATER"); }  //$NON-NLS-1$
		    consumeReferenceType1();  
			break;
 
    case 588 : if (DEBUG) { System.out.println("ReferenceType1 ::= OneOrMoreAnnotations ReferenceType..."); }  //$NON-NLS-1$
		    consumeReferenceType1();  
			break;
 
    case 589 : if (DEBUG) { System.out.println("ReferenceType1 ::= ClassOrInterface LESS..."); }  //$NON-NLS-1$
		    consumeTypeArgumentReferenceType1();  
			break;
 
    case 590 : if (DEBUG) { System.out.println("ReferenceType1 ::= OneOrMoreAnnotations ClassOrInterface"); }  //$NON-NLS-1$
		    consumeTypeArgumentReferenceType1();  
			break;
 
    case 592 : if (DEBUG) { System.out.println("TypeArgumentList2 ::= TypeArgumentList COMMA..."); }  //$NON-NLS-1$
		    consumeTypeArgumentList2();  
			break;
 
    case 595 : if (DEBUG) { System.out.println("ReferenceType2 ::= ReferenceType RIGHT_SHIFT"); }  //$NON-NLS-1$
		    consumeReferenceType2();  
			break;
 
    case 596 : if (DEBUG) { System.out.println("ReferenceType2 ::= OneOrMoreAnnotations ReferenceType..."); }  //$NON-NLS-1$
		    consumeReferenceType2();  
			break;
 
    case 597 : if (DEBUG) { System.out.println("ReferenceType2 ::= ClassOrInterface LESS..."); }  //$NON-NLS-1$
		    consumeTypeArgumentReferenceType2();  
			break;
 
    case 598 : if (DEBUG) { System.out.println("ReferenceType2 ::= OneOrMoreAnnotations ClassOrInterface"); }  //$NON-NLS-1$
		    consumeTypeArgumentReferenceType2();  
			break;
 
    case 600 : if (DEBUG) { System.out.println("TypeArgumentList3 ::= TypeArgumentList COMMA..."); }  //$NON-NLS-1$
		    consumeTypeArgumentList3();  
			break;
 
    case 603 : if (DEBUG) { System.out.println("ReferenceType3 ::= ReferenceType UNSIGNED_RIGHT_SHIFT"); }  //$NON-NLS-1$
		    consumeReferenceType3();  
			break;
 
    case 604 : if (DEBUG) { System.out.println("ReferenceType3 ::= OneOrMoreAnnotations ReferenceType..."); }  //$NON-NLS-1$
		    consumeReferenceType3();  
			break;
 
    case 605 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION"); }  //$NON-NLS-1$
		    consumeWildcard();  
			break;
 
    case 606 : if (DEBUG) { System.out.println("Wildcard ::= QUESTION WildcardBounds"); }  //$NON-NLS-1$
		    consumeWildcardWithBounds();  
			break;
 
    case 607 : if (DEBUG) { System.out.println("WildcardBounds ::= extends ReferenceType"); }  //$NON-NLS-1$
		    consumeWildcardBoundsExtends();  
			break;
 
    case 608 : if (DEBUG) { System.out.println("WildcardBounds ::= extends OneOrMoreAnnotations..."); }  //$NON-NLS-1$
		    consumeWildcardBoundsExtends();  
			break;
 
    case 609 : if (DEBUG) { System.out.println("WildcardBounds ::= super ReferenceType"); }  //$NON-NLS-1$
		    consumeWildcardBoundsSuper();  
			break;
 
    case 610 : if (DEBUG) { System.out.println("WildcardBounds ::= super OneOrMoreAnnotations..."); }  //$NON-NLS-1$
		    consumeWildcardBoundsSuper();  
			break;
 
    case 611 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION GREATER"); }  //$NON-NLS-1$
		    consumeWildcard1();  
			break;
 
    case 612 : if (DEBUG) { System.out.println("Wildcard1 ::= QUESTION WildcardBounds1"); }  //$NON-NLS-1$
		    consumeWildcard1WithBounds();  
			break;
 
    case 613 : if (DEBUG) { System.out.println("WildcardBounds1 ::= extends ReferenceType1"); }  //$NON-NLS-1$
		    consumeWildcardBounds1Extends();  
			break;
 
    case 614 : if (DEBUG) { System.out.println("WildcardBounds1 ::= super ReferenceType1"); }  //$NON-NLS-1$
		    consumeWildcardBounds1Super();  
			break;
 
    case 615 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION RIGHT_SHIFT"); }  //$NON-NLS-1$
		    consumeWildcard2();  
			break;
 
    case 616 : if (DEBUG) { System.out.println("Wildcard2 ::= QUESTION WildcardBounds2"); }  //$NON-NLS-1$
		    consumeWildcard2WithBounds();  
			break;
 
    case 617 : if (DEBUG) { System.out.println("WildcardBounds2 ::= extends ReferenceType2"); }  //$NON-NLS-1$
		    consumeWildcardBounds2Extends();  
			break;
 
    case 618 : if (DEBUG) { System.out.println("WildcardBounds2 ::= super ReferenceType2"); }  //$NON-NLS-1$
		    consumeWildcardBounds2Super();  
			break;
 
    case 619 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION UNSIGNED_RIGHT_SHIFT"); }  //$NON-NLS-1$
		    consumeWildcard3();  
			break;
 
    case 620 : if (DEBUG) { System.out.println("Wildcard3 ::= QUESTION WildcardBounds3"); }  //$NON-NLS-1$
		    consumeWildcard3WithBounds();  
			break;
 
    case 621 : if (DEBUG) { System.out.println("WildcardBounds3 ::= extends ReferenceType3"); }  //$NON-NLS-1$
		    consumeWildcardBounds3Extends();  
			break;
 
    case 622 : if (DEBUG) { System.out.println("WildcardBounds3 ::= super ReferenceType3"); }  //$NON-NLS-1$
		    consumeWildcardBounds3Super();  
			break;
 
    case 623 : if (DEBUG) { System.out.println("TypeParameterHeader ::= Identifier"); }  //$NON-NLS-1$
		    consumeTypeParameterHeader();  
			break;
 
    case 624 : if (DEBUG) { System.out.println("TypeParameterHeader ::= OneOrMoreAnnotations Identifier"); }  //$NON-NLS-1$
		    consumeTypeParameterHeader();  
			break;
 
    case 625 : if (DEBUG) { System.out.println("TypeParameters ::= LESS TypeParameterList1"); }  //$NON-NLS-1$
		    consumeTypeParameters();  
			break;
 
    case 627 : if (DEBUG) { System.out.println("TypeParameterList ::= TypeParameterList COMMA..."); }  //$NON-NLS-1$
		    consumeTypeParameterList();  
			break;
 
    case 629 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
		    consumeTypeParameterWithExtends();  
			break;
 
    case 630 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
		    consumeTypeParameterWithExtends();  
			break;
 
    case 631 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
		    consumeTypeParameterWithExtendsAndBounds();  
			break;
 
    case 632 : if (DEBUG) { System.out.println("TypeParameter ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
		    consumeTypeParameterWithExtendsAndBounds();  
			break;
 
    case 634 : if (DEBUG) { System.out.println("AdditionalBoundList ::= AdditionalBoundList..."); }  //$NON-NLS-1$
		    consumeAdditionalBoundList();  
			break;
 
    case 635 : if (DEBUG) { System.out.println("AdditionalBound ::= AND ReferenceType"); }  //$NON-NLS-1$
		    consumeAdditionalBound();  
			break;
 
    case 636 : if (DEBUG) { System.out.println("AdditionalBound ::= AND OneOrMoreAnnotations..."); }  //$NON-NLS-1$
		    consumeAdditionalBound();  
			break;
 
    case 638 : if (DEBUG) { System.out.println("TypeParameterList1 ::= TypeParameterList COMMA..."); }  //$NON-NLS-1$
		    consumeTypeParameterList1();  
			break;
 
    case 639 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader GREATER"); }  //$NON-NLS-1$
		    consumeTypeParameter1();  
			break;
 
    case 640 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
		    consumeTypeParameter1WithExtends();  
			break;
 
    case 641 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
		    consumeTypeParameter1WithExtendsAndBounds();  
			break;
 
    case 642 : if (DEBUG) { System.out.println("TypeParameter1 ::= TypeParameterHeader extends..."); }  //$NON-NLS-1$
		    consumeTypeParameter1WithExtendsAndBounds();  
			break;
 
    case 644 : if (DEBUG) { System.out.println("AdditionalBoundList1 ::= AdditionalBoundList..."); }  //$NON-NLS-1$
		    consumeAdditionalBoundList1();  
			break;
 
    case 645 : if (DEBUG) { System.out.println("AdditionalBound1 ::= AND ReferenceType1"); }  //$NON-NLS-1$
		    consumeAdditionalBound1();  
			break;
 
    case 651 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= PLUS PushPosition..."); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.PLUS);  
			break;
 
    case 652 : if (DEBUG) { System.out.println("UnaryExpression_NotName ::= MINUS PushPosition..."); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.MINUS);  
			break;
 
    case 655 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= TWIDDLE..."); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.TWIDDLE);  
			break;
 
    case 656 : if (DEBUG) { System.out.println("UnaryExpressionNotPlusMinus_NotName ::= NOT PushPosition"); }  //$NON-NLS-1$
		    consumeUnaryExpression(OperatorIds.NOT);  
			break;
 
    case 659 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.MULTIPLY);  
			break;
 
    case 660 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name MULTIPLY..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.MULTIPLY);  
			break;
 
    case 661 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.DIVIDE);  
			break;
 
    case 662 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name DIVIDE..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.DIVIDE);  
			break;
 
    case 663 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.REMAINDER);  
			break;
 
    case 664 : if (DEBUG) { System.out.println("MultiplicativeExpression_NotName ::= Name REMAINDER..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.REMAINDER);  
			break;
 
    case 666 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.PLUS);  
			break;
 
    case 667 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name PLUS..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.PLUS);  
			break;
 
    case 668 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.MINUS);  
			break;
 
    case 669 : if (DEBUG) { System.out.println("AdditiveExpression_NotName ::= Name MINUS..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.MINUS);  
			break;
 
    case 671 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.LEFT_SHIFT);  
			break;
 
    case 672 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name LEFT_SHIFT..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.LEFT_SHIFT);  
			break;
 
    case 673 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.RIGHT_SHIFT);  
			break;
 
    case 674 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name RIGHT_SHIFT..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.RIGHT_SHIFT);  
			break;
 
    case 675 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= ShiftExpression_NotName..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.UNSIGNED_RIGHT_SHIFT);  
			break;
 
    case 676 : if (DEBUG) { System.out.println("ShiftExpression_NotName ::= Name UNSIGNED_RIGHT_SHIFT..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.UNSIGNED_RIGHT_SHIFT);  
			break;
 
    case 678 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.LESS);  
			break;
 
    case 679 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.LESS);  
			break;
 
    case 680 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= ShiftExpression_NotName"); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.GREATER);  
			break;
 
    case 681 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.GREATER);  
			break;
 
    case 682 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.LESS_EQUAL);  
			break;
 
    case 683 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name LESS_EQUAL..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.LESS_EQUAL);  
			break;
 
    case 684 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.GREATER_EQUAL);  
			break;
 
    case 685 : if (DEBUG) { System.out.println("RelationalExpression_NotName ::= Name GREATER_EQUAL..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.GREATER_EQUAL);  
			break;
 
    case 687 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); }  //$NON-NLS-1$
		    consumeInstanceOfExpressionWithName();  
			break;
 
    case 688 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::= Name instanceof..."); }  //$NON-NLS-1$
		    consumeInstanceOfExpressionWithName();  
			break;
 
    case 689 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeInstanceOfExpression();  
			break;
 
    case 690 : if (DEBUG) { System.out.println("InstanceofExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeInstanceOfExpression();  
			break;
 
    case 692 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeEqualityExpression(OperatorIds.EQUAL_EQUAL);  
			break;
 
    case 693 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name EQUAL_EQUAL..."); }  //$NON-NLS-1$
		    consumeEqualityExpressionWithName(OperatorIds.EQUAL_EQUAL);  
			break;
 
    case 694 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeEqualityExpression(OperatorIds.NOT_EQUAL);  
			break;
 
    case 695 : if (DEBUG) { System.out.println("EqualityExpression_NotName ::= Name NOT_EQUAL..."); }  //$NON-NLS-1$
		    consumeEqualityExpressionWithName(OperatorIds.NOT_EQUAL);  
			break;
 
    case 697 : if (DEBUG) { System.out.println("AndExpression_NotName ::= AndExpression_NotName AND..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.AND);  
			break;
 
    case 698 : if (DEBUG) { System.out.println("AndExpression_NotName ::= Name AND EqualityExpression"); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.AND);  
			break;
 
    case 700 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.XOR);  
			break;
 
    case 701 : if (DEBUG) { System.out.println("ExclusiveOrExpression_NotName ::= Name XOR AndExpression"); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.XOR);  
			break;
 
    case 703 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.OR);  
			break;
 
    case 704 : if (DEBUG) { System.out.println("InclusiveOrExpression_NotName ::= Name OR..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.OR);  
			break;
 
    case 706 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.AND_AND);  
			break;
 
    case 707 : if (DEBUG) { System.out.println("ConditionalAndExpression_NotName ::= Name AND_AND..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.AND_AND);  
			break;
 
    case 709 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeBinaryExpression(OperatorIds.OR_OR);  
			break;
 
    case 710 : if (DEBUG) { System.out.println("ConditionalOrExpression_NotName ::= Name OR_OR..."); }  //$NON-NLS-1$
		    consumeBinaryExpressionWithName(OperatorIds.OR_OR);  
			break;
 
    case 712 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::=..."); }  //$NON-NLS-1$
		    consumeConditionalExpression(OperatorIds.QUESTIONCOLON) ;  
			break;
 
    case 713 : if (DEBUG) { System.out.println("ConditionalExpression_NotName ::= Name QUESTION..."); }  //$NON-NLS-1$
		    consumeConditionalExpressionWithName(OperatorIds.QUESTIONCOLON) ;  
			break;
 
    case 717 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeDeclarationHeaderName() ;  
			break;
 
    case 718 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= Modifiers AT..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;  
			break;
 
    case 719 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeDeclarationHeaderNameWithTypeParameters() ;  
			break;
 
    case 720 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeaderName ::= AT..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeDeclarationHeaderName() ;  
			break;
 
    case 721 : if (DEBUG) { System.out.println("AnnotationTypeDeclarationHeader ::=..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeDeclarationHeader() ;  
			break;
 
    case 722 : if (DEBUG) { System.out.println("AnnotationTypeDeclaration ::=..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeDeclaration() ;  
			break;
 
    case 724 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyAnnotationTypeMemberDeclarationsopt() ;  
			break;
 
    case 725 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarationsopt ::= NestedType..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeMemberDeclarationsopt() ;  
			break;
 
    case 727 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclarations ::=..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeMemberDeclarations() ;  
			break;
 
    case 728 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); }  //$NON-NLS-1$
		    consumeMethodHeaderNameWithTypeParameters(true);  
			break;
 
    case 729 : if (DEBUG) { System.out.println("AnnotationMethodHeaderName ::= Modifiersopt..."); }  //$NON-NLS-1$
		    consumeMethodHeaderName(true);  
			break;
 
    case 730 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::="); }  //$NON-NLS-1$
		    consumeEmptyMethodHeaderDefaultValue() ;  
			break;
 
    case 731 : if (DEBUG) { System.out.println("AnnotationMethodHeaderDefaultValueopt ::= DefaultValue"); }  //$NON-NLS-1$
		    consumeMethodHeaderDefaultValue();  
			break;
 
    case 732 : if (DEBUG) { System.out.println("AnnotationMethodHeader ::= AnnotationMethodHeaderName..."); }  //$NON-NLS-1$
		    consumeMethodHeader();  
			break;
 
    case 733 : if (DEBUG) { System.out.println("AnnotationTypeMemberDeclaration ::=..."); }  //$NON-NLS-1$
		    consumeAnnotationTypeMemberDeclaration() ;  
			break;
 
    case 741 : if (DEBUG) { System.out.println("AnnotationName ::= AT Name"); }  //$NON-NLS-1$
		    consumeAnnotationName() ;  
			break;
 
    case 742 : if (DEBUG) { System.out.println("NormalAnnotation ::= AnnotationName LPAREN..."); }  //$NON-NLS-1$
		    consumeNormalAnnotation() ;  
			break;
 
    case 743 : if (DEBUG) { System.out.println("MemberValuePairsopt ::="); }  //$NON-NLS-1$
		    consumeEmptyMemberValuePairsopt() ;  
			break;
 
    case 746 : if (DEBUG) { System.out.println("MemberValuePairs ::= MemberValuePairs COMMA..."); }  //$NON-NLS-1$
		    consumeMemberValuePairs() ;  
			break;
 
    case 747 : if (DEBUG) { System.out.println("MemberValuePair ::= SimpleName EQUAL EnterMemberValue..."); }  //$NON-NLS-1$
		    consumeMemberValuePair() ;  
			break;
 
    case 748 : if (DEBUG) { System.out.println("EnterMemberValue ::="); }  //$NON-NLS-1$
		    consumeEnterMemberValue() ;  
			break;
 
    case 749 : if (DEBUG) { System.out.println("ExitMemberValue ::="); }  //$NON-NLS-1$
		    consumeExitMemberValue() ;  
			break;
 
    case 751 : if (DEBUG) { System.out.println("MemberValue ::= Name"); }  //$NON-NLS-1$
		    consumeMemberValueAsName() ;  
			break;
 
    case 754 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); }  //$NON-NLS-1$
		    consumeMemberValueArrayInitializer() ;  
			break;
 
    case 755 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); }  //$NON-NLS-1$
		    consumeMemberValueArrayInitializer() ;  
			break;
 
    case 756 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); }  //$NON-NLS-1$
		    consumeEmptyMemberValueArrayInitializer() ;  
			break;
 
    case 757 : if (DEBUG) { System.out.println("MemberValueArrayInitializer ::=..."); }  //$NON-NLS-1$
		    consumeEmptyMemberValueArrayInitializer() ;  
			break;
 
    case 758 : if (DEBUG) { System.out.println("EnterMemberValueArrayInitializer ::="); }  //$NON-NLS-1$
		    consumeEnterMemberValueArrayInitializer() ;  
			break;
 
    case 760 : if (DEBUG) { System.out.println("MemberValues ::= MemberValues COMMA MemberValue"); }  //$NON-NLS-1$
		    consumeMemberValues() ;  
			break;
 
    case 761 : if (DEBUG) { System.out.println("MarkerAnnotation ::= AnnotationName"); }  //$NON-NLS-1$
		    consumeMarkerAnnotation() ;  
			break;
 
    case 762 : if (DEBUG) { System.out.println("SingleMemberAnnotationMemberValue ::= MemberValue"); }  //$NON-NLS-1$
		    consumeSingleMemberAnnotationMemberValue() ;  
			break;
 
    case 763 : if (DEBUG) { System.out.println("SingleMemberAnnotation ::= AnnotationName LPAREN..."); }  //$NON-NLS-1$
		    consumeSingleMemberAnnotation() ;  
			break;
 
    case 764 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt TypeParameters"); }  //$NON-NLS-1$
		    consumeRecoveryMethodHeaderNameWithTypeParameters();  
			break;
 
    case 765 : if (DEBUG) { System.out.println("RecoveryMethodHeaderName ::= Modifiersopt..."); }  //$NON-NLS-1$
		    consumeRecoveryMethodHeaderName();  
			break;
 
    case 766 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); }  //$NON-NLS-1$
		    consumeMethodHeader();  
			break;
 
    case 767 : if (DEBUG) { System.out.println("RecoveryMethodHeader ::= RecoveryMethodHeaderName..."); }  //$NON-NLS-1$
		    consumeMethodHeader();  
			break;
 
	}
}
private void consumeDimsWithTrailingAnnotsopt() {
	// DimsoptAnnotsopt -> DimsAnnotLoop
	pushOnIntStack(this.dimensions);
	this.dimensions = 0;
	// handle trailing annotations if any here.
}
private void consumeOneDimLoopWithAnnotations() {
	// OneDimLoop ::= OneOrMoreAnnotations '[' ']'
	this.dimensions++;
}
private void consumeEmptyDimsoptAnnotsopt() {
	// DimsoptAnnotsopt ::= $empty
	pushOnIntStack(0);  // signal a non array
	// handling trailing annotations if any here.
}
protected void consumeSimpleAssertStatement() {
	// AssertStatement ::= 'assert' Expression ';'
	this.expressionLengthPtr--;

Lines 166-173 Link Here

(-)formatter/org/eclipse/jdt/internal/formatter/CodeFormatterVisitor.java (-2 / +2 lines)
166	};	166	};
167	private static final int[] CLOSING_GENERICS_EXPECTEDTOKENS = new int[] {	167	private static final int[] CLOSING_GENERICS_EXPECTEDTOKENS = new int[] {
168	TerminalTokens.TokenNameRIGHT_SHIFT,	168	TerminalTokens.TokenNameRIGHT_SHIFT,
169	TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT,	169	TerminalTokens.TokenNameGREATER,
170	TerminalTokens.TokenNameGREATER	170	TerminalTokens.TokenNameUNSIGNED_RIGHT_SHIFT
171	};	171	};
172	private int chunkKind;	172	private int chunkKind;
173	public int lastLocalDeclarationSourceStart;	173	public int lastLocalDeclarationSourceStart;




				"	A2 a2;\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in test\\X1.java (at line 3)\n" + 
			"	public class X1<A1 extends X2<A2> {\n" + 
			"	                              ^^\n" + 
			"A2 cannot be resolved to a type\n" + 
			"----------\n" + 
			"2. ERROR in test\\X1.java (at line 3)\n" + 
			"	public class X1<A1 extends X2<A2> {\n" + 
			"	                                ^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n" + 
			"3. ERROR in test\\X1.java (at line 7)\n" + 
			"	class X2<A2 {\n" + 
			"	         ^^\n" + 
			"Syntax error, insert \">\" to complete TypeParameter1\n" + 
			"----------\n"		);
		);
	}

	// JSR14-V10[2.4]: Not terminated consecutive declaration

					"class X2<A extends X3<String> {}\n" +
					"class X3<A {}\n"
			},
			"----------\n" + 
			"1. ERROR in test\\X.java (at line 2)\n" + 
			"	public class X<A extends X1<X2<X3<String>>> {}\n" + 
			"	                                        ^^^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n" + 
			"2. ERROR in test\\X.java (at line 3)\n" + 
			"	class X1<A extends X2<X3<String>> {}\n" + 
			"	                               ^^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n" + 
			"3. ERROR in test\\X.java (at line 4)\n" + 
			"	class X2<A extends X3<String> {}\n" + 
			"	                            ^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n" + 
			"4. ERROR in test\\X.java (at line 5)\n" + 
			"	class X3<A {}\n" + 
			"	         ^\n" + 
			"Syntax error, insert \">\" to complete TypeParameter1\n" + 
			"----------\n"
		);
	}

					"class X2<A extends X3<String>> {}\n" +
					"class X3<A> {}\n"
			},
			"----------\n" + 
			"1. ERROR in test\\X.java (at line 2)\n" + 
			"	public class X<A extends X1<X2<X3<String {}\n" + 
			"	                                  ^^^^^^\n" + 
			"Syntax error, insert \">>>\" to complete ReferenceType3\n" + 
			"----------\n" + 
			"2. ERROR in test\\X.java (at line 2)\n" + 
			"	public class X<A extends X1<X2<X3<String {}\n" + 
			"	                                  ^^^^^^\n" + 
			"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
			"----------\n");
	}
	public void test0084() {

Lines 779-827 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestMixed.java (-43 / +21 lines)
779	+ " return \"\";\n"	779	+ " return \"\";\n"
780	+ " }\n"	780	+ " }\n"
781	+ "}\n" },	781	+ "}\n" },
782	this.complianceLevel < ClassFileConstants.JDK1_5	782	"----------\n" +
783	? "----------\n"	783	"1. ERROR in test\\X.java (at line 23)\n" +
784	+ "1. ERROR in test\\X.java (at line 23)\n"	784	" }\n" +
785	+ " }\n"	785	" ^\n" +
786	+ " ^\n"	786	"Syntax error, insert \"}\" to complete ClassBody\n" +
787	+ "Syntax error, insert \"}\" to complete ClassBody\n"	787	"----------\n" +
788	+ "----------\n"	788	"2. ERROR in test\\X.java (at line 26)\n" +
789	+ "2. ERROR in test\\X.java (at line 26)\n"	789	" * @param list Valid param tag\n" +
790	+ " * @param list Valid param tag\n"	790	" ^^^^\n" +
791	+ " ^^^^\n"	791	"Javadoc: Parameter list is not declared\n" +
792	+ "Javadoc: Parameter list is not declared\n"	792	"----------\n" +
793	+ "----------\n"	793	"3. ERROR in test\\X.java (at line 33)\n" +
794	+ "3. ERROR in test\\X.java (at line 33)\n"	794	" public String foo(java.util.Vector ) {\n" +
795	+ " public String foo(java.util.Vector ) {\n"	795	" ^^^^^^\n" +
796	+ " ^^^^^^\n"	796	"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameterList\n" +
797	+ "Syntax error on token \"Vector\", VariableDeclaratorId expected after this token\n"	797	"----------\n" +
798	+ "----------\n"	798	"4. ERROR in test\\X.java (at line 36)\n" +
799	+ "4. ERROR in test\\X.java (at line 36)\n"	799	" }\n" +
800	+ " }\n"	800	" ^\n" +
801	+ " ^\n"	801	"Syntax error on token \"}\", delete this token\n" +
802	+ "Syntax error on token \"}\", delete this token\n"	802	"----------\n");
803	+ "----------\n"
804	: "----------\n"
805	+ "1. ERROR in test\\X.java (at line 23)\n"
806	+ " }\n"
807	+ " ^\n"
808	+ "Syntax error, insert \"}\" to complete ClassBody\n"
809	+ "----------\n"
810	+ "2. ERROR in test\\X.java (at line 26)\n"
811	+ " * @param list Valid param tag\n"
812	+ " ^^^^\n"
813	+ "Javadoc: Parameter list is not declared\n"
814	+ "----------\n"
815	+ "3. ERROR in test\\X.java (at line 33)\n"
816	+ " public String foo(java.util.Vector ) {\n"
817	+ " ^\n"
818	+ "Syntax error on token \".\", ... expected\n"
819	+ "----------\n"
820	+ "4. ERROR in test\\X.java (at line 36)\n"
821	+ " }\n"
822	+ " ^\n"
823	+ "Syntax error on token \"}\", delete this token\n"
824	+ "----------\n");
825	}	803	}
826		804
827	public void test040() {	805	public void test040() {




		expected13ProblemLog;

	String expected15ProblemLog =
		"----------\n" + 
		"1. WARNING in X.java (at line 1)\n" + 
		"	public class X <T1 extends String, T2 extends Y {\n" + 
		"	                           ^^^^^^\n" + 
		"The type parameter T1 should not be bounded by the final type String. Final types cannot be further extended\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 1)\n" + 
		"	public class X <T1 extends String, T2 extends Y {\n" + 
		"	                                              ^\n" + 
		"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 1)\n" + 
		"	public class X <T1 extends String, T2 extends Y {\n" + 
		"	                                              ^\n" + 
		"Y cannot be resolved to a type\n" + 
		"----------\n";

	runComplianceParserTest(




		"1. ERROR in <parenthesis mismatch> (at line 3)\n" +
		"	[ arg1, 						\n" +
		"	^\n" +
		"Syntax error on token \"[\", boolean expected\n" +
		"----------\n" +
		"2. ERROR in <parenthesis mismatch> (at line 4)\n" +
		"	{ arg2, ]						\n" +
		"	^\n" +
		"Syntax error on token \"{\", boolean expected\n" +
		"----------\n" +
		"3. ERROR in <parenthesis mismatch> (at line 4)\n" +
		"	{ arg2, ]						\n" +
		"	        ^\n" +
		"Syntax error on token \"]\", boolean expected\n" +
		"----------\n" +
		"4. ERROR in <parenthesis mismatch> (at line 5)\n" +
		"	arg3, 						\n" +

		"1. ERROR in <test> (at line 3)\n"+
		"	i; 									\n"+
		"	^\n"+
		"Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration\n" +
		"----------\n";

	String testName = "<test>";

Lines 71-86 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/ParserTest.java (-25 / +35 lines)
71	" }\n" +	71	" }\n" +
72	"}\n"	72	"}\n"
73	},	73	},
74	"----------\n" +	74	"----------\n" +
75	"1. ERROR in X.java (at line 3)\n" +	75	"1. ERROR in X.java (at line 3)\n" +
76	" throws new X\n" +	76	" throws new X\n" +
77	" ^^^^^^\n" +	77	" ^^^^^^\n" +
78	"Syntax error on token \"throws\", throw expected\n" +	78	"Syntax error on token \"throws\", throw expected\n" +
79	"----------\n" +	79	"----------\n" +
80	"2. ERROR in X.java (at line 3)\n" +	80	"2. ERROR in X.java (at line 3)\n" +
81	" throws new X\n" +	81	" throws new X\n" +
82	" ^\n" +	82	" ^\n" +
83	"Syntax error, unexpected end of method\n" +	83	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
		84	"----------\n" +
		85	"3. ERROR in X.java (at line 3)\n" +
		86	" throws new X\n" +
		87	" ^\n" +
		88	"Syntax error, insert \";\" to complete BlockStatements\n" +
84	"----------\n"	89	"----------\n"
85	);	90	);
86	}	91	}
Lines 130-145 Link Here
130	" }\n" +	135	" }\n" +
131	"}\n"	136	"}\n"
132	},	137	},
133	"----------\n" +	138	"----------\n" +
134	"1. ERROR in X.java (at line 3)\n" +	139	"1. ERROR in X.java (at line 3)\n" +
135	" throws new X\n" +	140	" throws new X\n" +
136	" ^^^^^^\n" +	141	" ^^^^^^\n" +
137	"Syntax error on token \"throws\", throw expected\n" +	142	"Syntax error on token \"throws\", throw expected\n" +
138	"----------\n" +	143	"----------\n" +
139	"2. ERROR in X.java (at line 3)\n" +	144	"2. ERROR in X.java (at line 3)\n" +
140	" throws new X\n" +	145	" throws new X\n" +
141	" ^\n" +	146	" ^\n" +
142	"Syntax error, unexpected end of initializer\n" +	147	"Syntax error, insert \"Dimensions\" to complete Expression\n" +
		148	"----------\n" +
		149	"3. ERROR in X.java (at line 3)\n" +
		150	" throws new X\n" +
		151	" ^\n" +
		152	"Syntax error, insert \";\" to complete BlockStatements\n" +
143	"----------\n"	153	"----------\n"
144	);	154	);
145	}	155	}
Lines 238-248 Link Here
238	" public void bar(){}\n" +	248	" public void bar(){}\n" +
239	"}\n"	249	"}\n"
240	},	250	},
241	"----------\n" +	251	"----------\n" +
242	"1. ERROR in X.java (at line 2)\n" +	252	"1. ERROR in X.java (at line 2)\n" +
243	" public void foo(X, Object o, String s) {\n" +	253	" public void foo(X, Object o, String s) {\n" +
244	" ^\n" +	254	" ^\n" +
245	"Syntax error on token \",\", . expected\n" +	255	"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameterList\n" +
246	"----------\n"	256	"----------\n"
247	);	257	);
248	}	258	}

Return to bug 287648

Lines 7622-7628 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverterTestAST3_2.java (-73 / +80 lines)
7622	true);	7622	true);
7623	assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());	7623	assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
7624	CompilationUnit unit = (CompilationUnit) node;	7624	CompilationUnit unit = (CompilationUnit) node;
7625	assertProblemsSize(unit, 1, "Syntax error, insert \"AssignmentOperator Expression\" to complete Expression");	7625	assertProblemsSize(unit, 1, "Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration");
7626	node = getASTNode(unit, 0, 0, 0);	7626	node = getASTNode(unit, 0, 0, 0);
7627	assertEquals("Not an expression statement", ASTNode.EXPRESSION_STATEMENT, node.getNodeType());	7627	assertEquals("Not an expression statement", ASTNode.EXPRESSION_STATEMENT, node.getNodeType());
7628	assertTrue("Not recovered", isRecovered(node));	7628	assertTrue("Not recovered", isRecovered(node));
Lines 7731-7739 Link Here
7731	CompilationUnit unit = (CompilationUnit) node;	7731	CompilationUnit unit = (CompilationUnit) node;
7732	assertProblemsSize(	7732	assertProblemsSize(
7733	unit,	7733	unit,
7734	2,	7734	1,
7735	"Object.equ cannot be resolved to a variable\n" +	7735	"Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration");
7736	"Syntax error, insert \"AssignmentOperator Expression\" to complete Expression");
7737	node = getASTNode(unit, 0, 0);	7736	node = getASTNode(unit, 0, 0);
7738	assertEquals("Not a field declaration statement", ASTNode.INITIALIZER, node.getNodeType());	7737	assertEquals("Not a field declaration statement", ASTNode.INITIALIZER, node.getNodeType());
7739	Initializer initializer = (Initializer) node;	7738	Initializer initializer = (Initializer) node;
Lines 7999-8073 Link Here
7999	"}");	7998	"}");
8000		7999
8001	assertASTResult(	8000	assertASTResult(
8002	"===== AST =====\n" +	8001	"===== AST =====\n" +
8003	"import java.nio.ByteBuffer;\n" +	8002	"import java.nio.ByteBuffer;\n" +
8004	"import java.nio.CharBuffer;\n" +	8003	"import java.nio.CharBuffer;\n" +
8005	"import java.nio.charset.Charset;\n" +	8004	"import java.nio.charset.Charset;\n" +
8006	"import java.nio.charset.CharsetDecoder;\n" +	8005	"import java.nio.charset.CharsetDecoder;\n" +
8007	"import java.nio.charset.CharsetEncoder;\n" +	8006	"import java.nio.charset.CharsetEncoder;\n" +
8008	"import java.nio.charset.CoderResult;\n" +	8007	"import java.nio.charset.CoderResult;\n" +
8009	"public class TestCharset extends Charset {\n" +	8008	"public class TestCharset extends Charset {\n" +
8010	" public CharsetDecoder newDecoder(){\n" +	8009	" public CharsetDecoder newDecoder(){\n" +
8011	" return new CharsetDecoder(this,2.0,2.0){\n" +	8010	" return new CharsetDecoder(this,2.0,2.0){\n" +
8012	" void CharsetDecoder(){\n" +	8011	" void CharsetDecoder(){\n" +
8013	" }\n" +	8012	" }\n" +
8014	" protected CoderResult decodeLoop( ByteBuffer in, CharBuffer out){\n" +	8013	" protected CoderResult decodeLoop( ByteBuffer in, CharBuffer out){\n" +
8015	" return null;\n" +	8014	" return null;\n" +
8016	" }\n" +	8015	" }\n" +
8017	" }\n" +	8016	" }\n" +
8018	";\n" +	8017	";\n" +
8019	" ;\n" +	8018	" ;\n" +
8020	" }\n" +	8019	" }\n" +
8021	" public CharsetEncoder newEncoder(){\n" +	8020	" public CharsetEncoder newEncoder(){\n" +
8022	" return null;\n" +	8021	" return null;\n" +
8023	" }\n" +	8022	" }\n" +
8024	"}\n" +	8023	"}\n" +
8025	"\n" +	8024	"\n" +
8026	"===== Details =====\n" +	8025	"===== Details =====\n" +
8027	"===== Problems =====\n" +	8026	"===== Problems =====\n" +
8028	"1. ERROR in /Converter/src/TestCharset.java (at line 1)\n" +	8027	"1. ERROR in /Converter/src/TestCharset.java (at line 1)\n" +
8029	" import java.nio.ByteBuffer;\n" +	8028	" import java.nio.ByteBuffer;\n" +
8030	" ^^^^^^^^\n" +	8029	" ^^^^^^^^\n" +
8031	"The import java.nio cannot be resolved\n" +	8030	"The import java.nio cannot be resolved\n" +
8032	"2. ERROR in /Converter/src/TestCharset.java (at line 2)\n" +	8031	"2. ERROR in /Converter/src/TestCharset.java (at line 2)\n" +
8033	" import java.nio.CharBuffer;\n" +	8032	" import java.nio.CharBuffer;\n" +
8034	" ^^^^^^^^\n" +	8033	" ^^^^^^^^\n" +
8035	"The import java.nio cannot be resolved\n" +	8034	"The import java.nio cannot be resolved\n" +
8036	"3. ERROR in /Converter/src/TestCharset.java (at line 3)\n" +	8035	"3. ERROR in /Converter/src/TestCharset.java (at line 3)\n" +
8037	" import java.nio.charset.Charset;\n" +	8036	" import java.nio.charset.Charset;\n" +
8038	" ^^^^^^^^\n" +	8037	" ^^^^^^^^\n" +
8039	"The import java.nio cannot be resolved\n" +	8038	"The import java.nio cannot be resolved\n" +
8040	"4. ERROR in /Converter/src/TestCharset.java (at line 4)\n" +	8039	"4. ERROR in /Converter/src/TestCharset.java (at line 4)\n" +
8041	" import java.nio.charset.CharsetDecoder;\n" +	8040	" import java.nio.charset.CharsetDecoder;\n" +
8042	" ^^^^^^^^\n" +	8041	" ^^^^^^^^\n" +
8043	"The import java.nio cannot be resolved\n" +	8042	"The import java.nio cannot be resolved\n" +
8044	"5. ERROR in /Converter/src/TestCharset.java (at line 5)\n" +	8043	"5. ERROR in /Converter/src/TestCharset.java (at line 5)\n" +
8045	" import java.nio.charset.CharsetEncoder;\n" +	8044	" import java.nio.charset.CharsetEncoder;\n" +
8046	" ^^^^^^^^\n" +	8045	" ^^^^^^^^\n" +
8047	"The import java.nio cannot be resolved\n" +	8046	"The import java.nio cannot be resolved\n" +
8048	"6. ERROR in /Converter/src/TestCharset.java (at line 6)\n" +	8047	"6. ERROR in /Converter/src/TestCharset.java (at line 6)\n" +
8049	" import java.nio.charset.CoderResult;\n" +	8048	" import java.nio.charset.CoderResult;\n" +
8050	" ^^^^^^^^\n" +	8049	" ^^^^^^^^\n" +
8051	"The import java.nio cannot be resolved\n" +	8050	"The import java.nio cannot be resolved\n" +
8052	"7. ERROR in /Converter/src/TestCharset.java (at line 7)\n" +	8051	"7. ERROR in /Converter/src/TestCharset.java (at line 7)\n" +
8053	" public class TestCharset extends Charset {\n" +	8052	" public class TestCharset extends Charset {\n" +
8054	" ^^^^^^^\n" +	8053	" ^^^^^^^\n" +
8055	"Charset cannot be resolved to a type\n" +	8054	"Charset cannot be resolved to a type\n" +
8056	"8. ERROR in /Converter/src/TestCharset.java (at line 8)\n" +	8055	"8. ERROR in /Converter/src/TestCharset.java (at line 8)\n" +
8057	" public CharsetDecoder newDecoder() {\n" +	8056	" public CharsetDecoder newDecoder() {\n" +
8058	" ^^^^^^^^^^^^^^\n" +	8057	" ^^^^^^^^^^^^^^\n" +
8059	"CharsetDecoder cannot be resolved to a type\n" +	8058	"CharsetDecoder cannot be resolved to a type\n" +
8060	"9. ERROR in /Converter/src/TestCharset.java (at line 9)\n" +	8059	"9. ERROR in /Converter/src/TestCharset.java (at line 9)\n" +
8061	" return new CharsetDecoder(this, 2.0, 2.0) {\n" +	8060	" return new CharsetDecoder(this, 2.0, 2.0) {\n" +
8062	" ^^^^^^^^^^^^^^\n" +	8061	" ^^^^^^^^^^^^^^\n" +
8063	"CharsetDecoder cannot be resolved to a type\n" +	8062	"CharsetDecoder cannot be resolved to a type\n" +
8064	"10. ERROR in /Converter/src/TestCharset.java (at line 10)\n" +	8063	"10. ERROR in /Converter/src/TestCharset.java (at line 10)\n" +
8065	" CharsetDecoder(CharSet\n" +	8064	" CharsetDecoder(CharSet\n" +
8066	" ^^^^^^^^^^^^^^^^^^^^^^\n" +	8065	" ^^^^^^^\n" +
8067	"Syntax error on token(s), misplaced construct(s)\n" +	8066	"Syntax error, insert \"VariableDeclaratorId\" to complete FormalParameter\n" +
8068	"11. ERROR in /Converter/src/TestCharset.java (at line 17)\n" +	8067	"11. ERROR in /Converter/src/TestCharset.java (at line 10)\n" +
8069	" public CharsetEncoder newEncoder() {\n" +	8068	" CharsetDecoder(CharSet\n" +
8070	" ^^^^^^^^^^^^^^\n" +	8069	" ^^^^^^^\n" +
		8070	"Syntax error, insert \")\" to complete ConstructorDeclaration\n" +
		8071	"12. ERROR in /Converter/src/TestCharset.java (at line 10)\n" +
		8072	" CharsetDecoder(CharSet\n" +
		8073	" ^^^^^^^\n" +
		8074	"Syntax error, insert \";\" to complete ClassBodyDeclarations\n" +
		8075	"13. ERROR in /Converter/src/TestCharset.java (at line 17)\n" +
		8076	" public CharsetEncoder newEncoder() {\n" +
		8077	" ^^^^^^^^^^^^^^\n" +
8071	"CharsetEncoder cannot be resolved to a type\n",	8078	"CharsetEncoder cannot be resolved to a type\n",
8072	result);	8079	result);
8073	}	8080	}

Lines 1870-1892 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java (-47 / +46 lines)
1870	" A2 a2;\n" +	1870	" A2 a2;\n" +
1871	"}\n"	1871	"}\n"
1872	},	1872	},
1873	"----------\n" +	1873	"----------\n" +
1874	"1. ERROR in test\\X1.java (at line 3)\n" +	1874	"1. ERROR in test\\X1.java (at line 3)\n" +
1875	" public class X1<A1 extends X2<A2> {\n" +	1875	" public class X1<A1 extends X2<A2> {\n" +
1876	" ^^\n" +	1876	" ^^\n" +
1877	"A2 cannot be resolved to a type\n" +	1877	"A2 cannot be resolved to a type\n" +
1878	"----------\n" +	1878	"----------\n" +
1879	"2. ERROR in test\\X1.java (at line 3)\n" +	1879	"2. ERROR in test\\X1.java (at line 3)\n" +
1880	" public class X1<A1 extends X2<A2> {\n" +	1880	" public class X1<A1 extends X2<A2> {\n" +
1881	" ^\n" +	1881	" ^\n" +
1882	"Syntax error, insert \">\" to complete ReferenceType1\n" +	1882	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
1883	"----------\n" +	1883	"----------\n" +
1884	"3. ERROR in test\\X1.java (at line 7)\n" +	1884	"3. ERROR in test\\X1.java (at line 7)\n" +
1885	" class X2<A2 {\n" +	1885	" class X2<A2 {\n" +
1886	" ^^\n" +	1886	" ^^\n" +
1887	"Syntax error on token \"A2\", > expected after this token\n" +	1887	"Syntax error, insert \">\" to complete TypeParameter1\n" +
1888	"----------\n"	1888	"----------\n" );
1889	);
1890	}	1889	}
1891		1890
1892	// JSR14-V10[2.4]: Not terminated consecutive declaration	1891	// JSR14-V10[2.4]: Not terminated consecutive declaration
Lines 2311-2336 Link Here
2311	"class X2<A extends X3<String> {}\n" +	2310	"class X2<A extends X3<String> {}\n" +
2312	"class X3<A {}\n"	2311	"class X3<A {}\n"
2313	},	2312	},
2314	"----------\n" +	2313	"----------\n" +
2315	"1. ERROR in test\\X.java (at line 2)\n" +	2314	"1. ERROR in test\\X.java (at line 2)\n" +
2316	" public class X<A extends X1<X2<X3<String>>> {}\n" +	2315	" public class X<A extends X1<X2<X3<String>>> {}\n" +
2317	" ^^^\n" +	2316	" ^^^\n" +
2318	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2317	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2319	"----------\n" +	2318	"----------\n" +
2320	"2. ERROR in test\\X.java (at line 3)\n" +	2319	"2. ERROR in test\\X.java (at line 3)\n" +
2321	" class X1<A extends X2<X3<String>> {}\n" +	2320	" class X1<A extends X2<X3<String>> {}\n" +
2322	" ^^\n" +	2321	" ^^\n" +
2323	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2322	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2324	"----------\n" +	2323	"----------\n" +
2325	"3. ERROR in test\\X.java (at line 4)\n" +	2324	"3. ERROR in test\\X.java (at line 4)\n" +
2326	" class X2<A extends X3<String> {}\n" +	2325	" class X2<A extends X3<String> {}\n" +
2327	" ^\n" +	2326	" ^\n" +
2328	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2327	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2329	"----------\n" +	2328	"----------\n" +
2330	"4. ERROR in test\\X.java (at line 5)\n" +	2329	"4. ERROR in test\\X.java (at line 5)\n" +
2331	" class X3<A {}\n" +	2330	" class X3<A {}\n" +
2332	" ^\n" +	2331	" ^\n" +
2333	"Syntax error on token \"A\", > expected after this token\n" +	2332	"Syntax error, insert \">\" to complete TypeParameter1\n" +
2334	"----------\n"	2333	"----------\n"
2335	);	2334	);
2336	}	2335	}
Lines 2398-2413 Link Here
2398	"class X2<A extends X3<String>> {}\n" +	2397	"class X2<A extends X3<String>> {}\n" +
2399	"class X3<A> {}\n"	2398	"class X3<A> {}\n"
2400	},	2399	},
2401	"----------\n" +	2400	"----------\n" +
2402	"1. ERROR in test\\X.java (at line 2)\n" +	2401	"1. ERROR in test\\X.java (at line 2)\n" +
2403	" public class X<A extends X1<X2<X3<String {}\n" +	2402	" public class X<A extends X1<X2<X3<String {}\n" +
2404	" ^^^^^^\n" +	2403	" ^^^^^^\n" +
2405	"Syntax error, insert \">>>\" to complete ReferenceType3\n" +	2404	"Syntax error, insert \">>>\" to complete ReferenceType3\n" +
2406	"----------\n" +	2405	"----------\n" +
2407	"2. ERROR in test\\X.java (at line 2)\n" +	2406	"2. ERROR in test\\X.java (at line 2)\n" +
2408	" public class X<A extends X1<X2<X3<String {}\n" +	2407	" public class X<A extends X1<X2<X3<String {}\n" +
2409	" ^^^^^^\n" +	2408	" ^^^^^^\n" +
2410	"Syntax error, insert \">\" to complete ReferenceType1\n" +	2409	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
2411	"----------\n");	2410	"----------\n");
2412	}	2411	}
2413	public void test0084() {	2412	public void test0084() {

Lines 1456-1476 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/ComplianceDiagnoseTest.java (-15 / +15 lines)
1456	expected13ProblemLog;	1456	expected13ProblemLog;
1457		1457
1458	String expected15ProblemLog =	1458	String expected15ProblemLog =
1459	"----------\n" +	1459	"----------\n" +
1460	"1. WARNING in X.java (at line 1)\n" +	1460	"1. WARNING in X.java (at line 1)\n" +
1461	" public class X <T1 extends String, T2 extends Y {\n" +	1461	" public class X <T1 extends String, T2 extends Y {\n" +
1462	" ^^^^^^\n" +	1462	" ^^^^^^\n" +
1463	"The type parameter T1 should not be bounded by the final type String. Final types cannot be further extended\n" +	1463	"The type parameter T1 should not be bounded by the final type String. Final types cannot be further extended\n" +
1464	"----------\n" +	1464	"----------\n" +
1465	"2. ERROR in X.java (at line 1)\n" +	1465	"2. ERROR in X.java (at line 1)\n" +
1466	" public class X <T1 extends String, T2 extends Y {\n" +	1466	" public class X <T1 extends String, T2 extends Y {\n" +
1467	" ^\n" +	1467	" ^\n" +
1468	"Syntax error, insert \">\" to complete ReferenceType1\n" +	1468	"Syntax error, insert \"AdditionalBoundList1\" to complete TypeParameter1\n" +
1469	"----------\n" +	1469	"----------\n" +
1470	"3. ERROR in X.java (at line 1)\n" +	1470	"3. ERROR in X.java (at line 1)\n" +
1471	" public class X <T1 extends String, T2 extends Y {\n" +	1471	" public class X <T1 extends String, T2 extends Y {\n" +
1472	" ^\n" +	1472	" ^\n" +
1473	"Y cannot be resolved to a type\n" +	1473	"Y cannot be resolved to a type\n" +
1474	"----------\n";	1474	"----------\n";
1475		1475
1476	runComplianceParserTest(	1476	runComplianceParserTest(

Lines 166-182 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/parser/SyntaxErrorTest.java (-4 / +4 lines)
166	"1. ERROR in <parenthesis mismatch> (at line 3)\n" +	166	"1. ERROR in <parenthesis mismatch> (at line 3)\n" +
167	" [ arg1, \n" +	167	" [ arg1, \n" +
168	" ^\n" +	168	" ^\n" +
169	"Syntax error on token \"[\", invalid Type\n" +	169	"Syntax error on token \"[\", boolean expected\n" +
170	"----------\n" +	170	"----------\n" +
171	"2. ERROR in <parenthesis mismatch> (at line 4)\n" +	171	"2. ERROR in <parenthesis mismatch> (at line 4)\n" +
172	" { arg2, ] \n" +	172	" { arg2, ] \n" +
173	" ^\n" +	173	" ^\n" +
174	"Syntax error on token \"{\", invalid Type\n" +	174	"Syntax error on token \"{\", boolean expected\n" +
175	"----------\n" +	175	"----------\n" +
176	"3. ERROR in <parenthesis mismatch> (at line 4)\n" +	176	"3. ERROR in <parenthesis mismatch> (at line 4)\n" +
177	" { arg2, ] \n" +	177	" { arg2, ] \n" +
178	" ^\n" +	178	" ^\n" +
179	"Syntax error on token \"]\", invalid Type\n" +	179	"Syntax error on token \"]\", boolean expected\n" +
180	"----------\n" +	180	"----------\n" +
181	"4. ERROR in <parenthesis mismatch> (at line 5)\n" +	181	"4. ERROR in <parenthesis mismatch> (at line 5)\n" +
182	" arg3, \n" +	182	" arg3, \n" +
Lines 273-279 Link Here
273	"1. ERROR in <test> (at line 3)\n"+	273	"1. ERROR in <test> (at line 3)\n"+
274	" i; \n"+	274	" i; \n"+
275	" ^\n"+	275	" ^\n"+
276	"Syntax error, insert \"AssignmentOperator Expression\" to complete Expression\n"+	276	"Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration\n" +
277	"----------\n";	277	"----------\n";
278		278
279	String testName = "<test>";	279	String testName = "<test>";