javaparser.beaver

JDK1.4编译器前端

  ;
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();:}
  ;
type_declaration =
    class_declaration.c {: return c;:}

  | interface_declaration.i {: return i;:}

  | granule_declaration.g {: return g;:}

  | shadow_class_declaration.s {: return s;:}

  | SEMICOLON.SEMICOLON {: return new EmptyType(new Modifiers(), "EmptyType", new Opt(), new List());:}
  ;
granule_type =
    name.n {: return n;:}
  ;
granule_declaration =
    GRANULE.GRANULE IDENTIFIER.IDENTIFIER super_opt.s LPAREN.LPAREN class_type.c RPAREN.RPAREN class_body.b {: return new GranuleDecl(new Modifiers(new List()), IDENTIFIER, s, c, b);:}

  | modifiers.m GRANULE.GRANULE IDENTIFIER.IDENTIFIER super_opt.s LPAREN.LPAREN class_type.c RPAREN.RPAREN class_body.b {: return new GranuleDecl(new Modifiers(m), IDENTIFIER, s, c, b);:}
  ;
class_declaration =
    CLASS.CLASS IDENTIFIER.IDENTIFIER class_body.b {: return new ClassDecl(new Modifiers(new List()), IDENTIFIER, new Opt(), new List(), b);:}

  | modifiers.m CLASS.CLASS IDENTIFIER.IDENTIFIER class_body.b {: return new ClassDecl(new Modifiers(m), IDENTIFIER, new Opt(), new List(), b);:}

  | CLASS.CLASS IDENTIFIER.IDENTIFIER super.s class_body.b {: return new ClassDecl(new Modifiers(new List()), IDENTIFIER, s, new List(), b);:}

  | modifiers.m CLASS.CLASS IDENTIFIER.IDENTIFIER super.s class_body.b {: return new ClassDecl(new Modifiers(m), IDENTIFIER, s, new List(), b);:}

  | CLASS.CLASS IDENTIFIER.IDENTIFIER interfaces.i class_body.b {: return new ClassDecl(new Modifiers(new List()), IDENTIFIER, new Opt(), i, b);:}

  | modifiers.m CLASS.CLASS IDENTIFIER.IDENTIFIER interfaces.i class_body.b {: return new ClassDecl(new Modifiers(m), IDENTIFIER, new Opt(), i, b);:}

  | CLASS.CLASS IDENTIFIER.IDENTIFIER super.s interfaces.i class_body.b {: return new ClassDecl(new Modifiers(new List()), IDENTIFIER, s, i, b);:}

  | modifiers.m CLASS.CLASS IDENTIFIER.IDENTIFIER super.s interfaces.i class_body.b {: return new ClassDecl(new Modifiers(m), IDENTIFIER, s, i, b);:}
  ;
shadow_class_declaration =
    CLASS.CLASS IDENTIFIER.IDENTIFIER IN.IN granule_type.g class_body.b {: return new ShadowClassDecl(new Modifiers(new List()), IDENTIFIER,g, new Opt(), new List(), b);:}

  | modifiers.m CLASS.CLASS IDENTIFIER.IDENTIFIER IN.IN granule_type.g class_body.b {: return new ShadowClassDecl(new Modifiers(m), IDENTIFIER,g, new Opt(), new List(), b);:}

  | CLASS.CLASS IDENTIFIER.IDENTIFIER IN.IN granule_type.g super.s class_body.b {: return new ShadowClassDecl(new Modifiers(new List()), IDENTIFIER,g, s, new List(), b);:}

  | modifiers.m CLASS.CLASS IDENTIFIER.IDENTIFIER IN.IN granule_type.g super.s class_body.b {: return new ShadowClassDecl(new Modifiers(m), IDENTIFIER,g, s, new List(), b);:}

  | CLASS.CLASS IDENTIFIER.IDENTIFIER IN.IN granule_type.g interfaces.i class_body.b {: return new ShadowClassDecl(new Modifiers(new List()), IDENTIFIER,g, new Opt(), i, b);:}

  | modifiers.m CLASS.CLASS IDENTIFIER.IDENTIFIER IN.IN granule_type.g interfaces.i class_body.b {: return new ShadowClassDecl(new Modifiers(m), IDENTIFIER,g, new Opt(), i, b);:}

  | CLASS.CLASS IDENTIFIER.IDENTIFIER IN.IN granule_type.g super.s interfaces.i class_body.b {: return new ShadowClassDecl(new Modifiers(new List()), IDENTIFIER,g, s, i, b);:}

  | modifiers.m CLASS.CLASS IDENTIFIER.IDENTIFIER IN.IN granule_type.g super.s interfaces.i class_body.b {: return new ShadowClassDecl(new Modifiers(m), IDENTIFIER,g, s, i, b);:}
  ;
modifier =
    PUBLIC.PUBLIC {: return new Modifier("public");:}

  | PROTECTED.PROTECTED {: return new Modifier("protected");:}

  | PRIVATE.PRIVATE {: return new Modifier("private");:}

  | STATIC.STATIC {: return new Modifier("static");:}

  | ABSTRACT.ABSTRACT {: return new Modifier("abstract");:}

  | FINAL.FINAL {: return new Modifier("final");:}

  | NATIVE.NATIVE {: return new Modifier("native");:}

  | SYNCHRONIZED.SYNCHRONIZED {: return new Modifier("synchronized");:}

  | TRANSIENT.TRANSIENT {: return new Modifier("transient");:}

  | VOLATILE.VOLATILE {: return new Modifier("volatile");:}

  | STRICTFP.STRICTFP {: return new Modifier("strictfp");:}

  | EXTERNAL.EXTERNAL {: return new Modifier("external");:}
  ;




























































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; :}
  ;

super_opt =
    {: return new Opt(); :}
  | super.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; :}
  ;