javaparser.all

JDK1.4编译器后端

  ;
InstanceInitializer instance_initializer =
    block.b                                    {: return new InstanceInitializer(b); :}
  ;
ConstructorDecl constructor_declaration =
    modifiers.m? IDENTIFIER LPAREN formal_parameter_list.pl? RPAREN throws.tl? constructor_body.b
    {: b.setModifiers(new Modifiers(m)); b.setID(IDENTIFIER); b.setParameterList(pl); b.setExceptionList(tl); return b; :}
 ;
ConstructorDecl constructor_body =
		LBRACE explicit_constructor_invocation.c? block_statements.l? RBRACE
    {: return new ConstructorDecl(new Modifiers(), "", new List(), new List(), c, new Block(l)); :}
	;
ExprStmt explicit_constructor_invocation =
    THIS LPAREN argument_list.l? RPAREN SEMICOLON 
    {: ConstructorAccess c = new ConstructorAccess("this", l);
       c.setStart(THIS.getStart());
       c.setEnd(RPAREN.getEnd());
       return new ExprStmt(c); :}
  | SUPER LPAREN argument_list.l? RPAREN SEMICOLON 
    {: SuperConstructorAccess c = new SuperConstructorAccess("super", l);
       c.setStart(SUPER.getStart());
       c.setEnd(RPAREN.getEnd());
       return new ExprStmt(c); :}
  | primary.p DOT SUPER LPAREN argument_list.l? RPAREN SEMICOLON
    {: SuperConstructorAccess c = new SuperConstructorAccess("super", l);
       c.setStart(SUPER.getStart());
       c.setEnd(RPAREN.getEnd());
       return new ExprStmt(p.qualifiesAccess(c)); :}
  | name.n DOT SUPER LPAREN argument_list.l? RPAREN SEMICOLON
    {: SuperConstructorAccess c = new SuperConstructorAccess("super", l);
       c.setStart(SUPER.getStart());
       c.setEnd(RPAREN.getEnd());
       return new ExprStmt(n.qualifiesAccess(c)); :}
  ;
InterfaceDecl interface_declaration =
  modifiers.m? INTERFACE IDENTIFIER extends_interfaces.i? interface_body.b {: return new InterfaceDecl(new Modifiers(m), IDENTIFIER, i, b); :}
  ;
List extends_interfaces =
    EXTENDS interface_type.i                    {: return new List().add(i); :}
  | extends_interfaces.l COMMA interface_type.i {: return l.add(i); :}
  ;
    
List interface_body =
    LBRACE interface_member_declarations.i? RBRACE  {: return i; :}
  ;   
List interface_member_declarations =
    interface_member_declaration.i                                  {: return new List().add(i); :}
  | interface_member_declarations.l interface_member_declaration.i  {: return l.add(i); :}
  ;
BodyDecl 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                                  {: return new StaticInitializer(new Block()); :}
  ;
BodyDecl constant_declaration =
    field_declaration.f                        {: return f; :}
  ;
BodyDecl abstract_method_declaration =
    method_header.m SEMICOLON                  {: return m; :}
  ;
ArrayInit array_initializer =
    LBRACE variable_initializers.v? COMMA? RBRACE   {: return new ArrayInit(v); :}
  ;
List variable_initializers =
    variable_initializer.v                                {: return new List().add(v); :}
  | variable_initializers.l COMMA variable_initializer.v  {: return l.add(v); :}
  ;
Block block =
    LBRACE block_statements.l? RBRACE {: return new Block(l); :}
  ;
List block_statements =
    block_statement.b                     {: return new List().add(b); :}
  | block_statements.l block_statement.b  {: return l.add(b); :}
  ;
Stmt block_statement =
    local_variable_declaration_statement.l  {: return l; :}
  | class_declaration.c                     {: return new LocalClassDeclStmt(c); :}
  | statement.s                             {: return s; :}
  ;
VarDeclStmt local_variable_declaration_statement =
    local_variable_declaration.l SEMICOLON  {: return l; :}
  ;
VarDeclStmt local_variable_declaration =
  modifiers.m? type.t variable_declarators.l {: return new VarDeclStmt(new Modifiers(m), t, l); :}
  ;
Stmt 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; :}
  ;
Stmt 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; :}
  ;
Stmt 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; :}
  ;
IfStmt if_then_statement =
    IF LPAREN expression.e RPAREN statement.s  {: return new IfStmt(e, s, new Opt()); :}
  ;
IfStmt if_then_else_statement =
    IF LPAREN expression.e RPAREN statement_no_short_if.t ELSE statement.els {: return new IfStmt(e, t, new Opt(els)); :}
  ;
IfStmt if_then_else_statement_no_short_if =
    IF LPAREN expression.e RPAREN statement_no_short_if.t ELSE statement_no_short_if.els {: return new IfStmt(e, t, new Opt(els)); :}
  ;
EmptyStmt empty_statement =
    SEMICOLON                                  {: return new EmptyStmt(); :}
  ;
LabeledStmt labeled_statement =
    IDENTIFIER.id COLON statement.s            {: return new LabeledStmt(id, s); :}
  ;
LabeledStmt labeled_statement_no_short_if =
    IDENTIFIER.id COLON statement_no_short_if.s {: return new LabeledStmt(id, s); :}
  ;
ExprStmt expression_statement =
    statement_expression.e SEMICOLON           {: return e; :}
  ;
