javaparser.beaver

JDK1.4编译器后端

    local_variable_declaration.l SEMICOLON.SEMICOLON {: return l;:}
  ;
local_variable_declaration =
    type.t variable_declarators.l {: return new VarDeclStmt(new Modifiers(new List()), t, l);:}

  | modifiers.m type.t variable_declarators.l {: return new VarDeclStmt(new Modifiers(m), t, l);:}
  ;
statement =
    statement_without_trailing_substatement.s {: return s;:}

  | labeled_statement.l {: return l;:}

  | if_then_statement.i {: return i;:}

  | if_then_else_statement.i {: return i;:}

  | while_statement.w {: return w;:}

  | for_statement.f {: return f;:}
  ;
statement_without_trailing_substatement =
    block.b {: return b;:}

  | empty_statement.e {: return e;:}

  | expression_statement.e {: return e;:}

  | switch_statement.s {: return s;:}

  | do_statement.d {: return d;:}

  | break_statement.b {: return b;:}

  | continue_statement.c {: return c;:}

  | return_statement.r {: return r;:}

  | synchronized_statement.s {: return s;:}

  | throw_statement.t {: return t;:}

  | try_statement.t {: return t;:}

  | assert_statement.a {: return a;:}
  ;
statement_no_short_if =
    statement_without_trailing_substatement.s {: return s;:}

  | labeled_statement_no_short_if.l {: return l;:}

  | if_then_else_statement_no_short_if.i {: return i;:}

  | while_statement_no_short_if.w {: return w;:}

  | for_statement_no_short_if.f {: return f;:}
  ;
if_then_statement =
    IF.IF LPAREN.LPAREN expression.e RPAREN.RPAREN statement.s {: return new IfStmt(e, s, new Opt());:}
  ;
if_then_else_statement =
    IF.IF LPAREN.LPAREN expression.e RPAREN.RPAREN statement_no_short_if.t ELSE.ELSE statement.els {: return new IfStmt(e, t, new Opt(els));:}
  ;
if_then_else_statement_no_short_if =
    IF.IF LPAREN.LPAREN expression.e RPAREN.RPAREN statement_no_short_if.t ELSE.ELSE statement_no_short_if.els {: return new IfStmt(e, t, new Opt(els));:}
  ;
empty_statement =
    SEMICOLON.SEMICOLON {: return new EmptyStmt();:}
  ;
labeled_statement =
    IDENTIFIER.id COLON.COLON statement.s {: return new LabeledStmt(((String)id.value), s);:}
  ;
labeled_statement_no_short_if =
    IDENTIFIER.id COLON.COLON statement_no_short_if.s {: return new LabeledStmt(((String)id.value), s);:}
  ;
expression_statement =
    statement_expression.e SEMICOLON.SEMICOLON {: return e;:}
  ;
statement_expression =
    assignment.a {: return new ExprStmt(a);:}

  | preincrement_expression.e {: return new ExprStmt(e);:}

  | predecrement_expression.e {: return new ExprStmt(e);:}

  | postincrement_expression.e {: return new ExprStmt(e);:}

  | postdecrement_expression.e {: return new ExprStmt(e);:}

  | method_invocation.i {: return new ExprStmt(i);:}

  | class_instance_creation_expression.e {: return new ExprStmt(e);:}
  ;
switch_statement =
    SWITCH.SWITCH LPAREN.LPAREN expression.e RPAREN.RPAREN switch_block.l {: return new SwitchStmt(e, l);:}
  ;
switch_block =
    LBRACE.LBRACE switch_block_statement_groups.l switch_labels.s RBRACE.RBRACE {: for(int ii = 0; ii < s.getNumChildNoTransform(); ii++) l.add(s.getChildNoTransform(ii)); return new Block(l);:}

  | LBRACE.LBRACE switch_block_statement_groups.l RBRACE.RBRACE {: return new Block(l);:}

  | LBRACE.LBRACE switch_labels.l RBRACE.RBRACE {: return new Block(l);:}

  | LBRACE.LBRACE RBRACE.RBRACE {: return new Block(new List());:}
  ;
switch_block_statement_groups =
    switch_block_statement_group.g {: return g;:}

  | switch_block_statement_groups.l switch_block_statement_group.g {: for(int ii = 0; ii < g.getNumChildNoTransform(); ii++)
           l.add(g.getChildNoTransform(ii));
         return l;:}
  ;
