转载：抽象语法树AST的全面解析（二）

时间  2019-11-06
标签 转载 抽象 语法树 ast 全面 解析 繁體版
原文   原文链接

上篇文章：juejin.im/post/5d9096…java

类JCTree(com.sun.tools.javac.tree.JCTree)简要分析

抽象语法树由JCTree的内部类（如JCCompilationUnit，JCClassDecl，JCMethodDecl等）做为语法节点构成。咱们能够经过调用JCTree的accept()方法来访问抽象语法树的全部语法节点。数组

public abstract void accept(JCTree.Visitor var1)； 复制代码

accept()方法接收一个JCTree.Visitor的参数，经过执行这个方法，咱们能够在Visitor类中获取到抽象语法树全部语法节点的数据。oop

Visitor

  • 抽象内部类，内部定义了访问各类语法节点的方法，获取到对应的语法节点后咱们能够对语法节点增长删除或者修改语句。
  • Visitor派生子类有TreeScanner（扫描全部的语法节点）和TreeTranslator（扫描节点且能够把语法节点转换成另外一种语法节点）。
public abstract static class Visitor {

    //访问类节点
    public void visitClassDef(JCTree.JCClassDecl var1) {
        this.visitTree(var1);
    }

    //访问方法节点
    public void visitMethodDef(JCTree.JCMethodDecl var1) {
        this.visitTree(var1);
    }

    //访问变量节点
    public void visitVarDef(JCTree.JCVariableDecl var1) {
        this.visitTree(var1);
    }

    //访问skip节点
    public void visitSkip(JCTree.JCSkip var1) {
        this.visitTree(var1);
    }

    //访问代码块节点
    public void visitBlock(JCTree.JCBlock var1) {
        this.visitTree(var1);
    }

    //访问doWhild循环
    public void visitDoLoop(JCTree.JCDoWhileLoop var1) {
        this.visitTree(var1);
    }

    //访问whild循环
    public void visitWhileLoop(JCTree.JCWhileLoop var1) {
        this.visitTree(var1);
    }

    //访问for循环
    public void visitForLoop(JCTree.JCForLoop var1) {
        this.visitTree(var1);
    }

    //访问forEach循环
    public void visitForeachLoop(JCTree.JCEnhancedForLoop var1) {
        this.visitTree(var1);
    }

    //访问switch
    public void visitSwitch(JCTree.JCSwitch var1) {
        this.visitTree(var1);
    }

    //访问case
    public void visitCase(JCTree.JCCase var1) {
        this.visitTree(var1);
    }

    //访问同步关键字
    public void visitSynchronized(JCTree.JCSynchronized var1) {
        this.visitTree(var1);
    }

    //访问try
    public void visitTry(JCTree.JCTry var1) {
        this.visitTree(var1);
    }

    //访问catch
    public void visitCatch(JCTree.JCCatch var1) {
        this.visitTree(var1);
    }

    //访问三目运算符表达式
    public void visitConditional(JCTree.JCConditional var1) {
        this.visitTree(var1);
    }

    //访问if语句
    public void visitIf(JCTree.JCIf var1) {
        this.visitTree(var1);
    }

    //访问break语句
    public void visitBreak(JCTree.JCBreak var1) {
        this.visitTree(var1);
    }

    //访问continue语句
    public void visitContinue(JCTree.JCContinue var1) {
        this.visitTree(var1);
    }

    //访问return语句
    public void visitReturn(JCTree.JCReturn var1) {
        this.visitTree(var1);
    }

    //访问异常抛出表达式节点
    public void visitThrow(JCTree.JCThrow var1) {
        this.visitTree(var1);
    }

    //访问方法调用节点
    public void visitApply(JCTree.JCMethodInvocation var1) {
        this.visitTree(var1);
    }

    //访问new对象语句节点
    public void visitNewClass(JCTree.JCNewClass var1) {
        this.visitTree(var1);
    }

    //访问new数组语句节点
    public void visitNewArray(JCTree.JCNewArray var1) {
        this.visitTree(var1);
    }

    //访问赋值语句节点
    public void visitAssign(JCTree.JCAssign var1) {
        this.visitTree(var1);
    }

    //访问赋值操做语句节点
    public void visitAssignop(JCTree.JCAssignOp var1) {
        this.visitTree(var1);
    }

    //访问赋值操做语句节点
    public void visitUnary(JCTree.JCUnary var1) {
        this.visitTree(var1);
    }

    //访问一元运算节点
    public void visitBinary(JCTree.JCBinary var1) {
        this.visitTree(var1);
    }

    //访问对其余类的方法调用或者变量调用节点
    public void visitSelect(JCTree.JCFieldAccess var1) {
        this.visitTree(var1);
    }

    //访问标识符
    public void visitIdent(JCTree.JCIdent var1) {
        this.visitTree(var1);
    }