ExprStmt 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); :}
  ;
SwitchStmt switch_statement =
    SWITCH LPAREN expression.e RPAREN switch_block.l {: return new SwitchStmt(e, l); :}
  ;
Block switch_block =
    LBRACE switch_block_statement_groups.l switch_labels.s RBRACE 
                        {: for(int ii = 0; ii < s.getNumChildNoTransform(); ii++) l.add(s.getChildNoTransform(ii)); return new Block(l); :}
  | LBRACE switch_block_statement_groups.l RBRACE   {: return new Block(l); :}
  | LBRACE switch_labels.l RBRACE              {: return new Block(l); :}
  | LBRACE RBRACE                              {: return new Block(new List()); :}
  ;
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; :}
  ;
List 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; :}
  ;
List switch_labels =
    switch_label.s                             {: return new List().add(s); :}
  | switch_labels.l switch_label.s             {: return l.add(s); :}
  ;
Case switch_label =
    CASE constant_expression.e COLON           {: return new ConstCase(e); :}
  | DEFAULT COLON                              {: return new DefaultCase(); :}
  ;
WhileStmt while_statement =
    WHILE LPAREN expression.e RPAREN statement.s {: return new WhileStmt(e, s); :}
  ;
WhileStmt while_statement_no_short_if =
    WHILE LPAREN expression.e RPAREN statement_no_short_if.s {: return new WhileStmt(e, s); :}
  ;
DoStmt do_statement =
    DO statement.s WHILE LPAREN expression.e RPAREN SEMICOLON {: return new DoStmt(s, e); :}
  ;
ForStmt for_statement =
    FOR LPAREN for_init.i? SEMICOLON expression.e? SEMICOLON for_update.u? RPAREN statement.s {: return new ForStmt(i, e, u, s); :}
  ;
ForStmt for_statement_no_short_if =
    FOR LPAREN for_init.i? SEMICOLON expression.e? SEMICOLON for_update.u? RPAREN statement_no_short_if.s {: return new ForStmt(i, e, u, s); :}
  ;
List for_init =
    statement_expression_list.l        {: return l; :}
  | local_variable_declaration.d       {: return new List().add(d); :};
List for_update =
    statement_expression_list.l        {: return l; :}
  ;
List statement_expression_list =
    statement_expression.e                                   {: return new List().add(e); :}
  | statement_expression_list.l COMMA statement_expression.e {: return l.add(e); :}
  ;
BreakStmt break_statement =
    BREAK IDENTIFIER.id SEMICOLON              {: return new BreakStmt(id); :}
  | BREAK               SEMICOLON              {: return new BreakStmt(""); :}
  ; 
ContinueStmt continue_statement =
    CONTINUE IDENTIFIER.id SEMICOLON           {: return new ContinueStmt(id); :}
  | CONTINUE               SEMICOLON           {: return new ContinueStmt(""); :}
  ;
ReturnStmt return_statement =
    RETURN expression.e? SEMICOLON              {: return new ReturnStmt(e); :}
  ;
ThrowStmt throw_statement =
    THROW expression.e SEMICOLON               {: return new ThrowStmt(e); :}
  ;
SynchronizedStmt synchronized_statement =
    SYNCHRONIZED LPAREN expression.e RPAREN block.b {: return new SynchronizedStmt(e, b); :}
  ;
TryStmt try_statement =
    TRY block.b catches.c                        {: return new TryStmt(b, c, new Opt()); :}
  | TRY block.b            finally.f             {: return new TryStmt(b, new List(), new Opt(f)); :}
  | TRY block.b catches.c  finally.f             {: return new TryStmt(b, c, new Opt(f)); :}
  ;
List catches =
    catch_clause.c                             {: return new List().add(c); :}
  | catches.l catch_clause.c                   {: return l.add(c); :}
  ;
CatchClause catch_clause =
    CATCH LPAREN formal_parameter.p RPAREN block.b {: return new CatchClause(p, b); :}
  ;
Block finally =
    FINALLY block.b {: return b; :}
  ;
AssertStmt assert_statement =
    ASSERT expression.e                    SEMICOLON {: return new AssertStmt(e, new Opt()); :}
  | ASSERT expression.e COLON expression.s SEMICOLON {: return new AssertStmt(e, new Opt(s)); :}
  ;
Expr primary =
    primary_no_new_array.p                     {: return p; :}
  | array_creation_init.a                      {: return a; :}
  | array_creation_uninit.a                    {: return a; :}
  ;

ClassAccess class_literal =
  CLASS {: return new ClassAccess(); :}
  ;

Expr primary_no_new_array =
    literal.l                                  {: return l; :}
  | primitive_type.n dims.d? DOT class_literal.c       {: return n.addArrayDims(d).qualifiesAccess(c); :}
  | name.n dims.d? DOT class_literal.c                 {: return n.addArrayDims(d).qualifiesAccess(c); :}
  | VOID DOT class_literal.c                   {: PrimitiveTypeAccess v = new PrimitiveTypeAccess("void");
                                                  v.setStart(VOID.getStart());
                                                  v.setEnd(VOID.getEnd());
                                                  return v.qualifiesAccess(c); :}
  | THIS                                       {: return new ThisAccess("this"); :}
  | name.n DOT THIS                            {: ThisAccess t = new ThisAccess("this");