options {

//FORCE_LA_CHECK = true;
static = true;
//LOOKAHEAD = 3;
}

/*
* Parser Java Code
*/

PARSER_BEGIN(Java8Stepwise2)

package java8stepwise;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;

public class Java8Stepwise2 {


private static BufferedReader _bufferedReader = null;

public Java8Stepwise2 () {

}

public static void main (String[] args) throws ParseException {

String filePath = args[0];

if ( filePath != null) {

try {

_bufferedReader = new BufferedReader(new
FileReader(filePath));
} catch (FileNotFoundException e) {

}

Java8Stepwise2 myp = new
Java8Stepwise2(_bufferedReader);

myp.start();
}
}

}

PARSER_END(Java8Stepwise2)


// Line Terminators
SKIP :
{
"\n" | // New Line (Line Feed)
"\r" | // Return (Carriage Return)
"\r\n" // New Line Return (Carriage Return Line Feed)
}

// White Spaces
SKIP :
{
" " | // White Space, Blank
"\t" | // Horizontal Tab
"\f" // Form Feed
}

void Empty () :
{ }
{
{ System.out.print(""); }
}

// ================================================
// 3.9 Java Keywords
// ================================================

TOKEN : { < #a : "a" > }
TOKEN : { < b : "b" > }

TOKEN : {

< TestToken : <b> | <a><a> | "c">
}


TOKEN : { < KW_abstract : "abstract" > }
TOKEN : { < KW_assert : "assert" > }
TOKEN : { < KW_boolean : "boolean" > }
TOKEN : { < KW_break : "break" > }
TOKEN : { < KW_byte : "byte" > }
TOKEN : { < KW_case : "case" > }
TOKEN : { < KW_catch : "catch" > }
TOKEN : { < KW_char : "char" > }
TOKEN : { < KW_class : "class" > }
TOKEN : { < KW_const : "const" > }
TOKEN : { < KW_continue : "continue" > }
TOKEN : { < KW_default : "default" > }
TOKEN : { < KW_do : "do" > }
TOKEN : { < KW_double : "double" > }
TOKEN : { < KW_else : "else" > }
TOKEN : { < KW_enum : "enum" > }
TOKEN : { < KW_extends : "extends" > }
TOKEN : { < KW_final : "final" > }
TOKEN : { < KW_finally : "finally" > }
TOKEN : { < KW_float : "float" > }
TOKEN : { < KW_for : "for" > }
TOKEN : { < KW_if : "if" > }
TOKEN : { < KW_implements : "implements" > }
TOKEN : { < KW_import : "import" > }
TOKEN : { < KW_instanceof : "instanceof" > }
TOKEN : { < KW_int : "int" > }
TOKEN : { < KW_interface : "interface" > }
TOKEN : { < KW_long : "long" > }
TOKEN : { < KW_native : "native" > }
TOKEN : { < KW_new : "new" > }
TOKEN : { < KW_package : "package" > }
TOKEN : { < KW_private : "private" > }
TOKEN : { < KW_protected : "protected" > }
TOKEN : { < KW_public : "public" > }
TOKEN : { < KW_return : "return" > }
TOKEN : { < KW_short : "short" > }
TOKEN : { < KW_static : "static" > }
TOKEN : { < KW_strictfp : "strictfp" > }
TOKEN : { < KW_super : "super" > }
TOKEN : { < KW_switch : "switch" > }
TOKEN : { < KW_synchronized : "syncronized" > }
TOKEN : { < KW_this : "this" > }
TOKEN : { < KW_throw : "throw" > }
TOKEN : { < KW_throws : "throws" > }
TOKEN : { < KW_transient : "transient" > }
TOKEN : { < KW_try : "try" > }
TOKEN : { < KW_void : "void" > }
TOKEN : { < KW_volatile : "volatile" > }
TOKEN : { < KW_while : "while" > }



// ================================================
// 3.10 Literals
// ================================================

TOKEN :
{
< Literal :
<IntegerLiteral>
| <FloatingPointLiteral>
| <BooleanLiteral>
| <CharacterLiteral>
| <StringLiteral>
| <NullLiteral>
>
}

// ================================================
// 3.10.7 The Null Literal
// ================================================

TOKEN :
{
< #NullLiteral :
"null"
>
}

// ================================================
// 3.8 Identifiers
// ================================================

TOKEN :
{
< #JavaDigit : ["0" - "9"] >
}

TOKEN :
{
< #JavaLetter : ["a" - "z", "A" - "Z", "_", "$"] >
}

TOKEN :
{
< #JavaLetterOrDigit : <JavaLetter> | <JavaDigit> >
}

TOKEN :
{
< #IdentifierChars : <JavaLetter> | (<JavaLetterOrDigit>)+ > //
custom modification: replaced * by +
}

TOKEN :
{
< Identifier : <IdentifierChars> >
}

// Identifier = IdentifierChars ! 2 do: exclude Keywords, BooleanLiteral
and NullLiteral

/*
! Extra

Token_Backslash = '\'

! Token_Apostrophe = '''

{Apostrophe} = {&27}

<Comma_opt> ::= Token_Comma
|

<Semicolon_opt> ::= Token_Semicolon
|

<Identifier_opt> ::= Identifier
|
*/





// ================================================
// 3.10.1 IntegerLiterals
// ================================================

TOKEN :
{
< #IntegerLiteral :
<DecimalIntegerLiteral>
| <HexIntegerLiteral>
| <OctalIntegerLiteral>
| <BinaryIntegerLiteral>
>
}

TOKEN :
{
< #DecimalIntegerLiteral :
<DecimalNumeral> (<IntegerTypeSuffix>)?
>
}

TOKEN :
{
< #HexIntegerLiteral :
<HexNumeral> (<IntegerTypeSuffix>)?
>
}

TOKEN :
{
< #OctalIntegerLiteral :
<OctalNumeral> (<IntegerTypeSuffix>)?
>
}



TOKEN :
{
< #BinaryIntegerLiteral :
<BinaryNumeral> (<IntegerTypeSuffix>)?
>
}

TOKEN :
{
< #IntegerTypeSuffix :
"l" | "L"
>
}

// Decimal Numerals
// ----------------

TOKEN :
{
< #DecimalNumeral :
"0"
| <NonZeroDigit> (<Digits>)?
| <NonZeroDigit> <Underscores> <Digits>
>
}

TOKEN :
{
< #NonZeroDigit :
["1" - "9"]
>
}

TOKEN :
{
< #Digits :
<Digit>
| <Digit> (<DigitsAndUnderscores>)? <Digit>
>
}

TOKEN :
{
< #Digit :
"0"
| <NonZeroDigit>
>
}

TOKEN :
{
< #DigitsAndUnderscores :
<DigitOrUnderscore> (<DigitOrUnderscore>)*
>
}

TOKEN :
{
< #DigitOrUnderscore :
<Digit>
| "_"
>
}

TOKEN :
{
< #Underscores :
"_" ("_")*
>
}

// Hexadecimal Numerals
// --------------------

TOKEN :
{
< #HexNumeral :
"0" "x" <HexDigits>
| "0" "X" <HexDigits>
>
}

TOKEN :
{
< #HexDigits :
<HexDigit>
| <HexDigit> (<HexDigitsAndUnderscores>)? <HexDigit>
>
}

TOKEN :
{
< #HexDigit :
<JavaDigit>
| ["0" - "9"]
| ["A" - "F"]
| ["a" - "f"]
>
}

TOKEN :
{
< #HexDigitsAndUnderscores :
<HexDigitOrUnderscore> (<HexDigitOrUnderscore>)*
>
}

TOKEN :
{
< #HexDigitOrUnderscore :
<HexDigit>
| "_"
>
}

// Octal Numerals
// --------------

TOKEN :
{
< #OctalNumeral :
"0" <OctalDigits>
| "0" <Underscores> <OctalDigits>
>
}

TOKEN :
{
< #OctalDigits :
<OctalDigit>
| <OctalDigit> (<OctalDigitsAndUnderscore>)? <OctalDigit>
>
}

TOKEN :
{
< #OctalDigit :
["0" - "7"]
>
}

TOKEN :
{
< #OctalDigitsAndUnderscore :
<OctalDigitOrUnderscore> (<OctalDigitOrUnderscore>)*
>
}

TOKEN :
{
< #OctalDigitOrUnderscore :
<OctalDigit> | "_"
>
}


// Binary Numerals
// ---------------

TOKEN :
{
< #BinaryNumeral :
"0" "b" <BinaryDigits>
| "0" "B" <BinaryDigits>
>
}


TOKEN :
{
< #BinaryDigits :
<BinaryDigit>
| <BinaryDigit> (<BinaryDigitAndUnderscore>)? <BinaryDigit>
>
}

TOKEN :
{
< #BinaryDigit :
"0"
| "1"
>
}

TOKEN :
{
< #BinaryDigitAndUnderscore :
<BinaryDigitOrUnderscore> (<BinaryDigitOrUnderscore>)*
>
}

TOKEN :
{
< #BinaryDigitOrUnderscore :
<BinaryDigit>
| "_"
>
}

// ================================================
// 3.10.2 Floating-Point Literals
// ================================================

TOKEN :
{
< #FloatingPointLiteral :
<DecimalFloatingPointLiteral>
| <HexadecimalFloatingPointLiteral>
>
}

TOKEN :
{
< #DecimalFloatingPointLiteral :
<Digits> <Token_Dot> (<Digits>)? (<ExponentPart>)?
(<FloatTypeSuffix>)?
| <Token_Dot> <Digits> (<ExponentPart>)? (<FloatTypeSuffix>)?
| <Digits> <ExponentPart> (<FloatTypeSuffix>)?
| <Digits> (<ExponentPart>)? <FloatTypeSuffix>
>
}

TOKEN :
{
< #ExponentPart :
<ExponentIndicator> <SignedInteger>
>
}

TOKEN :
{
< #ExponentIndicator :
"e"
| "E"
>
}

TOKEN :
{
< #SignedInteger :
(<Sign>)? <Digits>
>
}

TOKEN :
{
< #Sign :
<Token_Plus>
| <Token_Minus>
>
}

TOKEN :
{
< #FloatTypeSuffix :
"f"
| "F"
| "d"
| "D"
>
}

TOKEN :
{
< #HexadecimalFloatingPointLiteral :
<HexSignificand> <BinaryExponent> (<FloatTypeSuffix>)?
>
}

TOKEN :
{
< #HexSignificand :
<HexNumeral> (<Token_Dot>)?
| "0" "x" (<HexDigits>)? <Token_Dot> <HexDigits>
| "0" "X" (<HexDigits>)? <Token_Dot> <HexDigits> >
}

TOKEN :
{
< #BinaryExponent :
<BinaryExponentIndicator> <SignedInteger>
>
}

TOKEN :
{
< #BinaryExponentIndicator :
"p"
| "P"
>
}

// ================================================
// 3.10.3 Boolean Literals
// ================================================

TOKEN :
{
< BooleanLiteral :
"true"
| "false"
>
}

// ================================================
// 3.10.4 Character Literals
// ================================================

TOKEN :
{
< #CharacterLiteral :
"'" <InputCharacter> "'"
| "'" <EscapeSequence> "'" >
}

TOKEN :
{
< #InputCharacter :
["a" - "z"]
| ["A" - "Z"]
| " "
>
}

// ================================================
// 3.10.5 String Literals
// ================================================

TOKEN :
{
< StringLiteral :
"\"" (<StringCharacter>)* "\""
>
}

TOKEN :
{
< #StringCharacter :
<InputCharacter>
| <EscapeSequence>
>
}

// ================================================
// 3.10.6 Escape Sequences for Character and String Literals
// ================================================

TOKEN :
{
< EscapeSequence :
<Token_Backslash> "b"
| <Token_Backslash> "t"
| <Token_Backslash> "n"
| <Token_Backslash> "f"
| <Token_Backslash> "r"
| <Token_Backslash> "\""
| <Token_Backslash> <Token_Apostrophe>
| <Token_Backslash> <Token_Backslash>
| <OctalEscape>
>
}

TOKEN :
{
< #OctalEscape :
"\\" <OctalDigit>
| "\\" <OctalDigit> <OctalDigit>
| "\\" <ZeroToThree> <OctalDigit> <OctalDigit>
>
}

TOKEN :
{
< #ZeroToThree :
["0" - "3"]
>
}



// ================================================
// 3.11 Separators
// ================================================

//TOKEN : { < Token_TripleDot : "..." > } // needs a
custom workaround
TOKEN : { < Token_Colon : ":" > }
TOKEN : { < Token_ParenthesesOpen : "(" > }
TOKEN : { < Token_ParenthesesClose : ")" > }
TOKEN : { < Token_BracesOpen : "{" > }
TOKEN : { < Token_BracesClose : "}" > }
TOKEN : { < Token_BracketsOpen : "[" > }
TOKEN : { < Token_BracketsClose : "]" > }
TOKEN : { < Token_Semiclon : ";" > }
TOKEN : { < Token_Comma : "," > }
TOKEN : { < Token_Dot : "." > }
TOKEN : { < Token_At : "@" > }
//TOKEN : { < Token_DoubleColon : "::" > } // needs a custom
workaround
TOKEN : { < Token_Backslash : "\\" > }
TOKEN : { < Token_Apostrophe : "'" > }

TOKEN : {
< Separator :
<Token_ParenthesesOpen>
| <Token_ParenthesesClose>
| <Token_BracesOpen>
| <Token_BracesClose>
| <Token_BracketsOpen>
| <Token_BracketsClose>
| <Token_Semiclon>
| <Token_Comma>
| <Token_Dot><Token_Dot><Token_Dot>
| <Token_Dot>
| <Token_At>
| <Token_Colon><Token_Colon> // custom
workaround
| <Token_Dot><Token_Dot><Token_Dot> // custom
workaround
>
}

// ================================================
// 3.12 Operators
// ================================================

TOKEN : { < Token_Slash : "//" > } // Extra
definition for custom workaround
TOKEN : { < Token_ExclamationMark : "!" > }
TOKEN : { < Token_Equal : "=" > }
TOKEN : { < Token_GreaterThan : ">" > }
TOKEN : { < Token_LowerThan : "<" > }
TOKEN : { < Token_Tilde : "~" > }
TOKEN : { < Token_QuestionMark : "?" > }
//TOKEN : { < Token_RightArrow : "->" > } // custom
workaround
//TOKEN : { < Token_DoubleEqual : "==" > } // custom
workaround
//TOKEN : { < Token_GreaterOrEqualThan : ">=" > } // custom workaround
//TOKEN : { < Token_LowerOrEqualThan : "<=" > } // custom
workaround
//TOKEN : { < Token_Unequal : "!=" > } // custom
workaround
//TOKEN : { < Token_DoubleAnd : "&&" > } // custom
workaround
//TOKEN : { < Token_DoublePipe : "||" > } // custom
workaround
//TOKEN : { < Token_DoublePlus : "++" > } // custom
workaround
//TOKEN : { < Token_DoubleMinus : "--" > } // custom
workaround
TOKEN : { < Token_Plus : "+" > }
TOKEN : { < Token_Minus : "-" > }
TOKEN : { < Token_Asterisk : "*" > }
//TOKEN : { < Token_DoubleSlash : "//" > } // custom
workaround
TOKEN : { < Token_And : "&" > }
TOKEN : { < Token_Pipe : "|" > }
TOKEN : { < Token_CircumFlexAccent : "^" > }
TOKEN : { < Token_Percent : "%" > }
//TOKEN : { < Token_DoubleLowerThan : "<<" > } // custom
workaround
//TOKEN : { < Token_DoubleGreaterThan : ">>" > } // custom workaround
//TOKEN : { < Token_TrippleGreaterThan : ">>>" > } // custom workaround
//TOKEN : { < Token_PlusEqual : "+=" > } // custom
workaround
//TOKEN : { < Token_MinusEqual : "-=" > } // custom
workaround
//TOKEN : { < Token_AsteriskEqual : "*=" > } // custom workaround
//TOKEN : { < Token_SlashEqual : "/=" > } // custom
workaround
//TOKEN : { < Token_AndEqual : "&=" > } // custom
workaround
//TOKEN : { < Token_PipeEqual : "|=" > } // custom
workaround
//TOKEN : { < Token_CircumFlexAccentEqual : "^=" > } // custom
workaround
//TOKEN : { < Token_PercentEqual : "%=" > } // custom
workaround
//TOKEN : { < Token_DoubleLowerThanEqual : "<<=" > } // custom
workaround
//TOKEN : { < Token_DoubleGreaterThanEqual : ">>=" > } // custom
workaround
//TOKEN : { < Token_TrippleGreaterThanEqual : ">>>=" > } // custom
workaround

TOKEN : {
< Operator : <Token_ExclamationMark>
| <Token_Equal>
| <Token_GreaterThan>
| <Token_LowerThan>
| <Token_Tilde>
| <Token_QuestionMark>
// | <Token_RightArrow>
| <Token_Minus><Token_GreaterThan> //
Token_RightArrow
// | <Token_DoubleEqual>
| <Token_Equal><Token_Equal> //
Token_DoubleEqual
// | <Token_GreaterOrEqualThan>
| <Token_GreaterThan><Token_Equal> //
Token_GreaterOrEqual
// | <Token_LowerOrEqualThan>
| <Token_LowerThan><Token_Equal> //
Token_LowerOrEqual
// | <Token_Unequal>
| <Token_ExclamationMark><Token_Equal> // Token_Unequal
// | <Token_DoubleAnd>
| <Token_And><Token_And> //
Token_DoubleAnd
// | <Token_DoublePipe>
| <Token_Pipe><Token_Pipe> //
Token_DoublePipe
// | <Token_DoublePlus>
| <Token_Plus><Token_Plus> //
Token_DoublePlus
// | <Token_DoubleMinus>
| <Token_Minus><Token_Minus> //
Token_DoubleMinus
| <Token_Plus>
| <Token_Minus>
| <Token_Asterisk>
// | <Token_DoubleSlash>
| <Token_Slash><Token_Slash> // Token_Slash
| <Token_And>
| <Token_Pipe>
| <Token_CircumFlexAccent>
| <Token_Percent>
// | <Token_DoubleLowerThan>
| <Token_LowerThan><Token_LowerThan> //
Token_DoubleLowerThan
// | <Token_DoubleGreaterThan>
| <Token_GreaterThan><Token_GreaterThan> //
Token_DoubleGreaterThan
// | <Token_TrippleGreaterThan>
| <Token_GreaterThan><Token_GreaterThan><Token_GreaterThan>
// Token_TrippleGreaterThan
// | <Token_PlusEqual>
| <Token_Plus><Token_Equal> //
Token_PlusEqual
// | <Token_MinusEqual>
| <Token_Minus><Token_Equal> //
Token_MinusEqual
// | <Token_AsteriskEqual>
| <Token_Asterisk><Token_Equal> //
Token_AsteriscEqual
// | <Token_SlashEqual>
| <Token_Slash><Token_Equal> //
Token_SlashEqual
// | <Token_AndEqual>
| <Token_And><Token_Equal> //
Token_AndEqual
// | <Token_PipeEqual>
| <Token_Pipe><Token_Equal> //
Token_PipeEqual
// | <Token_CircumFlexAccentEqual>
| <Token_CircumFlexAccent><Token_Equal> //
TokenCircumflexEqual
// | <Token_PercentEqual>
| <Token_Percent><Token_Equal> //
Token_PercentEqaul
// | <Token_DoubleLowerThanEqual>
| <Token_LowerThan><Token_LowerThan><Token_Equal> //
TokenDoubleLowerThanEqual
// | <Token_DoubleGreaterThanEqual>
| <Token_GreaterThan><Token_GreaterThan><Token_Equal> //
TokenDoubleGreaterThanEqual
// | <Token_TrippleGreaterThanEqual>
| <Token_GreaterThan><Token_GreaterThan><Token_GreaterThan>
// TokenTrippleGreaterThan
>
}


// OK
// #1 / PR_1
void Type() :
{ }
{
PrimitiveType() |
ReferenceType()
}

// OK
// #2 / PR_2
void PrimitiveType() :
{ }
{
(Annotation())* NumericType() |
Annotation() <KW_boolean>
}

//// #3 / PR_3
//void NumericType() :
//{ }
//{
// <IntegralType> |
// <FloatingPointType>
//}

// OK
// #3 / PR_3
void NumericType() :
{ }
{
<KW_byte> |
<KW_short> |
<KW_int> |
<KW_long> |
<KW_char> |
<KW_float> |
<KW_double>
}

//TOKEN :
//{
// < IntegralType :
// <KW_byte> |
// <KW_short> |
// <KW_int> |
// <KW_long> |
// <KW_char>
// >
//}
//
//TOKEN :
//{
// < FloatingPointType :
// <KW_float> |
// <KW_double>
// >
//}

// OK
// #4 / PR_4
void ReferenceType() :
{ }
{
ClassOrInterfaceType() |
TypeVariable() |
ArrayType()
}

// OK
// #7 / PR_7
void ClassOrInterfaceType() :
{ }
{
Annotation() <Identifier> (TypeArguments())? |
Annotation() <Identifier> (TypeArguments())? M()
}

// OK
// #8 / PR_ 7.1
void M() :
{ }
{
<Token_Dot> Annotation() <Identifier> (TypeArguments())? M() |
<Token_Dot> Annotation() <Identifier> (TypeArguments())?
}

// OK
// #9 / PR_8
void TypeVariable() :
{ }
{
Annotation() <Identifier>
}

// OK
// #10 / PR_9
void ArrayType() :
{ }
{
PrimitiveType() Dims() |
ClassOrInterfaceType() Dims() |
TypeVariable() Dims()
}

// OK
// #11 / PR_10
void Dims() :
{ }
{
Annotation() <Token_BracketsOpen> <Token_BracketsClose>
((Annotation())* <Token_BracketsOpen> <Token_BracketsClose>)*
}

// OK
// #16 / PR_15
void TypeArguments() :
{ }
{
<Token_LowerThan> TypeArgumentList() <Token_GreaterThan>
}

// OK
// #17 / PR_16
void TypeArgumentList() :
{ }
{
TypeArgument() (<Token_Comma> TypeArgument())*
}

// OK
// #18 / PR_17
void TypeArgument() :
{ }
{
ReferenceType() |
Wildcard()
}

// OK
// #19 / PR_18
void Wildcard() :
{ }
{
(Annotation())* <Token_QuestionMark> (WildcardBounds())?
}

// OK
// #20 / PR_19
void WildcardBounds() :
{ }
{
<KW_extends> ReferenceType() |
<KW_super> ReferenceType()
}

// OK
// #107 / PR_105
void Annotation() :
{ }
{
NormalAnnotation() |
MarkerAnnotation() |
SingleElementAnnotation()
}

// 9.7.1 Normal Annotations

// OK
// #108 / PR_106
void NormalAnnotation() :
{ }
{
<Token_At> TypeName() <Token_ParenthesesOpen>
(ElementValuePairList())? <Token_ParenthesesClose>
}

// OK
// #109 / PR_107
void ElementValuePairList() :
{ }
{
ElementValuePair() (<Token_Comma> ElementValuePair())*
}

// OK
// #110 / PR_108
void ElementValuePair() :
{ }
{
<Identifier> <Token_Equal> ElementValue()
}

// OK
// #111 / PR_109
void ElementValue() :
{ }
{
//ConditionalExpression() |
ElementValueArrayInitializer() |
Annotation()
}

// OK
// #112 / PR_110
void ElementValueArrayInitializer() :
{ }
{
<Token_BracesOpen> (ElementValueList())? (<Token_Comma>)?
<Token_BracesClose>
}

// OK
// #113 / PR_111
void ElementValueList() :
{ }
{
ElementValue() (<Token_Comma> ElementValue())*
}

// 9.7.2 Marker Annotations

// OK
// #114 / PR_112
void MarkerAnnotation() :
{ }
{
<Token_At> TypeName()
}

// OK
// #22 / PR_21
void TypeName() :
{ }
{
<Identifier> |
PackageOrTypeName() <Token_Dot> <Identifier>
}

// OK
// #23 / PR_22
void PackageOrTypeName() :
{ }
{
<Identifier> (<Token_Dot> <Identifier>)*
}

// OK
// #115 / PR_113
void SingleElementAnnotation() :
{ }
{
<Token_At> TypeName() <Token_ParenthesesOpen> ElementValue()
<Token_ParenthesesClose>
}

// #214 / PR_195
void ConditionalExpression() :
{ }
{
ConditionalOrExpression() |
ConditionalOrExpression() <Token_QuestionMark> Expression()
<Token_Colon> ConditionalExpression()
}

// #212 / PR_194
void ConditionalOrExpression() :
{ }
{
ConditionalAndExpression() |
ConditionalAndExpression() A12_()
}

// #213 / PR_194.1
void A12_() :
{ }
{
<Token_Pipe><Token_Pipe> ConditionalAndExpression() A12_() |
<Token_Pipe><Token_Pipe> ConditionalAndExpression()
}

// #210 / PR_193
void ConditionalAndExpression() :
{ }
{
InclusiveOrExpression() |
InclusiveOrExpression() A11_()
}

// #211 / PR_193.1
void A11_() :
{ }
{
<Token_And><Token_And> InclusiveOrExpression() A11_() |
<Token_And><Token_And> InclusiveOrExpression()
}

// #208 / PR_192
void InclusiveOrExpression() :
{ }
{
ExclusiveOrExpression() |
ExclusiveOrExpression() A10_()
}

// #209 / PR_192.1
void A10_() :
{ }
{
<Token_Pipe> ExclusiveOrExpression() A10_() |
<Token_Pipe> ExclusiveOrExpression()
}

// #206 / PR_191
void ExclusiveOrExpression() :
{ }
{
AndExpression() |
AndExpression() A9_()
}

// #207 / PR_191.1
void A9_() :
{ }
{
<Token_CircumFlexAccent> AndExpression() A9_() |
<Token_CircumFlexAccent> AndExpression()
}

// #204 / PR_190
void AndExpression() :
{ }
{
EqualityExpression() |
EqualityExpression() A8_()
}

// #205 / PR_190.1
void A8_() :
{ }
{
<Token_And> EqualityExpression() A8_() |
<Token_And> EqualityExpression()
}

// #202 / PR_189
void EqualityExpression() :
{ }
{
RelationalExpression() |
RelationalExpression() A7_()
}

// #203 / PR_189.1
void A7_() :
{ }
{
<Token_Equal><Token_Equal> RelationalExpression() A7_() |
<Token_Equal><Token_Equal> RelationalExpression() |
<Token_ExclamationMark><Token_Equal> RelationalExpression() A7_() |
<Token_ExclamationMark><Token_Equal> RelationalExpression()
}

// #200 / PR_188
void RelationalExpression() :
{ }
{
ShiftExpression() |
ShiftExpression() A6_()
}

// #201 / PR_188.1
void A6_() :
{ }
{
<Token_LowerThan> ShiftExpression() A6_() |
<Token_LowerThan> ShiftExpression() |
<Token_GreaterThan> ShiftExpression() A6_() |
<Token_GreaterThan> ShiftExpression() |
<Token_LowerThan><Token_Equal> ShiftExpression() A6_() |
<Token_LowerThan><Token_Equal> ShiftExpression() |
<Token_GreaterThan><Token_Equal> ShiftExpression() A6_() |
<Token_GreaterThan><Token_Equal> ShiftExpression() |
<KW_instanceof> ReferenceType() A6_() |
<KW_instanceof> ReferenceType()
}

// #198 / PR_187
void ShiftExpression() :
{ }
{
AdditiveExpression() |
AdditiveExpression() A5_()
}

// #199 / PR_187.1
void A5_() :
{ }
{
<Token_LowerThan><Token_LowerThan> AdditiveExpression() A5_() |
<Token_LowerThan><Token_LowerThan> AdditiveExpression() |
<Token_GreaterThan><Token_GreaterThan> AdditiveExpression() A5_() |
<Token_GreaterThan><Token_GreaterThan> AdditiveExpression() |
<Token_GreaterThan><Token_GreaterThan><Token_GreaterThan>
AdditiveExpression() A5_() |
<Token_GreaterThan><Token_GreaterThan><Token_GreaterThan>
AdditiveExpression()
}

// #196 / PR_186
void AdditiveExpression() :
{ }
{
MultiplicativeExpression() |
MultiplicativeExpression() A4_()
}

// #197 / PR_186.1
void A4_() :
{ }
{
<Token_Plus> MultiplicativeExpression() A4_() |
<Token_Plus> MultiplicativeExpression() |
<Token_Minus> MultiplicativeExpression() A4_() |
<Token_Minus> MultiplicativeExpression()
}

// #194 / PR_185
void MultiplicativeExpression() :
{ }
{
UnaryExpression() | A3_()
}

// #195 / PR_185.1
void A3_() :
{ }
{
<Token_Asterisk> UnaryExpression() A3_() |
<Token_Asterisk> UnaryExpression() |
<Token_Slash> UnaryExpression() A3_() |
<Token_Slash> UnaryExpression() |
<Token_Percent> UnaryExpression() A3_() |
<Token_Percent> UnaryExpression()
}

// #189 / PR_180
void UnaryExpression() :
{ }
{
PreIncrementExpression() |
PreDecrementExpression() |
<Token_Plus> UnaryExpression() |
<Token_Minus> UnaryExpression() |
UnaryExpressionNotPlusMinus()
}

// #190 / PR_181
void PreIncrementExpression() :
{ }
{
<Token_Plus><Token_Plus> UnaryExpression()
}

// #191 / PR_182
void PreDecrementExpression() :
{ }
{
<Token_Minus><Token_Minus> UnaryExpression()
}

// #192 / PR_183
void UnaryExpressionNotPlusMinus() :
{ }
{
PostfixExpression() |
<Token_Tilde> UnaryExpression() |
<Token_ExclamationMark> UnaryExpression() |
CastExpression()
}

// 15.16 Cast Expressions

// #193 / PR_184
void CastExpression() :
{ }
{
<Token_ParenthesesOpen> PrimitiveType() <Token_ParenthesesClose>
UnaryExpression() |
<Token_ParenthesesOpen> ReferenceType() (AdditionalBound())*
<Token_ParenthesesClose> UnaryExpressionNotPlusMinus() |
<Token_ParenthesesOpen> ReferenceType() (AdditionalBound())*
<Token_ParenthesesClose> LambdaExpression()
}

// #186 / PR_179
void PostfixExpression() :
{ }
{
// Primary() A2_() A2_2() | // POSTPONED!
ExpressionName() A2_() A2_2()
}

// #15 / PR_14
void AdditionalBound() :
{ }
{
<Token_And> InterfaceType()
}

// #5 / PR_5
// B
void ClassType() :
{ }
{
Annotation() <Identifier> (TypeArguments())? | // a
ClassOrInterfaceType() <Token_Dot> Annotation() <Identifier>
(TypeArguments())? // A b
}

// #6 / PR_6
// C
void InterfaceType() :
{ }
{
ClassType() // B
}

// #187 / PR_179.1
void A2_() :
{ }
{
<Token_Plus><Token_Plus> A2_()
}

// #188 / PR_179.2
void A2_2() :
{ }
{
<Token_Minus><Token_Minus> A2_2()
}

// #24 / PR_23
void ExpressionName() :
{ }
{
<Identifier> |
AmbiguousName() <Token_Dot> <Identifier>
}

// #26 / PR_25
void AmbiguousName() :
{ }
{
<Identifier> (<Token_Dot> <Identifier>)*
}

// #218 / PR_199
void LambdaExpression() :
{ }
{
LambdaParameters() <Token_Minus><Token_GreaterThan> LambdaBody()
}

// 15.27.1 Lambda Parameters

// #219 / PR_200
void LambdaParameters() :
{ }
{
<Identifier> |
<Token_ParenthesesOpen> (FormalParameterList())?
<Token_ParenthesesClose> |
<Token_ParenthesesOpen> InferredFormalParameterList()
<Token_ParenthesesClose>
}

// #220 / PR_201
void InferredFormalParameterList() :
{ }
{
<Identifier> (<Token_Comma> <Identifier>)*
}

// 15.27.2 Lambda Body

// #221 / PR_202
void LambdaBody() :
{ }
{
Expression()
// | Block() POSTPONED!
}

// #65 / PR_63
void FormalParameterList() :
{ }
{
FormalParameters() <Token_Comma> LastFormalParameter() |
LastFormalParameter()
}

// #66 / PR_64
void FormalParameters() :
{ }
{
FormalParameter() (<Token_Comma> FormalParameter())* |
ReceiverParameter() (<Token_Comma> FormalParameter())*
}

// #67 / PR_65
void FormalParameter() :
{ }
{
(VariableModifier())* UnannType() VariableDeclaratorId()
}

// #69 / PR_67
void ReceiverParameter() :
{ }
{
(Annotation())* UnannType() (<Identifier> <Token_Dot>)? <KW_this>
}

// #70 / PR_68
void LastFormalParameter() :
{ }
{
(VariableModifier())* UnannType() (Annotation())*
<Token_Dot><Token_Dot><Token_Dot> VariableDeclaratorId() |
FormalParameter()
}

// #52 / PR_51
void UnannType() :
{ }
{
UnannPrimitiveType() |
UnannReferenceType()
}

// #53 / PR_52
void UnannPrimitiveType() :
{ }
{
NumericType() | <KW_boolean>
}

// #54 / PR_53
void UnannReferenceType() :
{ }
{
UnannClassOrInterfaceType() |
UnannTypeVariable() |
UnannArrayType()
}

// #57 / PR_56
void UnannClassOrInterfaceType() :
{ }
{
<Identifier> (TypeArguments())? |
<Identifier> (TypeArguments())? N()
}

// #58 / PR_56.1
void N() :
{ }
{
<Token_Dot> (Annotation())* <Identifier> (TypeArguments())? N() |
<Token_Dot> (Annotation())* <Identifier> (TypeArguments())?
}

// Resolved non left-recursive Grammar End

// #59 / PR_57
void UnannTypeVariable() :
{ }
{
<Identifier>
}

// #60 / PR_58
void UnannArrayType() :
{ }
{
UnannPrimitiveType() Dims() |
UnannClassOrInterfaceType() Dims() |
UnannTypeVariable() Dims()
}

// #50 / PR_49
void VariableDeclaratorId() :
{ }
{
<Identifier> (Dims())?
}

// #68 / PR_66
void VariableModifier() :
{ }
{
Annotation() | <KW_final>
}

// #168 / PR_166
void Expression() :
{ }
{
LambdaExpression() |
AssignmentExpression()
}

// #215 / PR_196
void AssignmentExpression() :
{ }
{
ConditionalExpression() |
Assignment()
}

// #216 / PR_197
void Assignment() :
{ }
{
LeftHandSide() <AssignmentOperator> Expression()
}

// #217 / PR_198
void LeftHandSide() :
{ }
{
ExpressionName() |
FieldAccess() |
ArrayAccess()
}

TOKEN :
{
< AssignmentOperator : "=" | "*=" | "/=" | "%=" | "+=" | "-=" |
"<<=" | ">>=" | "&=" | "^=" | "|=" >
}

TOKEN :
{
< AssignmentOperator :
<Token_Equal>
| <Token_Asterisk><Token_Equal>
| <Token_Slash><Token_Equal>
| <Token_Percent><Token_Equal>
| <Token_Plus><Token_Equal>
| <Token_Minus><Token_Equal>
| <Token_LowerThan><Token_LowerThan><Token_Equal>
| <Token_GreaterThan><Token_GreaterThan><Token_Equal>
| <Token_And><Token_Equal>
| <Token_CircumFlexAccent><Token_Equal>
| <Token_Pipe><Token_Equal>
>
}

// #170 / PR_168
// D
void FieldAccess() :
{ }
{
// Primary() <Token_Dot> <Identifier> |
POSTPOPONED!
<KW_super> <Token_Dot> <Identifier> |
TypeName() <Token_Dot> <KW_super> <Token_Dot> <Identifier>
}

// 15.10.3 Array Access Expressions

// #170 / PR_168
// E
void ArrayAccess() :
{ }
{
ExpressionName() <Token_BracketsOpen> Expression()
<Token_BracketsClose>
// | PrimaryNoNewArray() "[" Expression() "]"
POSTPONED!
}

//
=========================================================================

void start() :
{ }
{
{ System.out.println("begin"); }
{ System.out.println("begin"); }
<EOF>

}