switch_block_statement_group =
    switch_labels.l block_statements.bl {: for(int ii = 0; ii < bl.getNumChildNoTransform(); ii++)
          l.add(bl.getChildNoTransform(ii));
          return l;:}
  ;
switch_labels =
    switch_label.s {: return new List().add(s);:}

  | switch_labels.l switch_label.s {: return l.add(s);:}
  ;
switch_label =
    CASE.CASE constant_expression.e COLON.COLON {: return new ConstCase(e);:}

  | DEFAULT.DEFAULT COLON.COLON {: return new DefaultCase();:}
  ;
while_statement =
    WHILE.WHILE LPAREN.LPAREN expression.e RPAREN.RPAREN statement.s {: return new WhileStmt(e, s);:}
  ;
while_statement_no_short_if =
    WHILE.WHILE LPAREN.LPAREN expression.e RPAREN.RPAREN statement_no_short_if.s {: return new WhileStmt(e, s);:}
  ;
do_statement =
    DO.DO statement.s WHILE.WHILE LPAREN.LPAREN expression.e RPAREN.RPAREN SEMICOLON.SEMICOLON {: return new DoStmt(s, e);:}
  ;
for_statement =
    FOR.FOR LPAREN.LPAREN for_init_opt.i SEMICOLON.SEMICOLON expression_opt.e SEMICOLON.SEMICOLON_ for_update_opt.u RPAREN.RPAREN statement.s {: return new ForStmt(i, e, u, s);:}
  ;
for_statement_no_short_if =
    FOR.FOR LPAREN.LPAREN for_init_opt.i SEMICOLON.SEMICOLON expression_opt.e SEMICOLON.SEMICOLON_ for_update_opt.u RPAREN.RPAREN statement_no_short_if.s {: return new ForStmt(i, e, u, s);:}
  ;
for_init =
    statement_expression_list.l {: return l;:}

  | local_variable_declaration.d {: return new List().add(d);:}
  ;
for_update =
    statement_expression_list.l {: return l;:}
  ;
statement_expression_list =
    statement_expression.e {: return new List().add(e);:}

  | statement_expression_list.l COMMA.COMMA statement_expression.e {: return l.add(e);:}
  ;
break_statement =
    BREAK.BREAK IDENTIFIER.id SEMICOLON.SEMICOLON {: return new BreakStmt(((String)id.value));:}

  | BREAK.BREAK SEMICOLON.SEMICOLON {: return new BreakStmt("");:}
  ;
continue_statement =
    CONTINUE.CONTINUE IDENTIFIER.id SEMICOLON.SEMICOLON {: return new ContinueStmt(((String)id.value));:}

  | CONTINUE.CONTINUE SEMICOLON.SEMICOLON {: return new ContinueStmt("");:}
  ;
return_statement =
    RETURN.RETURN expression_opt.e SEMICOLON.SEMICOLON {: return new ReturnStmt(e);:}
  ;
throw_statement =
    THROW.THROW expression.e SEMICOLON.SEMICOLON {: return new ThrowStmt(e);:}
  ;
synchronized_statement =
    SYNCHRONIZED.SYNCHRONIZED LPAREN.LPAREN expression.e RPAREN.RPAREN block.b {: return new SynchronizedStmt(e, b);:}
  ;
try_statement =
    TRY.TRY block.b catches.c {: return new TryStmt(b, c, new Opt());:}

  | TRY.TRY block.b finally.f {: return new TryStmt(b, new List(), new Opt(f));:}

  | TRY.TRY block.b catches.c finally.f {: return new TryStmt(b, c, new Opt(f));:}
  ;
catches =
    catch_clause.c {: return new List().add(c);:}

  | catches.l catch_clause.c {: return l.add(c);:}
  ;
catch_clause =
    CATCH.CATCH LPAREN.LPAREN formal_parameter.p RPAREN.RPAREN block.b {: return new CatchClause(p, b);:}
  ;
finally =
    FINALLY.FINALLY block.b {: return b;:}
  ;
