javaparser.beaver

JDK1.4编译器后端

    class_or_interface_type.t {: return t;:}

  | array_type.t {: return t;:}
  ;
class_or_interface_type =
    name.n {: return n;:}
  ;
class_type =
    class_or_interface_type.n {: return n;:}
  ;
interface_type =
    class_or_interface_type.n {: return n;:}
  ;
array_type =
    primitive_type.t dims.d {: return t.addArrayDims(d);:}

  | name.n dims.d {: return n.addArrayDims(d);:}
  ;
name =
    simple_name.s {: return s;:}

  | qualified_name.q {: return q;:}
  ;
simple_name =
    IDENTIFIER.IDENTIFIER {: return new ParseName(IDENTIFIER);:}
  ;
qualified_name =
    name.n DOT.DOT simple_name.i {: return n.qualifiesAccess(i);:}
  ;
compilation_unit =
    package_declaration.p {: return new CompilationUnit(p.getID(), new List(), new List());:}

  | package_declaration.p import_declarations.i {: return new CompilationUnit(p.getID(), i, new List());:}

  | package_declaration.p type_declarations.t {: return new CompilationUnit(p.getID(), new List(), t);:}

  | package_declaration.p import_declarations.i type_declarations.t {: return new CompilationUnit(p.getID(), i, t);:}

  | {: return new CompilationUnit("", new List(), new List());:}

  | import_declarations.i {: return new CompilationUnit("", i, new List());:}

  | type_declarations.t {: return new CompilationUnit("", new List(), t);:}

  | import_declarations.i type_declarations.t {: return new CompilationUnit("", i, t);:}
  ;
import_declarations =
    import_declaration.i {: return new List().add(i);:}

  | import_declarations.l import_declaration.i {: return l.add(i);:}
  ;
type_declarations =
    type_declaration.t {: return !(t instanceof EmptyType) ? new List().add(t) : new List() ;:}

  | type_declarations.l type_declaration.t {: return !(t instanceof EmptyType) ? l.add(t) : l;:}
  ;
package_declaration =
    PACKAGE.PACKAGE name_decl.n SEMICOLON.SEMICOLON {: return n;:}
  ;
name_decl =
    simple_name_decl.s {: return s;:}

  | qualified_name_decl.q {: return q;:}
  ;
simple_name_decl =
    IDENTIFIER.IDENTIFIER {: return new IdUse(IDENTIFIER);:}
  ;
qualified_name_decl =
    name_decl.n DOT.DOT IDENTIFIER.i {: return new IdUse(n.getID() + "." + ((String)i.value));:}
  ;
import_declaration =
    single_type_import_declaration.s {: return s;:}

  | type_import_on_demand_declaration.t {: return t;:}
  ;
single_type_import_declaration =
    IMPORT.IMPORT name.n SEMICOLON.SEMICOLON {: return new SingleTypeImportDecl(n);:}
  ;
type_import_on_demand_declaration =
    IMPORT.IMPORT name.n DOT.DOT MULT.MULT SEMICOLON.SEMICOLON {: return new TypeImportOnDemandDecl(n);:}
  ;
type_declaration =
    class_declaration.c {: return c;:}

  | interface_declaration.i {: return i;:}

  | SEMICOLON.SEMICOLON {: return new EmptyType(new Modifiers(), "EmptyType", new Opt(), new List());:}
  ;
modifiers =
    modifier.m {: return new List().add(m);:}

  | modifiers.l modifier.m {: return l.add(m);:}
  ;
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");:}
  ;
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);:}
  ;
super =
    EXTENDS.EXTENDS class_type.c {: return new Opt(c);:}
  ;
interfaces =
    IMPLEMENTS.IMPLEMENTS interface_type_list.i {: return i;:}
  ;
interface_type_list =
    interface_type.i {: return new List().add(i);:}

  | interface_type_list.l COMMA.COMMA interface_type.i {: return l.add(i);:}
  ;
class_body =
    LBRACE.LBRACE class_body_declarations_opt.c RBRACE.RBRACE {: return c;:}
  ;
class_body_declarations =
    class_body_declaration.c {: return new List().add(c);:}

  | class_body_declarations.l class_body_declaration.c {: return l.add(c);:}
  ;
class_body_declaration =
    class_member_declaration.c {: return c;:}

  | instance_initializer.i {: return i;:}

  | static_initializer.si {: return si;:}

  | constructor_declaration.c {: return c;:}
  ;
class_member_declaration =
    field_declaration.f {: return f;:}

  | method_declaration.m {: return m;:}

  | class_declaration.c {: return new MemberClassDecl(c);:}

  | interface_declaration.i {: return new MemberInterfaceDecl(i);:}

  | SEMICOLON.SEMICOLON {: return new InstanceInitializer(new Block());:}
  ;
field_declaration =
    type.t variable_declarators.v SEMICOLON.SEMICOLON {: return new FieldDecl(new Modifiers(new List()), t, v);:}

  | modifiers.m type.t variable_declarators.v SEMICOLON.SEMICOLON {: return new FieldDecl(new Modifiers(m), t, v);:}
  ;
