javaparser.beaver

JDK1.4编译器后端

                                                         a.setStart(LBRACK.getStart());
                                                         a.setEnd(RBRACK.getEnd());
                                                         return p.qualifiesAccess(a);:}
  ;
postfix_expression =
    primary.p {: return p;:}

  | name.n {: return n;:}

  | postincrement_expression.e {: return e;:}

  | postdecrement_expression.e {: return e;:}
  ;
postincrement_expression =
    postfix_expression.e PLUSPLUS.PLUSPLUS {: return new PostIncExpr(e);:}
  ;
postdecrement_expression =
    postfix_expression.e MINUSMINUS.MINUSMINUS {: return new PostDecExpr(e);:}
  ;
unary_expression =
    preincrement_expression.e {: return e;:}

  | predecrement_expression.e {: return e;:}

  | PLUS.PLUS unary_expression.e {: return new PlusExpr(e);:}

  | MINUS.MINUS unary_expression.e {: return new MinusExpr(e);:}

  | unary_expression_not_plus_minus.e {: return e;:}
  ;
preincrement_expression =
    PLUSPLUS.PLUSPLUS unary_expression.e {: return new PreIncExpr(e);:}
  ;
predecrement_expression =
    MINUSMINUS.MINUSMINUS unary_expression.e {: return new PreDecExpr(e);:}
  ;
unary_expression_not_plus_minus =
    postfix_expression.e {: return e;:}

  | COMP.COMP unary_expression.e {: return new BitNotExpr(e);:}

  | NOT.NOT unary_expression.e {: return new LogNotExpr(e);:}

  | cast_expression.e {: return e;:}
  ;
cast_expression =
    LPAREN.LPAREN primitive_type.t RPAREN.RPAREN unary_expression.e {: return new CastExpr(t.addArrayDims(new List()), e);:}

  | LPAREN.LPAREN primitive_type.t dims.d RPAREN.RPAREN unary_expression.e {: return new CastExpr(t.addArrayDims(d), e);:}

  | LPAREN.LPAREN name.n RPAREN.RPAREN unary_expression_not_plus_minus.e {: return new CastExpr(n.addArrayDims(new List()), e);:}

  | LPAREN.LPAREN name.n dims.d RPAREN.RPAREN unary_expression_not_plus_minus.e {: return new CastExpr(n.addArrayDims(d), e);:}
  ;
multiplicative_expression =
    unary_expression.e {: return e;:}

  | multiplicative_expression.e1 MULT.MULT unary_expression.e2 {: return new MulExpr(e1, e2);:}

  | multiplicative_expression.e1 DIV.DIV unary_expression.e2 {: return new DivExpr(e1, e2);:}

  | multiplicative_expression.e1 MOD.MOD unary_expression.e2 {: return new ModExpr(e1, e2);:}
  ;
additive_expression =
    multiplicative_expression.e {: return e;:}

  | additive_expression.e1 PLUS.PLUS multiplicative_expression.e2 {: return new AddExpr(e1, e2);:}

  | additive_expression.e1 MINUS.MINUS multiplicative_expression.e2 {: return new SubExpr(e1, e2);:}
  ;
shift_expression =
    additive_expression.e {: return e;:}

  | shift_expression.e1 LSHIFT.LSHIFT additive_expression.e2 {: return new LShiftExpr(e1, e2);:}

  | shift_expression.e1 RSHIFT.RSHIFT additive_expression.e2 {: return new RShiftExpr(e1, e2);:}

  | shift_expression.e1 URSHIFT.URSHIFT additive_expression.e2 {: return new URShiftExpr(e1, e2);:}
  ;
relational_expression =
    shift_expression.e {: return e;:}

  | relational_expression.e1 LT.LT shift_expression.e2 {: return new LTExpr(e1, e2);:}

  | relational_expression.e1 GT.GT shift_expression.e2 {: return new GTExpr(e1, e2);:}

  | relational_expression.e1 LTEQ.LTEQ shift_expression.e2 {: return new LEExpr(e1, e2);:}

  | relational_expression.e1 GTEQ.GTEQ shift_expression.e2 {: return new GEExpr(e1, e2);:}

  | relational_expression.e INSTANCEOF.INSTANCEOF reference_type.t {: return new InstanceOfExpr(e, t);:}
  ;
equality_expression =
    relational_expression.e {: return e;:}

  | equality_expression.e1 EQEQ.EQEQ relational_expression.e2 {: return new EQExpr(e1, e2);:}

  | equality_expression.e1 NOTEQ.NOTEQ relational_expression.e2 {: return new NEExpr(e1, e2);:}
  ;
