java1.1nola.jj

java 编译器java复杂编译器,可以编译java文件的类库

}

void EqualityExpression() :
{}
{
  InstanceOfExpression() ( ( "==" | "!=" ) InstanceOfExpression() )*
}

void InstanceOfExpression() :
{}
{
  RelationalExpression() [ "instanceof" Type() ]
}

void RelationalExpression() :
{}
{
  ShiftExpression() ( ( "<" | ">" | "<=" | ">=" ) ShiftExpression() )*
}

void ShiftExpression() :
{}
{
  AdditiveExpression() ( ( "<<" | ">>" | ">>>" ) AdditiveExpression() )*
}

void AdditiveExpression() :
{}
{
  MultiplicativeExpression() ( ( "+" | "-" ) MultiplicativeExpression() )*
}

void MultiplicativeExpression() :
{}
{
  UnaryExpression() ( ( "*" | "/" | "%" ) UnaryExpression() )*
}

void UnaryExpression() :
{}
{
  ( "+" | "-" ) UnaryExpression()
|
  PreIncrementExpression()
|
  PreDecrementExpression()
|
  LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
               <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
               <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
               <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> |
               <LPAREN> | <BANG> | <TILDE>)
  UnaryExpressionNotPlusMinus()
}

void PreIncrementExpression() :
{}
{
  "++" PrimaryExpression()
}

void PreDecrementExpression() :
{}
{
  "--" PrimaryExpression()
}

void UnaryExpressionNotPlusMinus() :
{}
{
  ( "~" | "!" ) UnaryExpression()
|
  LOOKAHEAD( { isTypeCast() } )
  CastExpression()
|
  LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
               <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
               <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
               <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> | <LPAREN>)
  PostfixExpression()
}

void PostfixExpression() :
{}
{
  PrimaryExpression() [ "++" | "--" ]
}

void CastExpression() :
{}
{
  LOOKAHEAD( { isPrimitiveTypeCast() } )
  "(" Type() ")" UnaryExpression()
|
  "(" Type() ")" UnaryExpressionNotPlusMinus()
}

void PrimaryExpression() :
{}
{
  PrimaryPrefix() ( LOOKAHEAD( { isPrimarySuffix() } ) PrimarySuffix() )*
}

void PrimaryPrefix() :
{}
{
  Literal()
|
  "this"
|
  "super" "." <IDENTIFIER>
|
  "(" Expression() ")"
|
  LOOKAHEAD(1, <NEW>)
  AllocationExpression()
|
  LOOKAHEAD( { isClassSelector() } )
  ResultType() "." "class"
|
  Name()
}

void PrimarySuffix() :
{}
{
  LOOKAHEAD( { getToken(1).kind == DOT && getToken(2).kind == THIS } )
  "." "this"
|
  LOOKAHEAD( { getToken(1).kind == DOT && getToken(2).kind == NEW } )
  "." AllocationExpression()
|
  "[" Expression() "]"
|
  "." <IDENTIFIER>
|
  Arguments()
}

void Literal() :
{}
{
  <INTEGER_LITERAL>
|
  <FLOATING_POINT_LITERAL>
|
  <CHARACTER_LITERAL>
|
  <STRING_LITERAL>
|
  BooleanLiteral()
|
  NullLiteral()
}

void BooleanLiteral() :
{}
{
  "true"
|
  "false"
}

void NullLiteral() :
{}
{
  "null"
}

void Arguments() :
{}
{
  "("
    [
      LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
                   <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
                   <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
                   <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> | <LPAREN> |
                   <BANG> | <TILDE> | <INCR> | <DECR> | <PLUS> | <MINUS>)
      ArgumentList()
    ]
  ")"
}

void ArgumentList() :
{}
{
  Expression() ( "," Expression() )*
}

void AllocationExpression() :
{}
{
  LOOKAHEAD( { getToken(2).kind != IDENTIFIER } )
  "new" PrimitiveType() ArrayDimsAndInits()
|
  "new" Name()
    (
      LOOKAHEAD(1, <LBRACKET>)
      ArrayDimsAndInits()
    |
      Arguments() [ ClassBody() ]
    )
}

