java抽象语法树（AST）

在上一篇文章java自定义编译时注解器中讲述到了有关自定义注解器的使用，接来在这里将会讲述的是如何通过语法树表示所想要的代码结构，并通过编译处理器生成相应的字节码。

Java 编译处理流程

  1. 源文件在指定的命令行下被读取，解析为语法树。对应外部可见的定义会被记录到编译器的符号表中（符合表如：LineNumberTable 记录行号、LocalVariableTable 记录变量定义、Exception table 记录异常定义 、StackMapTable ）
  2. 注解处理器编译处理注解。
  3. 语法分析器根据已解析创建的语法树分析并生成字节码，在语法树分析期间，当前所引用到的其他类也将会的的解析。

一、抽象语法树（Abstract Syntax Tree）

在计算机科学中，抽象语法树（Abstract Syntax Tree，AST），或简称语法树（Syntax tree），是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。

抽象语法树由JCTree 内部类（如：JCCompilationUnit、JCImport、JCClassDecl、JCMethodDecl、JCVariableDecl 等等）作为语法节点构成。语法树的节点可以是 包名、修饰符、类、接口、异常、方法、变量、返回值等。

例如：

1
2
3
4
5
6
7
package com.test;
public class Demo{
    public String var = "hello world";
    public void print(){
        System.out.print(var);
    }
}

对应的语法树如下图：

图1

JCTree 类中提供了 accept() 方法来范围语法树中的所有语法节点。

1
public abstract void accept(JCTree.Visitor var1);

accept 方法接收一个JCTree的内部类 Visitor 作为参数，Visitor 提供了一系列访问语法树各个语法节点的方法。在获取到响应的语法节点后，我们可以对语法节点进行增删改操作。

Visitor 的子类有 TreeScanner(可以扫描语法树的所有节点) 和 TreeTranslator（扫描语法树所有节点并且可以将节点进行转换）

JCCompilationUnit

​ Everything in one source file is kept in a TopLevel structure. 在语法树中作为每一个原文件的顶级结构，包含有 JCPackageDecl、JCImport、JCClassDecl 等信息。

JCClassDecl 类定义
1
2
3
4
5
6
7
8
9
10
public static class JCClassDecl extends JCTree.JCStatement implements ClassTree {
    public JCTree.JCModifiers mods;				// 类访问修饰符，如 public、private、final
    public Name name;							// 类名称
    public List<JCTree.JCTypeParameter> typarams;	// 泛型参数列表
    public JCTree.JCExpression extending;			// 继承的父类
    public List<JCTree.JCExpression> implementing;	// 实现的接口列表
    public List<JCTree> defs;		// 成员变量、方法
    public ClassSymbol sym;			// 包名+类名
    
}
JCMethodDecl 方法定义
1
2
3
4
5
6
7
8
9
10
11
12
public static class JCMethodDecl extends JCTree implements MethodTree {
    public JCTree.JCModifiers mods;			// 方法访问修饰符 public、private、static、final
    public Name name;	// 方法名称
    public JCTree.JCExpression restype;		// 返回类型
    public List<JCTree.JCTypeParameter> typarams;		// 泛型参数列表
    public JCTree.JCVariableDecl recvparam;			// 
    public List<JCTree.JCVariableDecl> params;		// 方法接收的参数列表
    public List<JCTree.JCExpression> thrown;		// 方法异常 列表
    public JCTree.JCBlock body;			// 方法他	
    public JCTree.JCExpression defaultValue;		//注解类的方法需要的defaultValue
    public MethodSymbol sym;		// //方法名+ （参数类型），如：setName(java.lang.String)
}
JCModifiers 访问修饰定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static class JCModifiers extends JCTree implements ModifiersTree {
    public long flags; // 访问修饰标记 public、private、static、final
    public List<JCTree.JCAnnotation> annotations;//注解列表
}
//
public class Flags {
    public static final int PUBLIC = 1;
    public static final int PRIVATE = 2;
    public static final int PROTECTED = 4;
    public static final int STATIC = 8;
    public static final int FINAL = 16;
    public static final int SYNCHRONIZED = 32;
    public static final int VOLATILE = 64;
    public static final int TRANSIENT = 128;
    public static final int NATIVE = 256;
    .....
}
// 例子 如要表示 
public static final;
treeMaker.Modifiers(Flags.PUBLIC + Flags.STATIC + Flags.FINAL);

JCVariableDecl 变量的定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static class JCVariableDecl extends JCTree.JCStatement implements VariableTree {
    public JCTree.JCModifiers mods;		// 方法访问修饰符
    public Name name;	// 变量名称
    public JCTree.JCExpression nameexpr;
    public JCTree.JCExpression vartype;		// 变量类型
    public JCTree.JCExpression init;		// 变量初始化值
    public VarSymbol sym;				// 变量名
}

