javaparser.all

JDK1.4编译器后端

%header {:
 package parser;
 import AST.*;
:};
%embed {:
  class Events extends Parser.Events {
    public void scannerError(Scanner.Exception e) {
      errors.add(new Problem(null, e.getMessage(), e.line, e.column, Problem.Severity.ERROR, Problem.Kind.LEXICAL));
    }
    public void syntaxError(Symbol token) {
      int line = token.getLine(token.getStart());
      int column = token.getColumn(token.getStart());
      int endLine = token.getLine(token.getEnd());
      int endColumn = token.getColumn(token.getEnd());
      String value = token.value != null ? token.value.toString() : Terminals.NAMES[token.getId()];
      errors.add(new Problem(null, "unexpected token \"" + value + "\"", line, column, endLine, endColumn, Problem.Severity.ERROR, Problem.Kind.SYNTACTIC));
    }
    public void unexpectedTokenRemoved(Symbol token) {
    }
    public void missingTokenInserted(Symbol token) {
    }
    public void misspelledTokenReplaced(Symbol token) {
    }
    public void errorPhraseRemoved(Symbol error) {
    }
  }

        {
            report = new Events(); // Use error handler in parser
        }

   public CompilationUnit parse(java.io.InputStream is, String fileName) throws java.io.IOException, beaver.Parser.Exception {
     CompilationUnit cu;
     errors = new ArrayList();
     try {
       scanner.JavaScanner scanner = new scanner.JavaScanner(new scanner.Unicode(is));
       cu = (CompilationUnit)parse(scanner);
     } catch(Parser.Exception e) {
       // build empty compilation unit for failed error recovery
       cu = new CompilationUnit();
     } catch(Error e) {
       cu = new CompilationUnit();
       errors.add(new Problem(null, e.getMessage(), 0, 0, Problem.Severity.ERROR, Problem.Kind.LEXICAL));
     }
     for(java.util.Iterator iter = errors.iterator(); iter.hasNext(); ) {
       Problem p = (Problem)iter.next();
       p.setFileName(fileName);
       cu.addParseError(p);
     }
     return cu;
   }
   protected java.util.Collection errors = new ArrayList();
:};

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); :}