javaparser.all

JDK1.4编译器前端

       e.setEnd(b.getEnd());
       return n.qualifiesAccess(e); :}
  ;
Opt subclass_body =
    class_body.b                               {: return new Opt(new AnonymousDecl(new Modifiers(), "Anonymous", b)); :}
  ;

List argument_list =
    expression.e                               {: return new List().add(e); :}
  | argument_list.l COMMA expression.e         {: return l.add(e); :}
  ;

Expr array_creation_uninit =
    NEW primitive_type.t dim_exprs.d           {: return new ArrayCreationExpr(t.addArrayDims(d), new Opt()); :}
  | NEW primitive_type.t dim_exprs.d dims.e    {: return new ArrayCreationExpr(t.addArrayDims(d).addArrayDims(e), new Opt()); :}
  | NEW class_or_interface_type.t dim_exprs.d  {: return new ArrayCreationExpr(t.addArrayDims(d), new Opt()); :}
  | NEW class_or_interface_type.t dim_exprs.d dims.e {: return new ArrayCreationExpr(t.addArrayDims(d).addArrayDims(e), new Opt()); :}
  ;
Expr array_creation_init =
    NEW primitive_type.t dims.d array_initializer.i           {: return new ArrayCreationExpr(t.addArrayDims(d), new Opt(i)); :}
  | NEW class_or_interface_type.t dims.d array_initializer.i  {: return new ArrayCreationExpr(t.addArrayDims(d), new Opt(i)); :}
  ;
List dim_exprs =
    dim_expr.e                                 {: return new List().add(e); :}
  | dim_exprs.l dim_expr.e                     {: return l.add(e); :}
  ;
Dims dim_expr =
    LBRACK expression.e RBRACK                 {: return new Dims(new Opt(e)); :}
  ;
List dims =
    LBRACK RBRACK                              {: return new List().add(new Dims(new Opt())); :}
  | dims.l LBRACK RBRACK                       {: return l.add(new Dims(new Opt())); :}
  ;

Access field_access =
    primary.p DOT simple_name.id                {: return p.qualifiesAccess(id); :}
  | SUPER DOT simple_name.id 
    {: SuperAccess s = new SuperAccess("super");
       s.setStart(SUPER.getStart());
       s.setEnd(SUPER.getEnd());
       return s.qualifiesAccess(id); :}
  | name.n DOT SUPER DOT simple_name.id
    {: SuperAccess s = new SuperAccess("super");
       s.setStart(SUPER.getStart());
       s.setEnd(SUPER.getEnd());
       return n.qualifiesAccess(s).qualifiesAccess(id); :}
  ;
Access method_invocation =
      name.n LPAREN argument_list.l? 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 IDENTIFIER LPAREN argument_list.l? 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 DOT IDENTIFIER LPAREN argument_list.l? 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 SUPER DOT IDENTIFIER LPAREN argument_list.l? 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); :}
   ;
Access array_access =
    name.n LBRACK expression.e RBRACK                 {: ArrayAccess a = new ArrayAccess(e);
                                                         a.setStart(LBRACK.getStart());
                                                         a.setEnd(RBRACK.getEnd());
                                                         return n.qualifiesAccess(a); :}
  | primary_no_new_array.p LBRACK expression.e RBRACK {: ArrayAccess a = new ArrayAccess(e);
                                                         a.setStart(LBRACK.getStart());
                                                         a.setEnd(RBRACK.getEnd());
                                                         return p.qualifiesAccess(a); :}
/*  | array_creation_init.i LBRACK expression.e RBRACK  {: ArrayAccess a = new ArrayAccess(e);
                                                         a.setStart(LBRACK.getStart());
                                                         a.setEnd(RBRACK.getEnd());
                                                         return i.qualifiesAccess(a); :}
                                                      */
  ;
Expr postfix_expression =
    primary.p                                  {: return p; :}
  | name.n                                     {: return n; :}
  | postincrement_expression.e                 {: return e; :}
  | postdecrement_expression.e                 {: return e; :}
  ;
Expr postincrement_expression =
    postfix_expression.e PLUSPLUS              {: return new PostIncExpr(e); :}
  ;
Expr postdecrement_expression =
    postfix_expression.e MINUSMINUS            {: return new PostDecExpr(e); :}
  ;