and_expression =
    equality_expression.e {: return e;:}

  | and_expression.e1 AND.AND equality_expression.e2 {: return new AndBitwiseExpr(e1, e2);:}
  ;
exclusive_or_expression =
    and_expression.e {: return e;:}

  | exclusive_or_expression.e1 XOR.XOR and_expression.e2 {: return new XorBitwiseExpr(e1, e2);:}
  ;
inclusive_or_expression =
    exclusive_or_expression.e {: return e;:}

  | inclusive_or_expression.e1 OR.OR exclusive_or_expression.e2 {: return new OrBitwiseExpr(e1, e2);:}
  ;
conditional_and_expression =
    inclusive_or_expression.e {: return e;:}

  | conditional_and_expression.e1 ANDAND.ANDAND inclusive_or_expression.e2 {: return new AndLogicalExpr(e1, e2);:}
  ;
conditional_or_expression =
    conditional_and_expression.e {: return e;:}

  | conditional_or_expression.e1 OROR.OROR conditional_and_expression.e2 {: return new OrLogicalExpr(e1, e2);:}
  ;
conditional_expression =
    conditional_or_expression.c {: return c;:}

  | conditional_or_expression.c QUESTION.QUESTION expression.e1 COLON.COLON conditional_expression.e2 {: return new ConditionalExpr(c, e1, e2);:}
  ;
assignment_expression =
    conditional_expression.c {: return c;:}

  | assignment.a {: return a;:}
  ;
assignment =
    postfix_expression.dest EQ.EQ assignment_expression.source {: return new AssignSimpleExpr(dest, source);:}

  | postfix_expression.dest MULTEQ.MULTEQ assignment_expression.source {: return new AssignMulExpr(dest, source);:}

  | postfix_expression.dest DIVEQ.DIVEQ assignment_expression.source {: return new AssignDivExpr(dest, source);:}

  | postfix_expression.dest MODEQ.MODEQ assignment_expression.source {: return new AssignModExpr(dest, source);:}

  | postfix_expression.dest PLUSEQ.PLUSEQ assignment_expression.source {: return new AssignPlusExpr(dest, source);:}

  | postfix_expression.dest MINUSEQ.MINUSEQ assignment_expression.source {: return new AssignMinusExpr(dest, source);:}

  | postfix_expression.dest LSHIFTEQ.LSHIFTEQ assignment_expression.source {: return new AssignLShiftExpr(dest, source);:}

  | postfix_expression.dest RSHIFTEQ.RSHIFTEQ assignment_expression.source {: return new AssignRShiftExpr(dest, source);:}

  | postfix_expression.dest URSHIFTEQ.URSHIFTEQ assignment_expression.source {: return new AssignURShiftExpr(dest, source);:}

  | postfix_expression.dest ANDEQ.ANDEQ assignment_expression.source {: return new AssignAndExpr(dest, source);:}

  | postfix_expression.dest XOREQ.XOREQ assignment_expression.source {: return new AssignXorExpr(dest, source);:}

  | postfix_expression.dest OREQ.OREQ assignment_expression.source {: return new AssignOrExpr(dest, source);:}
  ;
expression =
    assignment_expression.a {: return a;:}
  ;
constant_expression =
    expression.e {: return e;:}
  ;
class_body_declaration =
    error.error SEMICOLON.SEMICOLON {: return new InstanceInitializer(new Block());:}

  | error.error LBRACE.LBRACE {: return new InstanceInitializer(new Block());:}
  ;
block =
    error.error RBRACE.RBRACE {: return new Block(new List());:}
  ;
statement =
    error.error SEMICOLON.SEMICOLON {: return new EmptyStmt();:}
  ;


























































block_statements_opt =
    {: return new List(); :}
  | block_statements.n {: return n; :}
  ;

expression_opt =
    {: return new Opt(); :}
  | expression.n {: return new Opt(n); :}
  ;
















interface_member_declarations_opt =
    {: return new List(); :}
  | interface_member_declarations.n {: return n; :}
  ;

throws_opt =
    {: return new List(); :}
  | throws.n {: return n; :}
  ;











for_init_opt =
    {: return new List(); :}
  | for_init.n {: return n; :}
  ;






argument_list_opt =
    {: return new List(); :}
  | argument_list.n {: return n; :}
  ;







formal_parameter_list_opt =
    {: return new List(); :}
  | formal_parameter_list.n {: return n; :}
  ;






for_update_opt =
    {: return new List(); :}
  | for_update.n {: return n; :}
  ;


















dims_opt =
    {: return new List(); :}
  | dims.n {: return n; :}
  ;









class_body_declarations_opt =
    {: return new List(); :}
  | class_body_declarations.n {: return n; :}
  ;