/*
 * The third LOOKAHEAD specification below is to parse to PrimarySuffix
 * if there is an expression between the "[...]".
 */
void ArrayDimsAndInits() :
{}
{
  LOOKAHEAD( { getToken(2).kind != RBRACKET } )
  ( LOOKAHEAD( { getToken(1).kind == LBRACKET && getToken(2).kind != RBRACKET } )
    "[" Expression() "]"
  )+
  ( LOOKAHEAD( { getToken(1).kind == LBRACKET && getToken(2).kind == RBRACKET } )
    "[" "]"
  )*
|
  ( "[" "]" )+ ArrayInitializer()
}


/*
 * Statement syntax follows.
 */

void Statement() :
{}
{
  LOOKAHEAD( { getToken(1).kind == IDENTIFIER && getToken(2).kind == COLON } )
  LabeledStatement()
|
  Block()
|
  EmptyStatement()
|
  LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
               <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
               <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
               <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> |
               <LPAREN> | <INCR> | <DECR>)
  StatementExpression() ";"
|
  SwitchStatement()
|
  IfStatement()
|
  WhileStatement()
|
  DoStatement()
|
  ForStatement()
|
  BreakStatement()
|
  ContinueStatement()
|
  ReturnStatement()
|
  ThrowStatement()
|
  SynchronizedStatement()
|
  TryStatement()
}

void LabeledStatement() :
{}
{
  <IDENTIFIER> ":" Statement()
}

void Block() :
{}
{
  "{"
    (
      LOOKAHEAD(1, <BOOLEAN> | <BREAK> | <BYTE> | <CHAR> | <CLASS> | <CONTINUE> |
                   <DO> | <DOUBLE> | <FALSE> | <FINAL> | <FLOAT> | <FOR> | <IF> |
                   <INT> | <LONG> | <NEW> | <NULL> | <RETURN> | <SHORT> | <SUPER> |
                   <SWITCH> | <SYNCHRONIZED> | <THIS> | <THROW> | <TRUE> | <TRY> |
                   <VOID> | <WHILE> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
                   <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> |
                   <LPAREN> | <LBRACE> | <SEMICOLON> | <INCR> | <DECR>)
      BlockStatement()
    )*
  "}"
}

void BlockStatement() :
{}
{
  LOOKAHEAD( { isLocalVariableDeclaration() } )
  LocalVariableDeclaration() ";"
|
  LOOKAHEAD(1, <BOOLEAN> | <BREAK> | <BYTE> | <CHAR> | <CONTINUE> | <DO> |
               <DOUBLE> | <FALSE> | <FLOAT> | <FOR> | <IF> | <INT> | <LONG> |
               <NEW> | <NULL> | <RETURN> | <SHORT> | <SUPER> | <SWITCH> |
               <SYNCHRONIZED> | <THIS> | <THROW> | <TRUE> | <TRY> | <VOID> |
               <WHILE> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
               <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> | <LPAREN> |
               <LBRACE> | <SEMICOLON> | <INCR> | <DECR>)
  Statement()
|
  UnmodifiedClassDeclaration()
|
  UnmodifiedInterfaceDeclaration()
}

void LocalVariableDeclaration() :
{}
{
  [ "final" ] Type() VariableDeclarator() ( "," VariableDeclarator() )*
}

void EmptyStatement() :
{}
{
  ";"
}

void StatementExpression() :
/*
 * The last expansion of this production accepts more than the legal
 * Java expansions for StatementExpression.  This expansion does not
 * use PostfixExpression for performance reasons.
 */
{}
{
  PreIncrementExpression()
|
  PreDecrementExpression()
|
  LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
               <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
               <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
               <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> | <LPAREN>)
  PrimaryExpression()
  [
    "++"
  |
    "--"
  |
    AssignmentOperator() Expression()
  ]
}