    //访问字面量，能够是数字1，字符串"x"
    public void visitLiteral(JCTree.JCLiteral var1) {
        this.visitTree(var1);
    }

    //获取访问修饰符
    public void visitModifiers(JCTree.JCModifiers var1) {
        this.visitTree(var1);
    }
}
复制代码

JCStatement

声明语句，继承JCStatement都是声明语句，子类有： JCBlock、JCReturn、JCClassDecl、JCVariableDecl、JCTry、JCThrow等；post

JCExpression

表达式语句，继承JCExpression都是表达式语句，子类有： JCAssign，JCBinary，JCBreak，JCFieldAccess，JCIdent，JCLiteral等；this

JCClassDecl

类定义spa

public static class JCClassDecl extends JCTree.JCStatement implements ClassTree {
    public JCTree.JCModifiers mods;//访问修饰符 好比public, 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

方法定义rest

public static class JCMethodDecl extends JCTree implements MethodTree {
    public JCTree.JCModifiers mods;//访问修饰符 好比public, final，static
    public Name name;//方法名
    public JCTree.JCExpression restype;//返回类型
    public List<JCTree.JCTypeParameter> typarams;//泛型参数列表
    public JCTree.JCVariableDecl recvparam;//null
    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)
}
复制代码

JCVariableDecl

变量定义code

public static class JCVariableDecl extends JCTree.JCStatement implements VariableTree {
    public JCTree.JCModifiers mods;//访问修饰符 好比public, final，static
    public Name name;//变量名
    public JCTree.JCExpression nameexpr;//null
    public JCTree.JCExpression vartype;//变量的类型
    public JCTree.JCExpression init;//初始化值
    public VarSymbol sym;//变量名
}
-->建立变量： private x = 1;
treeMaker.VarDef(treeMaker.Modifiers(Flags.PRIVATE),   
    names.fromString"x", treeMaker.TypeIdent(TypeTag.INT), 
    treeMaker.Literal(1));
复制代码

JCModifiers

访问修饰符orm

public static class JCModifiers extends JCTree implements ModifiersTree {
    public long flags;//访问标志，例如：public，private，static
    public List<JCTree.JCAnnotation> annotations;//注解列表
}

-->flag一般用Flags（com.sun.tools.javac.code.Flags）类的常量来表示
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
treeMaker.Modifiers(Flags.PUBLIC);
复制代码

JCBlock

代码块对象

public static class JCBlock extends JCTree.JCStatement implements BlockTree {
    public long flags;//访问修复符
    public List<JCTree.JCStatement> stats;//多行代码列表
}

-->使用例子：
List<JCTree.JCStatement> jcStatementList = List.nil();
treeMaker.Block(0, jcStatementList);//构建代码块
复制代码

JCIdent

标识符表达式，能够表示类、变量引用或者方法。

public static class JCIdent extends JCTree.JCExpression implements IdentifierTree {
    public Name name;//标识符的名字
    public Symbol sym;//表明类时为包名+类名，表明其余类型数据时为null

    protected JCIdent(Name var1, Symbol var2) {
        this.name = var1;
        this.sym = var2;
    }
}

-->建立实例: 获取变量textView的引用
treeMaker.Ident(names.fromString("textView"))))
复制代码

JCFieldAccess

其余类的变量、方法的访问表达式

public static class JCFieldAccess extends JCTree.JCExpression implements MemberSelectTree {
    public JCTree.JCExpression selected;//类访问表达式
    public Name name;//变量名或方法名
    public Symbol sym;
}
复制代码

JCLiteral

字面量表达式

public static class JCLiteral extends JCTree.JCExpression implements LiteralTree {
        public TypeTag typetag;//常量的类型
        public Object value;//常量的值
}

-->
字面量类型的枚举类
public enum TypeTag {
    BYTE(1, 125, true),
    CHAR(2, 122, true),
    SHORT(4, 124, true),
    LONG(16, 112, true),
    FLOAT(32, 96, true),
    INT(8, 120, true),
    DOUBLE(64, 64, true),
    BOOLEAN(0, 0, true),
    CLASS,

    ...
}

-->使用例子：闭括号字符串"}"
treeMaker.Literal("}")
复制代码

JCBinary

二元操做符

public static class JCBinary extends JCTree.JCExpression implements BinaryTree {
    private JCTree.Tag opcode;//操做符
    public JCTree.JCExpression lhs;//操做符左边
    public JCTree.JCExpression rhs;//操做符右边
    public Symbol operator;//null
}

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

-->建立例子 ： 1 + 1
treeMaker.Binary(JCTree.Tag.PLUS, treeMaker.Literal(1),
    treeMaker.Literal(1));
复制代码

JCReturn

return语句