assert_statement =
    ASSERT.ASSERT expression.e SEMICOLON.SEMICOLON {: return new AssertStmt(e, new Opt());:}

  | ASSERT.ASSERT expression.e COLON.COLON expression.s SEMICOLON.SEMICOLON {: return new AssertStmt(e, new Opt(s));:}
  ;
primary =
    primary_no_new_array.p {: return p;:}

  | array_creation_init.a {: return a;:}

  | array_creation_uninit.a {: return a;:}
  ;
class_literal =
    CLASS.CLASS {: return new ClassAccess();:}
  ;
primary_no_new_array =
    literal.l {: return l;:}

  | primitive_type.n DOT.DOT class_literal.c {: return n.addArrayDims(new List()).qualifiesAccess(c);:}

  | primitive_type.n dims.d DOT.DOT class_literal.c {: return n.addArrayDims(d).qualifiesAccess(c);:}

  | name.n DOT.DOT class_literal.c {: return n.addArrayDims(new List()).qualifiesAccess(c);:}

  | name.n dims.d DOT.DOT class_literal.c {: return n.addArrayDims(d).qualifiesAccess(c);:}

  | VOID.VOID DOT.DOT class_literal.c {: PrimitiveTypeAccess v = new PrimitiveTypeAccess("void");
                                                  v.setStart(VOID.getStart());
                                                  v.setEnd(VOID.getEnd());
                                                  return v.qualifiesAccess(c);:}

  | THIS.THIS {: return new ThisAccess("this");:}

  | name.n DOT.DOT THIS.THIS {: ThisAccess t = new ThisAccess("this");
                                                  t.setStart(THIS.getStart()); t.setEnd(THIS.getEnd());
                                                  return n.qualifiesAccess(t);:}

  | LPAREN.LPAREN expression.e RPAREN.RPAREN {: return new ParExpr(e);:}

  | LPAREN.LPAREN name.n RPAREN.RPAREN {: return new ParExpr(n);:}

  | class_instance_creation_expression.c {: return c;:}

  | field_access.f {: return f;:}

  | method_invocation.m {: return m;:}

  | array_access.a {: return a;:}
  ;
class_instance_creation_expression =
    NEW.NEW class_or_interface_type.t LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN {: return new ClassInstanceExpr(t, l, new Opt());:}

  | primary.n DOT.DOT NEW.NEW simple_name.id LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN {: ClassInstanceExpr e = new ClassInstanceExpr(id, l, new Opt());
       e.setStart(NEW.getStart());
       e.setEnd(RPAREN.getEnd());
       return n.qualifiesAccess(e);:}

  | name.n DOT.DOT NEW.NEW simple_name.id LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN {: ClassInstanceExpr e = new ClassInstanceExpr(id, l, new Opt());
       e.setStart(NEW.getStart());
       e.setEnd(RPAREN.getEnd());
       return n.qualifiesAccess(e);:}

  | NEW.NEW class_or_interface_type.t LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN subclass_body.b {: return new ClassInstanceExpr(t, l, b);:}

  | primary.n DOT.DOT NEW.NEW simple_name.id LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN subclass_body.b {: ClassInstanceExpr e = new ClassInstanceExpr(id, l, b);
       e.setStart(NEW.getStart());
       e.setEnd(b.getEnd());
       return n.qualifiesAccess(e);:}

  | name.n DOT.DOT NEW.NEW simple_name.id LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN subclass_body.b {: ClassInstanceExpr e = new ClassInstanceExpr(id, l, b);
       e.setStart(NEW.getStart());
       e.setEnd(b.getEnd());
       return n.qualifiesAccess(e);:}
  ;
subclass_body =
    class_body.b {: return new Opt(new AnonymousDecl(new Modifiers(), "Anonymous", b));:}
  ;
argument_list =
    expression.e {: return new List().add(e);:}

  | argument_list.l COMMA.COMMA expression.e {: return l.add(e);:}
  ;
array_creation_uninit =
    NEW.NEW primitive_type.t dim_exprs.d {: return new ArrayCreationExpr(t.addArrayDims(d), new Opt());:}

  | NEW.NEW primitive_type.t dim_exprs.d dims.e {: return new ArrayCreationExpr(t.addArrayDims(d).addArrayDims(e), new Opt());:}

  | NEW.NEW class_or_interface_type.t dim_exprs.d {: return new ArrayCreationExpr(t.addArrayDims(d), new Opt());:}

  | NEW.NEW class_or_interface_type.t dim_exprs.d dims.e {: return new ArrayCreationExpr(t.addArrayDims(d).addArrayDims(e), new Opt());:}
  ;