Expr unary_expression =
    preincrement_expression.e                  {: return e; :}
  | predecrement_expression.e                  {: return e; :}
  | PLUS unary_expression.e                    {: return new PlusExpr(e); :}
  | MINUS unary_expression.e                   {: return new MinusExpr(e); :}
  | unary_expression_not_plus_minus.e          {: return e; :}
  ;
Expr preincrement_expression =
    PLUSPLUS unary_expression.e                {: return new PreIncExpr(e); :}
  ;
Expr predecrement_expression =
    MINUSMINUS unary_expression.e              {: return new PreDecExpr(e); :}
  ;
Expr unary_expression_not_plus_minus =
    postfix_expression.e                       {: return e; :}
  | COMP unary_expression.e                    {: return new BitNotExpr(e); :}
  | NOT unary_expression.e                     {: return new LogNotExpr(e); :}
  | cast_expression.e                          {: return e; :}
  ;
Expr cast_expression =
    LPAREN primitive_type.t dims.d? RPAREN unary_expression.e      {: return new CastExpr(t.addArrayDims(d), e); :}
  | LPAREN name.n dims.d? RPAREN unary_expression_not_plus_minus.e {: return new CastExpr(n.addArrayDims(d), e); :}
  ;
Expr multiplicative_expression =
    unary_expression.e                                     {: return e; :}
  | multiplicative_expression.e1 MULT unary_expression.e2  {: return new MulExpr(e1, e2); :}
  | multiplicative_expression.e1 DIV unary_expression.e2   {: return new DivExpr(e1, e2); :}
  | multiplicative_expression.e1 MOD unary_expression.e2   {: return new ModExpr(e1, e2); :}
  ;
Expr additive_expression =
    multiplicative_expression.e                                {: return e; :}
  | additive_expression.e1 PLUS multiplicative_expression.e2   {: return new AddExpr(e1, e2); :}
  | additive_expression.e1 MINUS multiplicative_expression.e2  {: return new SubExpr(e1, e2); :}
  ;
Expr shift_expression =
    additive_expression.e                               {: return e; :}
  | shift_expression.e1 LSHIFT additive_expression.e2   {: return new LShiftExpr(e1, e2); :}
  | shift_expression.e1 RSHIFT additive_expression.e2   {: return new RShiftExpr(e1, e2); :}
  | shift_expression.e1 URSHIFT additive_expression.e2  {: return new URShiftExpr(e1, e2); :}
  ;
Expr relational_expression =
    shift_expression.e                                  {: return e; :}
  | relational_expression.e1 LT shift_expression.e2     {: return new LTExpr(e1, e2); :}
  | relational_expression.e1 GT shift_expression.e2     {: return new GTExpr(e1, e2); :}
  | relational_expression.e1 LTEQ shift_expression.e2   {: return new LEExpr(e1, e2); :}
  | relational_expression.e1 GTEQ shift_expression.e2   {: return new GEExpr(e1, e2); :}
  | relational_expression.e INSTANCEOF reference_type.t {: return new InstanceOfExpr(e, t); :}
  ;
Expr equality_expression =
    relational_expression.e                               {: return e; :}
  | equality_expression.e1 EQEQ relational_expression.e2  {: return new EQExpr(e1, e2); :}
  | equality_expression.e1 NOTEQ relational_expression.e2 {: return new NEExpr(e1, e2); :}
  ;
Expr and_expression =
    equality_expression.e                               {: return e; :}
  | and_expression.e1 AND equality_expression.e2        {: return new AndBitwiseExpr(e1, e2); :}
  ;
Expr exclusive_or_expression =
    and_expression.e                                    {: return e; :}
  | exclusive_or_expression.e1 XOR and_expression.e2    {: return new XorBitwiseExpr(e1, e2); :}
  ;
Expr inclusive_or_expression =
    exclusive_or_expression.e                                {: return e; :}
  | inclusive_or_expression.e1 OR exclusive_or_expression.e2 {: return new OrBitwiseExpr(e1, e2); :}
  ;
Expr conditional_and_expression =
    inclusive_or_expression.e                                       {: return e; :}
  | conditional_and_expression.e1 ANDAND inclusive_or_expression.e2 {: return new AndLogicalExpr(e1, e2); :}
  ;