// 例子
// 定义变量 :
public static final int i = 1;
treeMaker.VarDef(
    treeMaker.Modifiers(Flags.PUBLIC + Flags.STATIC + Flags.FINAL),
    names.from("i"),
    treeMaker.TypeIdent(TypeTag.INT),
    treeMaker.Literal(1)
)

JCIdent 标识符表达式，可以表示类、变量引用或者方法。
1
2
3
4
5
6
public static class JCIdent extends JCTree.JCExpression implements IdentifierTree {
    public Name name;  //标识符的名字
    public Symbol sym; //代表类时为包名+类名，代表其他类型数据时为null
}
// 样例 获取变量 x
treeMaker.Ident(names.fromString("x"))))
JCIf if语句定义
1
2
3
4
5
public static class JCIf extends JCTree.JCStatement implements IfTree {
    public JCTree.JCExpression cond;  // 条件判断语句 
    public JCTree.JCStatement thenpart; // if 
    public JCTree.JCStatement elsepart; // else
}
JCAssign 赋值语句
1
2
3
4
public static class JCAssign extends JCTree.JCExpression implements AssignmentTree {
    public JCTree.JCExpression lhs;  // 赋值语句左边表达式
    public JCTree.JCExpression rhs;  // 赋值语句右边表达式
}
JCAssignOp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static class JCAssignOp extends JCTree.JCExpression implements CompoundAssignmentTree {
    private JCTree.Tag opcode;		 	// 操作符	
    public JCTree.JCExpression lhs;		// 赋值语句左边表达式
    public JCTree.JCExpression rhs;		// 赋值语句右边表达式
    public Symbol operator;
}

// --> opcode可取值
public static enum Tag {
      BITOR_ASG(BITOR),                // |=
      BITXOR_ASG(BITXOR),              // ^=
      BITAND_ASG(BITAND),              // &=

      SL_ASG(SL),                      // <<=
      SR_ASG(SR),                      // >>=
      USR_ASG(USR),                    // >>>=
      PLUS_ASG(PLUS),                  // +=
      MINUS_ASG(MINUS),                // -=
      MUL_ASG(MUL),                    // *=
      DIV_ASG(DIV),                    // /=
      MOD_ASG(MOD),                    // %=
}
JCBinary 二元操作符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public static class JCBinary extends JCTree.JCExpression implements BinaryTree {
    private JCTree.Tag opcode;			// 操作符
    public JCTree.JCExpression lhs;		// 赋值语句左边表达式
    public JCTree.JCExpression rhs;		// 赋值语句右边表达式
    public Symbol operator;
}

// --> 二元运算符opcode可取值
public static enum Tag {
        OR,                              // ||
        AND,                             // &&
        BITOR,                           // |
        BITXOR,                          // ^
        BITAND,                          // &
        EQ,                              // ==
        NE,                              // !=
        LT,                              // <
        GT,                              // >
        LE,                              // <=
        GE,                              // >=
        SL,                              // <<
        SR,                              // >>
        USR,                             // >>>
        PLUS,                            // +
        MINUS,                           // -
        MUL,                             // *
        DIV,                             // /
        MOD,                             // %
}

JCReturn 返回语句
1
2
3
public static class JCReturn extends JCTree.JCStatement implements ReturnTree {
    public JCTree.JCExpression expr;   //返回语句的结果字段
}
JCLiteral 字面量表达式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static class JCLiteral extends JCTree.JCExpression implements LiteralTree {
    public TypeTag typetag;		//常量的类型
    public Object value;		//常量值
}
// --> typetag 常量类型取值 
public enum TypeTag {
    BYTE(1, 125, true),			// byte 类型
    CHAR(2, 122, true),			// char 类型
    SHORT(4, 124, true),		// short 类型
    LONG(16, 112, true),		// long 类型
    FLOAT(32, 96, true),		// float 类型
    INT(8, 120, true),			// int 类型
    DOUBLE(64, 64, true),		// double 类型
    BOOLEAN(0, 0, true),		// boolean 类型
    VOID,						// void
    CLASS,						// class 
    ARRAY,						// array 数组
    METHOD,						// method 方法
    PACKAGE,					// package 包
    TYPEVAR,					
    WILDCARD,
    FORALL,
    DEFERRED,
    BOT,
    NONE,
    ERROR,
    UNKNOWN,
    UNDETVAR,
    UNINITIALIZED_THIS,
    UNINITIALIZED_OBJECT;
}
// 样例
treeMaker.Literal(TypeTag.BOT,null)  //  表示  null
JCFieldAccess 其他类的变量、方法的访问表达式
1
2
3
4
5
public static class JCFieldAccess extends JCTree.JCExpression implements MemberSelectTree {
    public JCTree.JCExpression selected;	 //类访问表达式
    public Name name;			// 变量名、方法名
    public Symbol sym;	
}
JCMethodInvocation 方法调用表达式
1
2
3
4
5
6
public static class JCMethodInvocation extends JCTree.JCPolyExpression implements MethodInvocationTree {
    public List<JCTree.JCExpression> typeargs;		// 调用方法参数类型列表
    public JCTree.JCExpression meth;				// 方法的调用语句
    public List<JCTree.JCExpression> args;			// 参数列表
    public Type varargsElement;
}
JCSkip

