language Java {
  omit JavaLex.Omit;

  nonterminal {
    Java, CompilationUnit, PackageDeclaration, ImportDeclarations,
    ImportDeclaration, ImportName, TypeDeclarations, TypeDeclaration,
    InterfacesOpt, Interfaces, InterfaceTypeList, ClassType,
    InterfaceType, Modifiers, Modifier, ModifiersOpt,
    ClassDeclaration, SuperOpt, Super, ClassBody,
    ClassBodyDeclarations, ClassBodyDeclaration,
    ClassMemberDeclaration, StaticInitializer, InterfaceDeclaration,
    ExtendsInterfacesOpt, ExtendsInterfaces, ExtendsInterfacesRest,
    InterfaceBody, InterfaceMemberDeclarationsOpt,
    InterfaceMemberDeclarations, InterfaceMemberDeclaration,
    ConstantDeclaration, AbstractMethodDeclaration, FieldDeclaration,
    VariableDeclarators, VariableDeclarator, VariableDeclaratorId,
    VariableDeclaratorIdRest, VariableInitializer, ArrayInitializer,
    VariableInitializersOpt, VariableInitializers, MethodDeclaration,
    MethodHeader, MethodDeclarator, MethodDeclaratorRest, MethodBody,
    FormalParameterListOpt, FormalParameterList, FormalParameter,
    ThrowsOpt, Throws, ClassTypeList, ConstructorDeclaration,
    ConstructorDeclarator, ConstructorBody,
    ExplicitConstructorInvocationOpt, ExplicitConstructorInvocation,
    ConstructorModifier, Type, ReferenceType, ArrayTypeRest,
    PrimitiveType, NumericType, IntegralType, FloatingPointType,
    ResultType, Statement, LabeledStatement, Block, BlockStatements,
    BlockStatement, LocalVariableDeclaration,
    LocalVariableDeclarationRest, EmptyStatement, StatementExpression,
    SwitchStatement, SwitchBlocks, SwitchLabel, IfStatement,
    WhileStatement, DoStatement, ForStatement, ForInitOpt, ForInit,
    StatementExpressionList, ForUpdateOpt, ForUpdate, BreakStatement,
    ContinueStatement, ReturnStatement, ThrowStatement,
    SynchronizedStatement, TryStatement, Catchblock, ExpressionOpt,
    Expression, AssignmentOperator, ConditionalExpression,
    ConditionalOrExpression, ConditionalOrExpressionRest,
    ConditionalAndExpression, ConditionalAndExpressionRest,
    InclusiveOrExpression, InclusiveOrExpressionRest,
    ExclusiveOrExpression, ExclusiveOrExpressionRest, AndExpression,
    AndExpressionRest, EqualityExpression, EqualityExpressionRest,
    InstanceOfExpression, RelationalExpression,
    RelationalExpressionRest, ShiftExpression, ShiftExpressionRest,
    AdditiveExpression, AdditiveExpressionRest,
    MultiplicativeExpression, MultiplicativeExpressionRest,
    UnaryExpression, PreIncrementExpression, PreDecrementExpression,
    UnaryExpressionNotPlusMinus, PostfixExpression, CastExpression,
    PrimaryExpression, PrimaryExpressionRest, PrimaryPrefix,
    PrimarySuffix, Literal, BooleanLiteral, NullLiteral, Arguments,
    ArgumentList, AllocationExpression, ArrayDimsAndInits,
    ArrayDimsExpression, ArrayDims, Name, SimpleName, QualifiedName,
    IntegerLiteral;
  }

  Java                                --> <CompilationUnit> [/] ;

  CompilationUnit                     --> <PackageDeclaration> [/] <ImportDeclarations> [/] <TypeDeclarations> ;
                                      --> <ImportDeclarations> <TypeDeclarations> [] ;

  PackageDeclaration                  --> package <Name> [] ";" [/] ;


  ImportDeclarations                  --> <ImportDeclaration> <ImportDeclarations> [] ;
                                      --> ;

  ImportDeclaration                   --> import <ImportName> [] ";" [/] ;

  ImportName                          --> <JavaLex.Identifier> [] . [] <ImportName> ;
				      --> <JavaLex.Identifier> [] . [] * ;
				      --> <JavaLex.Identifier> ;

  TypeDeclarations                    --> <TypeDeclaration> <TypeDeclarations> ;
                                      --> <TypeDeclaration> ;

  TypeDeclaration                     --> <ModifiersOpt> <ClassDeclaration> ;
                                      --> <ModifiersOpt> <InterfaceDeclaration> ;
                                      --> ";" [/] ;

  InterfacesOpt                       --> <Interfaces> ;
                                      --> ;

  Interfaces                          --> implements <InterfaceTypeList> ;

  InterfaceTypeList                   --> <InterfaceType> ;
                                      --> <InterfaceType> [] , <InterfaceTypeList> ;

  ClassType                           --> <Name> ;

  InterfaceType                       --> <Name> ;

  // -- Declaration: --------------------------------------------------

  Modifiers                           --> <Modifier> <Modifiers> ;
                                      --> <Modifier> ;

  Modifier                            --> public ;
                                      --> protected ;
                                      --> private ;
                                      --> static ;
                                      --> abstract ;
                                      --> final ;
                                      --> native ;
                                      --> synchronized ;
                                      --> transient ;
                                      --> volatile ;

  ConstructorModifier		      --> public ;
				      --> protected ;
				      --> private ;
				      --> ;

  ModifiersOpt                        --> <Modifiers> ;
                                      --> ;

  ClassDeclaration                    --> class <JavaLex.Identifier> <SuperOpt> <Java.InterfacesOpt> <ClassBody> ;

  SuperOpt                            --> <Super> ;
                                      --> ;

  Super                               --> extends <ClassType> ;

  ClassBody                           --> { [+/] <ClassBodyDeclarations> [-/] } [/] ;

  ClassBodyDeclarations               --> <ClassBodyDeclaration> [/] <ClassBodyDeclarations> ;
				      --> ;

  ClassBodyDeclaration                --> [<StaticInitializer>] <StaticInitializer> ;
				      --> [<ClassDeclaration>] <ClassDeclaration> ;
				      --> [<InterfaceDeclaration>] <InterfaceDeclaration> ;
                                      --> [<ConstructorDeclaratorAndDeclaration>] <ConstructorModifier> <ConstructorDeclaration> ;
				      --> <ModifiersOpt> <ClassMemberDeclaration> ;
                                      
  nonterminal ConstructorDeclaratorAndDeclaration;
  ConstructorDeclaratorAndDeclaration   --> <ConstructorModifier> <ConstructorDeclaration> ;

    ClassMemberDeclaration              --> [<FieldDeclaration>] <FieldDeclaration> ;
                                        --> <MethodDeclaration> ;

    StaticInitializer                   --> static <Block> ;

    InterfaceDeclaration                --> interface <JavaLex.Identifier> <ExtendsInterfacesOpt> <InterfaceBody> ;

    ExtendsInterfacesOpt                --> <ExtendsInterfaces> ;
                                        --> ;

    ExtendsInterfaces                   --> extends <Java.InterfaceType> <ExtendsInterfacesRest>;

    ExtendsInterfacesRest               --> , <Java.InterfaceType> <ExtendsInterfacesRest> ;
                                        --> ;

    InterfaceBody                       --> [/] { [+/] <InterfaceMemberDeclarationsOpt> [-/] } [/] ;

    InterfaceMemberDeclarationsOpt      --> <InterfaceMemberDeclarations> ;
                                        --> ;

    InterfaceMemberDeclarations         --> <InterfaceMemberDeclaration> [/] ;
                                        --> <InterfaceMemberDeclaration> [/] <InterfaceMemberDeclarations> ;

    InterfaceMemberDeclaration          --> <ConstantDeclaration> ;
                                        --> [<AbstractMethodDeclaration>] <AbstractMethodDeclaration> ;

    ConstantDeclaration                 --> <ModifiersOpt> <FieldDeclaration> ;

    AbstractMethodDeclaration           --> <ModifiersOpt> <MethodHeader> \; ;

    FieldDeclaration                    --> <Type> <VariableDeclarators> [] ";" ;

    VariableDeclarators                 --> <VariableDeclarator> ;
                                        --> <VariableDeclarator> , <VariableDeclarators> ;

    VariableDeclarator                  --> <VariableDeclaratorId> ;
                                        --> <VariableDeclaratorId> = <VariableInitializer> ;

    VariableDeclaratorId                --> <JavaLex.Identifier> [] <VariableDeclaratorIdRest>;
                                        --> <JavaLex.Identifier> ;

    VariableDeclaratorIdRest            --> "[" [] "]" [] <VariableDeclaratorIdRest> ;
                                        --> "[" [] "]" ;

    VariableInitializer                 --> <Expression> ;
                                        --> <ArrayInitializer> ;

    ArrayInitializer                    --> { <VariableInitializersOpt> , } ;
                                        --> { <VariableInitializersOpt> } ;

    VariableInitializersOpt             --> <VariableInitializers> ;
                                        --> ;

    VariableInitializers                --> <VariableInitializer> ;
					--> <VariableInitializer> , ;
                                        --> <VariableInitializer> , <VariableInitializers> ;

    MethodDeclaration                   --> <MethodHeader> <MethodBody> [/] ;

    MethodHeader                        --> <ResultType> <MethodDeclarator> <ThrowsOpt> ;

    MethodDeclarator                    --> <JavaLex.Identifier> [] ( [] <FormalParameterListOpt> [] ) ;
                                        --> <JavaLex.Identifier> ( [] <FormalParameterListOpt> [] ) [] <MethodDeclaratorRest>;

    MethodDeclaratorRest                --> "[" [] "]" [] <MethodDeclaratorRest> ;
                                        --> "[" "]" ;

    MethodBody                          --> <Block> ;
                                        --> \; ;

    FormalParameterListOpt              --> <FormalParameterList> ;
                                        --> ;

    FormalParameterList                 --> <FormalParameter> ;
                                        --> <FormalParameter> , <FormalParameterList> ;

    FormalParameter                     --> <Type> <VariableDeclaratorId> ;

    ThrowsOpt                           --> <Throws> ;
                                        --> ;

    Throws                              --> throws <ClassTypeList> ;

    ClassTypeList                       --> <Java.ClassType> ;
                                        --> <Java.ClassType> , <ClassTypeList> ;


    ConstructorDeclaration              --> <ConstructorDeclarator> <ThrowsOpt> [/] <ConstructorBody> ;

    ConstructorDeclarator               --> <SimpleName> ( <FormalParameterListOpt> ) ;

    ConstructorBody                     --> { [/+] <ExplicitConstructorInvocationOpt> <BlockStatements> [/-] } ;

    ExplicitConstructorInvocationOpt    --> [<ExplicitConstructorInvocation>] <ExplicitConstructorInvocation> ;
                                        --> ;

    ExplicitConstructorInvocation       --> this [] <Arguments> \; [/] ;
                                        --> super [] <Arguments> \; [/] ;


  // -- Type: --------------------------------------------------

    Type                                --> <PrimitiveType> ;
                                        --> <ReferenceType> ;

    ReferenceType                       --> <PrimitiveType> <ArrayTypeRest> ;
                                        --> <Name> <ArrayTypeRest> ;

    ArrayTypeRest                       --> "[" [] "]" <ArrayTypeRest> ;
                                        --> ;

    PrimitiveType                       --> <NumericType> ;
                                        --> boolean ;

    NumericType                         --> <IntegralType> ;
                                        --> <FloatingPointType> ;

    IntegralType                        --> byte ;
                                        --> short ;
                                        --> int ;
                                        --> long ;
                                        --> char ;

    FloatingPointType                   --> float ;
                                        --> double ;

    ResultType                          --> void ;
                                        --> <Type> ;

  // -- Statement: --------------------------------------------------

    Statement                           --> [<LabeledStatement>] <LabeledStatement> ;
                                        --> <Block> ;
                                        --> <EmptyStatement> ;
                                        --> <StatementExpression> [] ";" ;
                                        --> <SwitchStatement> ;
                                        --> <IfStatement> ;
                                        --> <WhileStatement> ;
                                        --> <DoStatement> ;
                                        --> <ForStatement> ;
                                        --> <BreakStatement> ;
                                        --> <ContinueStatement> ;
                                        --> <ReturnStatement> ;
                                        --> <ThrowStatement> ;
                                        --> <SynchronizedStatement> ;
                                        --> <TryStatement> ;

    LabeledStatement                    --> <JavaLex.Identifier> : <Statement> ;

    Block                               --> { [+/] <BlockStatements> [-/] } ;

    BlockStatements                     --> <BlockStatement> [/] <BlockStatements> ;
					--> [<CaseTrap>] ;
                                        --> ;

    BlockStatement                      --> [<LocalVariableDeclaration>] <LocalVariableDeclaration> [] ";" ;
                                        --> <Statement>  ;
                                        --> <ClassDeclaration>  ;

    LocalVariableDeclaration            --> final <Type> <VariableDeclarator> <LocalVariableDeclarationRest> ;
                                        --> <Type> <VariableDeclarator> <LocalVariableDeclarationRest> ;

    LocalVariableDeclarationRest        --> , <VariableDeclarator> [] <LocalVariableDeclarationRest> ;
                                        --> ;

    EmptyStatement                      --> \; ;

    StatementExpression                 --> <PreIncrementExpression> ;
                                        --> <PreDecrementExpression> ;
                                        --> <PrimaryExpression> ;
                                        --> <PrimaryExpression> [] ++ ;
                                        --> <PrimaryExpression> [] -- ;
                                        --> <PrimaryExpression> <AssignmentOperator> <Expression> ;
	
    SwitchStatement                     --> switch ( <Expression> ) { <SwitchBlocks> } ;

    SwitchBlocks                        --> <SwitchLabel> <BlockStatements> <SwitchBlocks> ;
					--> ;

    SwitchLabel                         --> case <Expression> : ;
                                        --> default : ;

    IfStatement                         --> if ( [] <Expression> [] ) <Statement> else [+] <Statement> [-] ;
                                        --> if ( [] <Expression> [] ) <Statement> ;

    WhileStatement                      --> while ( <Expression> ) <Statement> ;

    DoStatement                         --> do <Statement> while ( <Expression> ) \; [/] ;

    ForStatement                        --> for ( [] <ForInitOpt> [] ";" <ExpressionOpt> [] ";" <ForUpdateOpt> [] ) <Statement> ;

    ForInitOpt                          --> <ForInit> ;
                                        --> ;

    ForInit                             --> [<LocalVariableDeclaration>] <LocalVariableDeclaration> ;
                                        --> <StatementExpressionList> ;

    StatementExpressionList             --> <StatementExpression> , <StatementExpressionList> ;
                                        --> <StatementExpression> ;

    ForUpdateOpt                        --> <ForUpdate> ;
                                        --> ;

    ForUpdate                           --> <StatementExpressionList> ;

    BreakStatement                      --> break <JavaLex.Identifier> [] ";" [/] ;
                                        --> break [] ";" [/] ;

    ContinueStatement                   --> continue <JavaLex.Identifier> [] ";" [/] ;
                                        --> continue [] ";" [/] ;

    ReturnStatement                     --> return <Expression> [] ";" [/] ;
                                        --> return [] ";" [/] ;

    ThrowStatement                      --> throw <Expression> \; ;

    SynchronizedStatement               --> synchronized ( <Expression> ) <Block> ;

    TryStatement                        --> try <Block> <Catchblock> finally <Block> ;
                                        --> try <Block> [/] <Catchblock> ;

    Catchblock                          --> catch ( [] <FormalParameter> [] ) <Block> <Catchblock> ;
                                        --> ;


  // -- Expression: --------------------------------------------------

    ExpressionOpt                       --> <Expression> ;
                                        --> ;

    Expression                          --> <ConditionalExpression> ;
                                        --> <ConditionalExpression> <AssignmentOperator> <Expression> ;

    AssignmentOperator                  --> = ;
                                        --> *= ;
                                        --> /= ;
                                        --> %= ;
                                        --> += ;
                                        --> -= ;
                                        --> \<\<= ;
                                        --> \>\>= ;
                                        --> \>\>\>= ;
                                        --> &= ;
                                        --> ^= ;
                                        --> |= ;

    ConditionalExpression               --> <ConditionalOrExpression> ? <Expression> : <ConditionalExpression> ;
                                        --> <ConditionalOrExpression> ;

    ConditionalOrExpression             --> <ConditionalAndExpression> <ConditionalOrExpressionRest> ;

    ConditionalOrExpressionRest         --> || <ConditionalAndExpression> <ConditionalOrExpressionRest> ;
                                        --> ;

    ConditionalAndExpression            --> <InclusiveOrExpression> <ConditionalAndExpressionRest> ;

    ConditionalAndExpressionRest        --> && <InclusiveOrExpression> <ConditionalAndExpressionRest> ;
                                        --> ;

    InclusiveOrExpression               --> <ExclusiveOrExpression> <InclusiveOrExpressionRest> ;

    InclusiveOrExpressionRest           --> | <ExclusiveOrExpression> <InclusiveOrExpressionRest> ;
                                        --> [ <OrOrTrap> ] ;
                                        --> ;

    ExclusiveOrExpression               --> <AndExpression> <ExclusiveOrExpressionRest> ;

    ExclusiveOrExpressionRest           --> ^ <AndExpression> <ExclusiveOrExpressionRest> ;
                                        --> ;

    AndExpression                       --> <EqualityExpression> <AndExpressionRest> ;

    AndExpressionRest                   --> & <EqualityExpression> <AndExpressionRest> ;
                                        --> [ <AndAndTrap> ] ;
                                        --> ;

    EqualityExpression                  --> <InstanceOfExpression> <EqualityExpressionRest> ;

    EqualityExpressionRest              --> == <InstanceOfExpression> <EqualityExpressionRest> ;
                                        --> != <InstanceOfExpression> <EqualityExpressionRest> ;
                                        --> ;

    InstanceOfExpression                --> <RelationalExpression> instanceof <Type> ;
                                        --> <RelationalExpression> ;

    RelationalExpression                --> <ShiftExpression> <RelationalExpressionRest> ;

    RelationalExpressionRest            --> \< <ShiftExpression> <RelationalExpressionRest> ;
                                        --> \> <ShiftExpression> <RelationalExpressionRest> ;
                                        --> \<= <ShiftExpression> <RelationalExpressionRest> ;
                                        --> \>= <ShiftExpression> <RelationalExpressionRest> ;
                                        --> ;

    ShiftExpression                     --> <AdditiveExpression> <ShiftExpressionRest> ;

    ShiftExpressionRest                 --> \<\< <AdditiveExpression> <ShiftExpressionRest> ;
                                        --> \>\> <AdditiveExpression> <ShiftExpressionRest> ;
                                        --> \>\>\> <AdditiveExpression> <ShiftExpressionRest> ;
                                        --> ;

    AdditiveExpression                  --> <MultiplicativeExpression> <AdditiveExpressionRest> ;

    AdditiveExpressionRest              --> + <MultiplicativeExpression> <AdditiveExpressionRest> ;
                                        --> - <MultiplicativeExpression> <AdditiveExpressionRest> ;
                                        --> ;

    MultiplicativeExpression            --> <UnaryExpression> <MultiplicativeExpressionRest> ;

    MultiplicativeExpressionRest        --> * <UnaryExpression> <MultiplicativeExpressionRest> ;
                                        --> / <UnaryExpression> <MultiplicativeExpressionRest> ;
                                        --> % <UnaryExpression> <MultiplicativeExpressionRest> ;
                                        --> ;

    UnaryExpression                     --> + <UnaryExpression> ;
                                        --> - <UnaryExpression> ;
                                        --> <PreIncrementExpression> ;
                                        --> <PreDecrementExpression> ;
                                        --> <UnaryExpressionNotPlusMinus> ;

    PreIncrementExpression              --> ++ [] <PrimaryExpression> ;

    PreDecrementExpression              --> -- [] <PrimaryExpression> ;

    UnaryExpressionNotPlusMinus         --> ~ [] <UnaryExpression> ;
                                        --> ! [] <UnaryExpression> ;
                                        --> [<CastExpression>] <CastExpression> ;
                                        --> <PostfixExpression> ;

    PostfixExpression                   --> <PrimaryExpression> ++ ;
                                        --> <PrimaryExpression> -- ;
                                        --> <PrimaryExpression> ;

    CastExpression                      --> ( [] <Type> [] ) [] <UnaryExpression> ;
                                        --> ( [] <Type> [] ) [] <UnaryExpressionNotPlusMinus> ;

    PrimaryExpression                   --> <PrimaryPrefix> <PrimaryExpressionRest> ;

    PrimaryExpressionRest               --> [] <PrimarySuffix> <PrimaryExpressionRest> ;
                                        --> ;

    PrimaryPrefix                       --> <Literal> ;
                                        --> this ;
                                        --> super [] . [] <JavaLex.Identifier> ;
                                        --> ( [] <Expression> [] ) ;
                                        --> <AllocationExpression> ;
                                        --> [<ResultTypeDotClass>] <ResultType> [] . [] class ;
                                        --> <Name> ;

    nonterminal ResultTypeDotClass;
    ResultTypeDotClass  	        --> <ResultType> [] . [] class ;

    PrimarySuffix                       --> .this ;
                                        --> [] . []  <AllocationExpression> ;
                                        --> "[" [] <Expression> [] "]" ;
                                        --> [] . [] <JavaLex.Identifier> ;
                                        --> <Arguments> ;

    Literal                             --> <IntegerLiteral> ;
                                        --> <JavaLex.FloatingPointLiteral> ;
                                        --> <JavaLex.CharacterLiteral> ;
                                        --> <JavaLex.StringLiteral> ;
                                        --> <BooleanLiteral> ;
                                        --> <NullLiteral> ;

    BooleanLiteral                      --> true ;
                                        --> false ;

    NullLiteral                         --> null ;

    Arguments                           --> ( [] <ArgumentList> [] ) ;
                                        --> ( [] ) ;

    ArgumentList                        --> <Expression> [] , <ArgumentList> ;
                                        --> <Expression> ;


    AllocationExpression                --> new <PrimitiveType> [] <ArrayDimsAndInits> ;
                                        --> new <Name> [] <ArrayDimsAndInits> ;
                                        --> new <Name> [] <Arguments> <ClassBody> ;
                                        --> new <Name> [] <Arguments> ;

    ArrayDimsAndInits                   --> <ArrayDimsExpression> <ArrayDims> ;
                                        --> <ArrayDimsExpression> ;
                                        --> [<ArrayDimsAndInitializer>] <ArrayDims> <ArrayInitializer> ;

    nonterminal ArrayDimsAndInitializer;
    ArrayDimsAndInitializer             --> <ArrayDims> <ArrayInitializer> ;

    ArrayDimsExpression                 --> "[" [] <Expression> [] "]" [] <ArrayDimsExpression> ;
                                        --> "[" [] <Expression> [] "]" ;

    ArrayDims                           --> "[" "]" <ArrayDims> ;
                                        --> ;

  // -- Identifier: --------------------------------------------------

  Name                                --> <SimpleName> <QualifiedName> ;

  SimpleName                          --> <JavaLex.Identifier> ;

  QualifiedName                       --> [] . [] <JavaLex.Identifier> <QualifiedName> ;
                                      --> ;


  IntegerLiteral			--> <JavaLex.DecimalLiteral> ;
					--> <JavaLex.HexLiteral> ;
					--> <JavaLex.OctalLiteral> ;


  // -- Traps: --------------------------------------------------

  nonterminal {
    CaseTrap, AndAndTrap, OrOrTrap;
  }

  CaseTrap	   	              --> case ;

  AndAndTrap                        --> && ;

  OrOrTrap                          --> || ;
}