Expr conditional_or_expression =
    conditional_and_expression.e                                    {: return e; :}
  | conditional_or_expression.e1 OROR conditional_and_expression.e2 {: return new OrLogicalExpr(e1, e2); :}
  ;
Expr conditional_expression =
    conditional_or_expression.c                                                        {: return c; :}
  | conditional_or_expression.c QUESTION expression.e1 COLON conditional_expression.e2 {: return new ConditionalExpr(c, e1, e2); :}
  ;
Expr assignment_expression =
    conditional_expression.c {: return c; :}
  | assignment.a {: return a; :}
  ;
Expr assignment =
    postfix_expression.dest EQ assignment_expression.source {: return new AssignSimpleExpr(dest, source); :}
  | postfix_expression.dest MULTEQ assignment_expression.source {: return new AssignMulExpr(dest, source); :}
  | postfix_expression.dest DIVEQ assignment_expression.source {: return new AssignDivExpr(dest, source); :}
  | postfix_expression.dest MODEQ assignment_expression.source {: return new AssignModExpr(dest, source); :}
  | postfix_expression.dest PLUSEQ assignment_expression.source {: return new AssignPlusExpr(dest, source); :}
  | postfix_expression.dest MINUSEQ assignment_expression.source {: return new AssignMinusExpr(dest, source); :}
  | postfix_expression.dest LSHIFTEQ assignment_expression.source {: return new AssignLShiftExpr(dest, source); :}
  | postfix_expression.dest RSHIFTEQ assignment_expression.source {: return new AssignRShiftExpr(dest, source); :}
  | postfix_expression.dest URSHIFTEQ assignment_expression.source {: return new AssignURShiftExpr(dest, source); :}
  | postfix_expression.dest ANDEQ assignment_expression.source {: return new AssignAndExpr(dest, source); :}
  | postfix_expression.dest XOREQ assignment_expression.source {: return new AssignXorExpr(dest, source); :}
  | postfix_expression.dest OREQ assignment_expression.source {: return new AssignOrExpr(dest, source); :}
  ;
Expr expression =
    assignment_expression.a                    {: return a; :}
  ;
Expr constant_expression =
    expression.e                               {: return e; :}
  ;
BodyDecl class_body_declaration =
    error SEMICOLON {: return new InstanceInitializer(new Block()); :}
  | error LBRACE {: return new InstanceInitializer(new Block()); :}
  ;

Block block =
    error RBRACE {: return new Block(new List()); :}
  ;

Stmt statement =
    error SEMICOLON {: return new EmptyStmt(); :}
  ;
TypeDecl 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());:}
  ;

Access granule_type =
    name.n                    {: return n; :}
  ;
GranuleDecl granule_declaration =
    modifiers.m? GRANULE IDENTIFIER super.s? LPAREN class_type.c RPAREN class_body.b 
                                               {: return new GranuleDecl(new Modifiers(m), IDENTIFIER, s, c, b); :}
  ;
ClassDecl class_declaration =
    modifiers.m? CLASS IDENTIFIER super.s? interfaces.i? class_body.b 
                                               {: return new ClassDecl(new Modifiers(m), IDENTIFIER, s, i, b); :}
   
  ;  
  
  
ShadowClassDecl shadow_class_declaration = 
    modifiers.m? CLASS IDENTIFIER IN granule_type.g super.s? interfaces.i? class_body.b 
                                               {: return new ShadowClassDecl(new Modifiers(m), IDENTIFIER,g, s, i, b); :}
  ;    
 
 
Modifier modifier =
    PUBLIC                                     {: return new Modifier("public"); :}
  | PROTECTED                                  {: return new Modifier("protected"); :}
  | PRIVATE                                    {: return new Modifier("private"); :}
  | STATIC                                     {: return new Modifier("static"); :}
  | ABSTRACT                                   {: return new Modifier("abstract"); :}
  | FINAL                                      {: return new Modifier("final"); :}
  | NATIVE                                     {: return new Modifier("native"); :}
  | SYNCHRONIZED                               {: return new Modifier("synchronized"); :}
  | TRANSIENT                                  {: return new Modifier("transient"); :}
  | VOLATILE                                   {: return new Modifier("volatile"); :}
  | STRICTFP                                   {: return new Modifier("strictfp"); :}
  | EXTERNAL                                   {: return new Modifier("external"); :}
  ;