空操作，即一个无效的分号 “;”

JCUnary 一元运算表达式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static class JCUnary extends JCTree.JCExpression implements UnaryTree {
        private JCTree.Tag opcode;//操作运算符
        public JCTree.JCExpression arg;//
}

public static enum Tag {
  POS,                             // +
  NEG,                             // -
  NOT,                             // !
  COMPL,                           // ~
  PREINC,                          // ++ _；例子：++i
  PREDEC,                          // -- _； 例子：--i
  POSTINC,                         // _ ++; 例子：i++
  POSTDEC,                         // _ --; 例子：i--
}

-->例子：i++;
treeMaker.Unary(JCTree.Tag.POSTINC, treeMaker.Ident(names.fromString("i")));
JCBlock 代码块 定义
1
2
3
4
5
6
7
8
public static class JCBlock extends JCTree.JCStatement implements BlockTree {
        public long flags;
        public List<JCTree.JCStatement> stats;
        public int endpos = -1;
}
// 例子
List<JCTree.JCStatement> jcStatements = List.nil();
treeMaker.Block(0,jcStatements);
JCForLoop for 循环代码块定义
1
2
3
4
5
6
public static class JCForLoop extends JCTree.JCStatement implements ForLoopTree {
    public List<JCTree.JCStatement> init;
    public JCTree.JCExpression cond;
    public List<JCTree.JCExpressionStatement> step;
    public JCTree.JCStatement body;
}
JCDoWhileLoop do…while 循环代码块定义
1
2
3
4
public static class JCDoWhileLoop extends JCTree.JCStatement implements DoWhileLoopTree {
    public JCTree.JCStatement body;
    public JCTree.JCExpression cond;
}
JCWhileLoop while 循环代码块定义
1
2
3
4
public static class JCWhileLoop extends JCTree.JCStatement implements WhileLoopTree {
    public JCTree.JCExpression cond;
    public JCTree.JCStatement body;
}
JCEnhancedForLoop 增强for 循环定义
1
2
3
4
public static class JCWhileLoop extends JCTree.JCStatement implements WhileLoopTree {
    public JCTree.JCExpression cond;
    public JCTree.JCStatement body;
}
JCSynchronized 同步锁定义
1
2
3
4
5
public static class JCSynchronized extends JCTree.JCStatement implements SynchronizedTree {
    public JCTree.JCExpression lock;
    public JCTree.JCBlock body;
}
// 样例 synchronized(){}

样例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 构建同步代码块
public class Test{
    
    public void gen(){
        ....
        JCTree.JCStatement jcStatement = treeMaker.Exec(
                treeMaker.Apply(List.nil(),treeMaker.Select(
                        treeMaker.Select(
                                treeMaker.Ident(
                                        names.fromString("System")
                                ),
                                names.fromString("out")
                        ),
                        names.fromString("println")
                ),List.of(treeMaker.Literal("Hello, world!!!")))
        );
		List<JCTree.JCStatement> statementList = List.nil();
        // {System.out.println("Hello, world!!!");}
		JCTree.JCBlock jcBlock = treeMaker.Block(0,statementList);
   
        // syschroninzed(demoA)
   		JCTree.JCExpression SynjcExpression = treeMaker.Ident(names.fromString("demoA"));
   		JCTree.JCSynchronized jcSynchronized = treeMaker.Synchronized(SynjcExpression,jcBlock);
        .....
    }
}
// 最终结果为：
synchronized(demoA) {
    System.out.println("Hello, world!!!");
}

参考资料：

http://openjdk.java.net/groups/compiler/doc/compilation-overview/index.html

https://www.cnblogs.com/wade-luffy/p/6050331.html

https://www.jianshu.com/p/ff8ec920f5b9

https://www.jianshu.com/p/5df7f77611dc

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家