public static class JCReturn extends JCTree.JCStatement implements ReturnTree {
    public JCTree.JCExpression expr;//返回语句的结果字段
}

-->例子：retrun this.xxx
treeMaker.Return(treeMaker.Select(
    treeMaker.Ident(names.fromString("this")),names.fromString("xxx")));
复制代码

JCAssign

赋值语句

public static class JCAssign extends JCTree.JCExpression implements AssignmentTree {
    public JCTree.JCExpression lhs;//赋值语句左边表达式
    public JCTree.JCExpression rhs;//赋值语句右边表达式
}

-->例子：x = 1
treeMaker.Assign(treeMaker.Ident(
    names.fromString("x")))), treeMaker.Literal(1))
复制代码

JCAssignOp

赋值语句

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),                    // %=
}

-->例子：x += 1
treeMaker.AssignOp(JCTree.Tag.PLUS_ASG,
    treeMaker.Ident(names.fromString("x")))), treeMaker.Literal(1))
复制代码

JCIf

if代码块； if(condition) {thenpart} else {elsepart}

public static class JCIf extends JCTree.JCStatement implements IfTree {
    public JCTree.JCExpression cond;//条件语句
    public JCTree.JCStatement thenpart;//if的操做语句
    public JCTree.JCStatement elsepart;//else的操做语句
}
复制代码

JCForLoop

for循环代码块；for (init; cond; step) {body}

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;
}
复制代码

JCTry、JCCatch

try、catch和finally代码块；

public static class JCTry extends JCTree.JCStatement implements TryTree {
    public JCTree.JCBlock body;//try代码块
    public List<JCTree.JCCatch> catchers;//JCCatch
    public JCTree.JCBlock finalizer;//final代码块
    public List<JCTree> resources;//List.nil()，用不上的字段
    public boolean finallyCanCompleteNormally;//
}

public static class JCCatch extends JCTree implements CatchTree {
    public JCTree.JCVariableDecl param;//catch的异常类型
    public JCTree.JCBlock body;//catch代码块
}
复制代码

JCMethodInvocation

方法调用表达式

public static class JCMethodInvocation extends JCTree.JCPolyExpression implements MethodInvocationTree {
    public List<JCTree.JCExpression> typeargs;//参数类型列表
    public JCTree.JCExpression meth;//方法的调用语句，好比Log.i，setContentView
    public List<JCTree.JCExpression> args;//参数列表
    public Type varargsElement;//null
}
复制代码

JCDoWhileLoop

doWhile循环 ; do（body）while(cond)

public static class JCDoWhileLoop extends JCTree.JCStatement implements DoWhileLoopTree {
    public JCTree.JCStatement body;//do代码块
    public JCTree.JCExpression cond;//条件语句
}
复制代码

JCEnhancedForLoop

加强for循环 ; for(var : expr){body}

public static class JCEnhancedForLoop extends JCTree.JCStatement implements EnhancedForLoopTree {
    public JCTree.JCVariableDecl var;
    public JCTree.JCExpression expr;
    public JCTree.JCStatement body;//代码块
}
复制代码

JCThrow

异常抛出

public static class JCThrow extends JCTree.JCStatement implements ThrowTree {
    public JCTree.JCExpression expr;//异常表达式
}

-->例子：throw Exception
treeMaker.Throw(treeMaker.Ident(names.fromString("Exception")));
复制代码

JCSwitch，JCCase

switch代码块；switch(selector) {case pat : stats}

public static class JCSwitch extends JCTree.JCStatement implements SwitchTree {
    public JCTree.JCExpression selector;//判断条件
    public List<JCTree.JCCase> cases;//多个case
}

public static class JCCase extends JCTree.JCStatement implements CaseTree {
    public JCTree.JCExpression pat;//case逻辑表达式
    public List<JCTree.JCStatement> stats;//代码执行语句
}
复制代码

JCConditional

三目运算表达式，cond ? truepart : falsepart

public static class JCConditional extends JCTree.JCPolyExpression implements ConditionalExpressionTree {
    public JCTree.JCExpression cond;//判断条件
    public JCTree.JCExpression truepart;//判断为真时执行的表达式
    public JCTree.JCExpression falsepart;//判断为假时执行的表达式
}
复制代码

JCSkip

空操做，即一个无效的分号 ";"

JCUnary

一元运算表达式

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")));
复制代码

JCContinue

continue，跳过本次循环, continue label

public static class JCContinue extends JCTree.JCStatement implements ContinueTree {
    public Name label;//label标签
    public JCTree target;//null
}
复制代码

JCBreak

break，跳出循环, break label

public static class JCBreak extends JCTree.JCStatement implements BreakTree {
    public Name label;//label标签
    public JCTree target;//null
}
复制代码

原文地址：www.jianshu.com/p/4bd5dc13f…

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程