java14.parser

JDK1.4编译器前端

CompilationUnit goal =
    compilation_unit.cu      {: return cu; :}
  ;
      
Expr literal =
    INTEGER_LITERAL.i        {: return new IntegerLiteral(i); :}
  | LONG_LITERAL.l           {: return new LongLiteral(l); :}
  | FLOATING_POINT_LITERAL.f {: return new FloatingPointLiteral(f); :}
  | DOUBLE_LITERAL.d         {: return new DoubleLiteral(d); :}
  | BOOLEAN_LITERAL.b        {: return new BooleanLiteral(b); :}
  | CHARACTER_LITERAL.c      {: return new CharacterLiteral(c); :}
  | STRING_LITERAL.s         {: return new StringLiteral(s); :}
  | NULL_LITERAL             {: return new NullLiteral("null"); :}
  ;
Access type =
    primitive_type.t         {: return t; :}
  | reference_type.t         {: return t; :}
  ;
Access primitive_type =
    numeric_type.t           {: return t; :}
  | BOOLEAN                  {: return new PrimitiveTypeAccess("boolean"); :}
  ;
Access numeric_type =
    integral_type.t          {: return t; :}
  | floating_point_type.t    {: return t; :}
  ;
Access integral_type =
    BYTE                     {: return new PrimitiveTypeAccess("byte"); :}
  | SHORT                    {: return new PrimitiveTypeAccess("short"); :}
  | INT                      {: return new PrimitiveTypeAccess("int"); :}
  | LONG                     {: return new PrimitiveTypeAccess("long"); :}
  | CHAR                     {: return new PrimitiveTypeAccess("char"); :}
  ;
Access floating_point_type =
    FLOAT                    {: return new PrimitiveTypeAccess("float"); :}
  | DOUBLE                   {: return new PrimitiveTypeAccess("double"); :}
  ;
Access reference_type =
    class_or_interface_type.t {: return t; :}
  | array_type.t              {: return t; :}
  ;
Access class_or_interface_type =
    name.n                    {: return n; :}
  ;
Access class_type =
    class_or_interface_type.n {: return n; :}
  ;
Access interface_type =
    class_or_interface_type.n {: return n; :}
  ;
Access array_type =
    primitive_type.t dims.d   {: return t.addArrayDims(d); :}
  | name.n dims.d             {: return n.addArrayDims(d); :}
  ;
Access name =
    simple_name.s             {: return s; :}
  | qualified_name.q          {: return q; :}
  ;
Access simple_name =
    IDENTIFIER              {: return new ParseName(IDENTIFIER); :}
  ;
Access qualified_name =
    name.n DOT simple_name.i   {: return n.qualifiesAccess(i); :}
  ;
CompilationUnit compilation_unit =
    package_declaration.p import_declarations.i? type_declarations.t? {: return new CompilationUnit(p.getID(), i, t); :}
  |                       import_declarations.i? type_declarations.t? {: return new CompilationUnit("", i, t); :}
  ;
List import_declarations =
    import_declaration.i                       {: return new List().add(i); :}
  | import_declarations.l import_declaration.i {: return l.add(i); :}
  ;
List 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; :}
  ;
IdUse package_declaration =
    PACKAGE name_decl.n SEMICOLON              {: return n; :}
  ;
IdUse name_decl =
    simple_name_decl.s        {: return s; :}
  | qualified_name_decl.q     {: return q; :}
  ;
IdUse simple_name_decl =
    IDENTIFIER              {: return new IdUse(IDENTIFIER); :}
  ;
IdUse qualified_name_decl =
    name_decl.n DOT IDENTIFIER.i {: return new IdUse(n.getID() + "." + i); :}
  ;
ImportDecl import_declaration =
    single_type_import_declaration.s           {: return s; :}
  | type_import_on_demand_declaration.t        {: return t; :}
  ;
ImportDecl single_type_import_declaration =
    IMPORT name.n SEMICOLON                    {: return new SingleTypeImportDecl(n); :}
  ;
ImportDecl type_import_on_demand_declaration =
    IMPORT name.n DOT MULT SEMICOLON           {: return new TypeImportOnDemandDecl(n); :}
  ;