array_creation_init =
    NEW.NEW primitive_type.t dims.d array_initializer.i {: return new ArrayCreationExpr(t.addArrayDims(d), new Opt(i));:}

  | NEW.NEW class_or_interface_type.t dims.d array_initializer.i {: return new ArrayCreationExpr(t.addArrayDims(d), new Opt(i));:}
  ;
dim_exprs =
    dim_expr.e {: return new List().add(e);:}

  | dim_exprs.l dim_expr.e {: return l.add(e);:}
  ;
dim_expr =
    LBRACK.LBRACK expression.e RBRACK.RBRACK {: return new Dims(new Opt(e));:}
  ;
dims =
    LBRACK.LBRACK RBRACK.RBRACK {: return new List().add(new Dims(new Opt()));:}

  | dims.l LBRACK.LBRACK RBRACK.RBRACK {: return l.add(new Dims(new Opt()));:}
  ;
field_access =
    primary.p DOT.DOT simple_name.id {: return p.qualifiesAccess(id);:}

  | SUPER.SUPER DOT.DOT simple_name.id {: SuperAccess s = new SuperAccess("super");
       s.setStart(SUPER.getStart());
       s.setEnd(SUPER.getEnd());
       return s.qualifiesAccess(id);:}

  | name.n DOT.DOT SUPER.SUPER DOT.DOT_ simple_name.id {: SuperAccess s = new SuperAccess("super");
       s.setStart(SUPER.getStart());
       s.setEnd(SUPER.getEnd());
       return n.qualifiesAccess(s).qualifiesAccess(id);:}
  ;
method_invocation =
    name.n LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN {: if(n instanceof AbstractDot) {    
                                                               AbstractDot d = (AbstractDot)n; 
                                                               ParseName pn = (ParseName)d.extractLast();
                                                               MethodAccess m = new MethodAccess(pn.getID(), l);
                                                               m.setStart(n.getStart()); // add location information
                                                               m.setEnd(RPAREN.getEnd()); // add location information
                                                               d.replaceLast(m);
                                                               return d;
                                                             }
                                                             else {
                                                               ParseName pn = (ParseName)n;
                                                               return new MethodAccess(pn.getID(), l);
                                                             }:}

  | primary.p DOT.DOT IDENTIFIER.IDENTIFIER LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN {: MethodAccess m = new MethodAccess(IDENTIFIER, l);
        m.setStart(IDENTIFIER.getStart()); // add location information
        m.setEnd(RPAREN.getEnd()); // add location information
        return p.qualifiesAccess(m);:}

  | SUPER.SUPER DOT.DOT IDENTIFIER.IDENTIFIER LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN {: SuperAccess s = new SuperAccess("super");
        s.setStart(SUPER.getStart());
        s.setEnd(SUPER.getEnd());
        MethodAccess m = new MethodAccess(IDENTIFIER, l);
        m.setStart(IDENTIFIER.getStart());
        m.setEnd(RPAREN.getEnd());
        return s.qualifiesAccess(m);:}

  | name.n DOT.DOT SUPER.SUPER DOT.DOT_ IDENTIFIER.IDENTIFIER LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN {: SuperAccess s = new SuperAccess("super");
        s.setStart(SUPER.getStart());
        s.setEnd(SUPER.getEnd());
        MethodAccess m = new MethodAccess(IDENTIFIER, l);
        m.setStart(IDENTIFIER.getStart());
        m.setEnd(RPAREN.getEnd());
        return n.qualifiesAccess(s).qualifiesAccess(m);:}
  ;
array_access =
    name.n LBRACK.LBRACK expression.e RBRACK.RBRACK {: ArrayAccess a = new ArrayAccess(e);
                                                         a.setStart(LBRACK.getStart());
                                                         a.setEnd(RBRACK.getEnd());
                                                         return n.qualifiesAccess(a);:}

  | primary_no_new_array.p LBRACK.LBRACK expression.e RBRACK.RBRACK {: ArrayAccess a = new ArrayAccess(e);