variable_declarators =
    variable_declarator.v {: return new List().add(v);:}

  | variable_declarators.l COMMA.COMMA variable_declarator.v {: return l.add(v);:}
  ;
variable_declarator =
    variable_declarator_id.v {: return v;:}

  | variable_declarator_id.v EQ.EQ variable_initializer.i {: v.setInit(i); return v;:}
  ;
variable_declarator_id =
    IDENTIFIER.IDENTIFIER dims_opt.d {: return new VariableDecl(IDENTIFIER, d, new Opt());:}
  ;
variable_initializer =
    expression.e {: return e;:}

  | array_initializer.a {: return a;:}
  ;
method_declaration =
    method_header.m method_body.b {: m.setBlockOpt(b); return m;:}
  ;
method_header =
    type.t IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN {: return new MethodDecl(new Modifiers(new List()), t.addArrayDims(new List()), IDENTIFIER, l, new List(), new Opt());:}

  | modifiers.m type.t IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN {: return new MethodDecl(new Modifiers(m), t.addArrayDims(new List()), IDENTIFIER, l, new List(), new Opt());:}

  | type.t IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN dims.d {: return new MethodDecl(new Modifiers(new List()), t.addArrayDims(d), IDENTIFIER, l, new List(), new Opt());:}

  | modifiers.m type.t IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN dims.d {: return new MethodDecl(new Modifiers(m), t.addArrayDims(d), IDENTIFIER, l, new List(), new Opt());:}

  | type.t IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN throws.tl {: return new MethodDecl(new Modifiers(new List()), t.addArrayDims(new List()), IDENTIFIER, l, tl, new Opt());:}

  | modifiers.m type.t IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN throws.tl {: return new MethodDecl(new Modifiers(m), t.addArrayDims(new List()), IDENTIFIER, l, tl, new Opt());:}

  | type.t IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN dims.d throws.tl {: return new MethodDecl(new Modifiers(new List()), t.addArrayDims(d), IDENTIFIER, l, tl, new Opt());:}

  | modifiers.m type.t IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN dims.d throws.tl {: return new MethodDecl(new Modifiers(m), t.addArrayDims(d), IDENTIFIER, l, tl, new Opt());:}

  | VOID.VOID IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN throws_opt.tl {: return new MethodDecl(new Modifiers(new List()), new PrimitiveTypeAccess("void"), IDENTIFIER, l, tl, new Opt());:}

  | modifiers.m VOID.VOID IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.l RPAREN.RPAREN throws_opt.tl {: return new MethodDecl(new Modifiers(m), new PrimitiveTypeAccess("void"), IDENTIFIER, l, tl, new Opt());:}
  ;
formal_parameter_list =
    formal_parameter.f {: return new List().add(f);:}

  | formal_parameter_list.l COMMA.COMMA formal_parameter.f {: return l.add(f);:}
  ;
formal_parameter =
    type.t IDENTIFIER.IDENTIFIER dims_opt.d {: return new ParameterDeclaration(new Modifiers(new List()), t.addArrayDims(d), IDENTIFIER);:}

  | modifiers.m type.t IDENTIFIER.IDENTIFIER dims_opt.d {: return new ParameterDeclaration(new Modifiers(m), t.addArrayDims(d), IDENTIFIER);:}
  ;
throws =
    THROWS.THROWS class_type_list.l {: return l;:}
  ;
class_type_list =
    class_type.c {: return new List().add(c);:}

  | class_type_list.l COMMA.COMMA class_type.c {: return l.add(c);:}
  ;
method_body =
    block.b {: return new Opt(b);:}

  | SEMICOLON.SEMICOLON {: return new Opt();:}
  ;
static_initializer =
    STATIC.STATIC block.b {: return new StaticInitializer(b);:}
  ;
instance_initializer =
    block.b {: return new InstanceInitializer(b);:}
  ;
constructor_declaration =
    IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.pl RPAREN.RPAREN constructor_body.b {: b.setModifiers(new Modifiers(new List())); b.setID(IDENTIFIER); b.setParameterList(pl); b.setExceptionList(new List()); return b;:}

  | modifiers.m IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.pl RPAREN.RPAREN constructor_body.b {: b.setModifiers(new Modifiers(m)); b.setID(IDENTIFIER); b.setParameterList(pl); b.setExceptionList(new List()); return b;:}

  | IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.pl RPAREN.RPAREN throws.tl constructor_body.b {: b.setModifiers(new Modifiers(new List())); b.setID(IDENTIFIER); b.setParameterList(pl); b.setExceptionList(tl); return b;:}

  | modifiers.m IDENTIFIER.IDENTIFIER LPAREN.LPAREN formal_parameter_list_opt.pl RPAREN.RPAREN throws.tl constructor_body.b {: b.setModifiers(new Modifiers(m)); b.setID(IDENTIFIER); b.setParameterList(pl); b.setExceptionList(tl); return b;:}
  ;