TypeDecl type_declaration =
    class_declaration.c                        {: return c; :}
  | interface_declaration.i                    {: return i; :}
  | SEMICOLON                                  {: return new EmptyType(new Modifiers(), "EmptyType", new Opt(), new List()); :}
  ;
List modifiers =
    modifier.m                                 {: return new List().add(m); :}
  | modifiers.l modifier.m                     {: return l.add(m); :}
  ;
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"); :}
  ;
ClassDecl class_declaration =
    modifiers.m? CLASS IDENTIFIER super.s? interfaces.i? class_body.b 
                                               {: return new ClassDecl(new Modifiers(m), IDENTIFIER, s, i, b); :}
  ;
Opt super =
    EXTENDS class_type.c                       {: return new Opt(c); :}
  ;
List interfaces =
    IMPLEMENTS interface_type_list.i           {: return i; :}
  ;
List interface_type_list =
    interface_type.i                              {: return new List().add(i); :}
  | interface_type_list.l COMMA interface_type.i  {: return l.add(i); :}
  ;
List class_body =
    LBRACE class_body_declarations.c? RBRACE    {: return c; :}
  ;
List class_body_declarations =
    class_body_declaration.c                           {: return new List().add(c); :}
  | class_body_declarations.l class_body_declaration.c {: return l.add(c); :}
  ;
BodyDecl class_body_declaration =
    class_member_declaration.c                 {: return c; :}
  | instance_initializer.i                     {: return i; :}
  | static_initializer.si                      {: return si; :}
  | constructor_declaration.c                  {: return c; :}
  ;
BodyDecl 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                                  {: return new InstanceInitializer(new Block()); :}
  ;
BodyDecl field_declaration =
    modifiers.m? type.t variable_declarators.v SEMICOLON {: return new FieldDecl(new Modifiers(m), t, v); :}
  ;
List variable_declarators =
    variable_declarator.v                              {: return new List().add(v); :}
  | variable_declarators.l COMMA variable_declarator.v {: return l.add(v); :}
  ;
VariableDecl variable_declarator =
    variable_declarator_id.v                           {: return v; :}
  | variable_declarator_id.v EQ variable_initializer.i {: v.setInit(i); return v; :}
  ;
VariableDecl variable_declarator_id =
    IDENTIFIER dims.d?                       {: return new VariableDecl(IDENTIFIER, d, new Opt()); :}
  ;
Expr variable_initializer =
    expression.e                               {: return e; :}
  | array_initializer.a                        {: return a; :}
  ;
MethodDecl method_declaration =
    method_header.m method_body.b              {: m.setBlockOpt(b); return m; :}
  ;
      
MethodDecl method_header =
    modifiers.m? type.t IDENTIFIER LPAREN formal_parameter_list.l? RPAREN dims.d? throws.tl?
    {: return new MethodDecl(new Modifiers(m), t.addArrayDims(d), IDENTIFIER, l, tl, new Opt()); :}
  | modifiers.m? VOID   IDENTIFIER LPAREN formal_parameter_list.l? RPAREN throws.tl?
    {: return new MethodDecl(new Modifiers(m), new PrimitiveTypeAccess("void"), IDENTIFIER, l, tl, new Opt()); :}
  ;
                                                                
List formal_parameter_list =
    formal_parameter.f                                  {: return new List().add(f); :}
  | formal_parameter_list.l COMMA formal_parameter.f    {: return l.add(f); :}
  ;
ParameterDeclaration formal_parameter =
  modifiers.m? type.t IDENTIFIER dims.d?     {: return new ParameterDeclaration(new Modifiers(m), t.addArrayDims(d), IDENTIFIER); :}
  ;
List throws =
    THROWS class_type_list.l                   {: return l; :}
  ;
List class_type_list =
    class_type.c                               {: return new List().add(c); :}
  | class_type_list.l COMMA class_type.c       {: return l.add(c); :}
  ;
Opt method_body =
    block.b                                    {: return new Opt(b); :}
  | SEMICOLON                                  {: return new Opt(); :}
  ;
StaticInitializer static_initializer =
    STATIC block.b                             {: return new StaticInitializer(b); :}
  ;
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());