void SwitchStatement() :
{}
{
  "switch" "(" Expression() ")" "{"
    (
      SwitchLabel()
      (
        LOOKAHEAD(1, <BOOLEAN> | <BREAK> | <BYTE> | <CHAR> | <CLASS> | <CONTINUE> |
                     <DO> | <DOUBLE> | <FALSE> | <FINAL> | <FLOAT> | <FOR> | <IF> |
                     <INT> | <LONG> | <NEW> | <NULL> | <RETURN> | <SHORT> | <SUPER> |
                     <SWITCH> | <SYNCHRONIZED> | <THIS> | <THROW> | <TRUE> | <TRY> |
                     <VOID> | <WHILE> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
                     <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> |
                     <LPAREN> | <LBRACE> | <SEMICOLON> | <INCR> | <DECR>)
        BlockStatement()
      )*
    )*
  "}"
}

void SwitchLabel() :
{}
{
  "case" Expression() ":"
|
  "default" ":"
}

void IfStatement() :
/*
 * The disambiguating algorithm of JavaCC automatically binds dangling
 * else's to the innermost if statement.  The LOOKAHEAD specification
 * is to tell JavaCC that we know what we are doing.
 */
{}
{
  "if" "(" Expression() ")" Statement() [ LOOKAHEAD(1) "else" Statement() ]
}

void WhileStatement() :
{}
{
  "while" "(" Expression() ")" Statement()
}

void DoStatement() :
{}
{
  "do" Statement() "while" "(" Expression() ")" ";"
}

void ForStatement() :
{}
{
  "for" "("
    [
      LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FINAL> |
                   <FLOAT> | <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> |
                   <THIS> | <TRUE> | <VOID> | <INTEGER_LITERAL> |
                   <FLOATING_POINT_LITERAL> | <CHARACTER_LITERAL> | <STRING_LITERAL> |
                   <IDENTIFIER> | <LPAREN> | <INCR> | <DECR>)
      ForInit()
    ]
    ";"
    [
      LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
                   <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
                   <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
                   <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> | <LPAREN> |
                   <BANG> | <TILDE> | <INCR> | <DECR> | <PLUS> | <MINUS>)
      Expression()
    ]
    ";"
    [
      LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
                   <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
                   <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
                   <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> | <LPAREN> |
                   <INCR> | <DECR>)
      ForUpdate()
    ]
    ")"
    Statement()
}

void ForInit() :
{}
{
  LOOKAHEAD( { isLocalVariableDeclaration() } )
  LocalVariableDeclaration()
|
  LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
               <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
               <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
               <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> | <LPAREN> |
               <INCR> | <DECR>)
  StatementExpressionList()
}

void StatementExpressionList() :
{}
{
  StatementExpression() ( "," StatementExpression() )*
}

void ForUpdate() :
{}
{
  StatementExpressionList()
}

void BreakStatement() :
{}
{
  "break" [ <IDENTIFIER> ] ";"
}

void ContinueStatement() :
{}
{
  "continue" [ <IDENTIFIER> ] ";"
}

void ReturnStatement() :
{}
{
  "return"
  [
    LOOKAHEAD(1, <BOOLEAN> | <BYTE> | <CHAR> | <DOUBLE> | <FALSE> | <FLOAT> |
                 <INT> | <LONG> | <NEW> | <NULL> | <SHORT> | <SUPER> | <THIS> |
                 <TRUE> | <VOID> | <INTEGER_LITERAL> | <FLOATING_POINT_LITERAL> |
                 <CHARACTER_LITERAL> | <STRING_LITERAL> | <IDENTIFIER> | <LPAREN> |
                 <BANG> | <TILDE> | <INCR> | <DECR> | <PLUS> | <MINUS>)
    Expression()
  ]
  ";"
}

void ThrowStatement() :
{}
{
  "throw" Expression() ";"
}

void SynchronizedStatement() :
{}
{
  "synchronized" "(" Expression() ")" Block()
}

void TryStatement() :
/*
 * Semantic check required here to make sure that at least one
 * finally/catch is present.
 */
{}
{
  "try" Block()
  ( "catch" "(" FormalParameter() ")" Block() )*
  [ "finally" Block() ]
}