constructor_body =
    LBRACE.LBRACE RBRACE.RBRACE {: return new ConstructorDecl(new Modifiers(), "", new List(), new List(), new Opt(), new Block(new List()));:}

  | LBRACE.LBRACE explicit_constructor_invocation.c RBRACE.RBRACE {: return new ConstructorDecl(new Modifiers(), "", new List(), new List(), new Opt(c), new Block(new List()));:}

  | LBRACE.LBRACE block_statements.l RBRACE.RBRACE {: return new ConstructorDecl(new Modifiers(), "", new List(), new List(), new Opt(), new Block(l));:}

  | LBRACE.LBRACE explicit_constructor_invocation.c block_statements.l RBRACE.RBRACE {: return new ConstructorDecl(new Modifiers(), "", new List(), new List(), new Opt(c), new Block(l));:}
  ;
explicit_constructor_invocation =
    THIS.THIS LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN SEMICOLON.SEMICOLON {: ConstructorAccess c = new ConstructorAccess("this", l);
       c.setStart(THIS.getStart());
       c.setEnd(RPAREN.getEnd());
       return new ExprStmt(c);:}

  | SUPER.SUPER LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN SEMICOLON.SEMICOLON {: SuperConstructorAccess c = new SuperConstructorAccess("super", l);
       c.setStart(SUPER.getStart());
       c.setEnd(RPAREN.getEnd());
       return new ExprStmt(c);:}

  | primary.p DOT.DOT SUPER.SUPER LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN SEMICOLON.SEMICOLON {: SuperConstructorAccess c = new SuperConstructorAccess("super", l);
       c.setStart(SUPER.getStart());
       c.setEnd(RPAREN.getEnd());
       return new ExprStmt(p.qualifiesAccess(c));:}

  | name.n DOT.DOT SUPER.SUPER LPAREN.LPAREN argument_list_opt.l RPAREN.RPAREN SEMICOLON.SEMICOLON {: SuperConstructorAccess c = new SuperConstructorAccess("super", l);
       c.setStart(SUPER.getStart());
       c.setEnd(RPAREN.getEnd());
       return new ExprStmt(n.qualifiesAccess(c));:}
  ;
interface_declaration =
    INTERFACE.INTERFACE IDENTIFIER.IDENTIFIER interface_body.b {: return new InterfaceDecl(new Modifiers(new List()), IDENTIFIER, new List(), b);:}

  | modifiers.m INTERFACE.INTERFACE IDENTIFIER.IDENTIFIER interface_body.b {: return new InterfaceDecl(new Modifiers(m), IDENTIFIER, new List(), b);:}

  | INTERFACE.INTERFACE IDENTIFIER.IDENTIFIER extends_interfaces.i interface_body.b {: return new InterfaceDecl(new Modifiers(new List()), IDENTIFIER, i, b);:}

  | modifiers.m INTERFACE.INTERFACE IDENTIFIER.IDENTIFIER extends_interfaces.i interface_body.b {: return new InterfaceDecl(new Modifiers(m), IDENTIFIER, i, b);:}
  ;
extends_interfaces =
    EXTENDS.EXTENDS interface_type.i {: return new List().add(i);:}

  | extends_interfaces.l COMMA.COMMA interface_type.i {: return l.add(i);:}
  ;
interface_body =
    LBRACE.LBRACE interface_member_declarations_opt.i RBRACE.RBRACE {: return i;:}
  ;
interface_member_declarations =
    interface_member_declaration.i {: return new List().add(i);:}

  | interface_member_declarations.l interface_member_declaration.i {: return l.add(i);:}
  ;
interface_member_declaration =
    constant_declaration.c {: return c;:}

  | abstract_method_declaration.a {: return a;:}

  | class_declaration.c {: return new MemberClassDecl(c);:}

  | interface_declaration.i {: return new MemberInterfaceDecl(i);:}

  | SEMICOLON.SEMICOLON {: return new StaticInitializer(new Block());:}
  ;
constant_declaration =
    field_declaration.f {: return f;:}
  ;
abstract_method_declaration =
    method_header.m SEMICOLON.SEMICOLON {: return m;:}
  ;
array_initializer =
    LBRACE.LBRACE RBRACE.RBRACE {: return new ArrayInit(new List());:}

  | LBRACE.LBRACE variable_initializers.v RBRACE.RBRACE {: return new ArrayInit(v);:}

  | LBRACE.LBRACE COMMA.COMMA RBRACE.RBRACE {: return new ArrayInit(new List());:}

  | LBRACE.LBRACE variable_initializers.v COMMA.COMMA RBRACE.RBRACE {: return new ArrayInit(v);:}
  ;
variable_initializers =
    variable_initializer.v {: return new List().add(v);:}

  | variable_initializers.l COMMA.COMMA variable_initializer.v {: return l.add(v);:}
  ;
block =
    LBRACE.LBRACE block_statements_opt.l RBRACE.RBRACE {: return new Block(l);:}
  ;
block_statements =
    block_statement.b {: return new List().add(b);:}

  | block_statements.l block_statement.b {: return l.add(b);:}
  ;
block_statement =
    local_variable_declaration_statement.l {: return l;:}

  | class_declaration.c {: return new LocalClassDeclStmt(c);:}

  | statement.s {: return s;:}
  ;
local_variable_declaration_statement =