浅谈Javac编译原理

Javac就是java编译器，它的作用就是把java源代码转化为JVM能识别的一种语言，然后JVM可以将这种语言转为当前运行机器所能识别的机器码，从而执行程序。这篇文章只谈源代码到jvm的字节码的过程。

Javac使源码转为JVM字节码需要经历4个过程：词法分析，语法分析，语义分析，代码生成。
本篇文章以jdk1.7版本及以下讲解，1.8后编译相关的源码改动较大，具体变化挖坑以后再补。

词法分析

Javac的主要词法分析器的接口类是com.sun.tools.javac.parser.Lexer,它的默认实现类是com.sun.tools.javac.parser.Scanner,Scanner会逐个读取Java源文件的单个字符，然后解析出符合Java语言规范的Token序列。

public enum Token {
    EOF,
    ERROR,
    IDENTIFIER,
    ABSTRACT("abstract"),
    ASSERT("assert"),
    BOOLEAN("boolean"),
    BREAK("break"),
    BYTE("byte"),
    CASE("case"),
    CATCH("catch"),
    CHAR("char"),
    CLASS("class"),
    CONST("const"),
    CONTINUE("continue"),
    DEFAULT("default"),
    DO("do"),
    DOUBLE("double"),
    ELSE("else"),
    ENUM("enum"),
    EXTENDS("extends"),
    FINAL("final"),
    FINALLY("finally"),
    FLOAT("float"),
    FOR("for"),
    GOTO("goto"),
    IF("if"),
    IMPLEMENTS("implements"),
    IMPORT("import"),
    INSTANCEOF("instanceof"),
    INT("int"),
    INTERFACE("interface"),
    LONG("long"),
    NATIVE("native"),
    NEW("new"),
    PACKAGE("package"),
    PRIVATE("private"),
    PROTECTED("protected"),
    PUBLIC("public"),
    RETURN("return"),
    SHORT("short"),
    STATIC("static"),
    STRICTFP("strictfp"),
    SUPER("super"),
    SWITCH("switch"),
    SYNCHRONIZED("synchronized"),
    THIS("this"),
    THROW("throw"),
    THROWS("throws"),
    TRANSIENT("transient"),
    TRY("try"),
    VOID("void"),
    VOLATILE("volatile"),
    WHILE("while"),
    INTLITERAL,
    LONGLITERAL,
    FLOATLITERAL,
    DOUBLELITERAL,
    CHARLITERAL,
    STRINGLITERAL,
    TRUE("true"),
    FALSE("false"),
    NULL("null"),
    LPAREN("("),
    RPAREN(")"),
    LBRACE("{"),
    RBRACE("}"),
    LBRACKET("["),
    RBRACKET("]"),
    SEMI(";"),
    COMMA(","),
    DOT("."),
    ELLIPSIS("..."),
    EQ("="),
    GT(">"),
    LT("<"),
    BANG("!"),
    TILDE("~"),
    QUES("?"),
    COLON(":"),
    EQEQ("=="),
    LTEQ("<="),
    GTEQ(">="),
    BANGEQ("!="),
    AMPAMP("&&"),
    BARBAR("||"),
    PLUSPLUS("++"),
    SUBSUB("--"),
    PLUS("+"),
    SUB("-"),
    STAR("*"),
    SLASH("/"),
    AMP("&"),
    BAR("|"),
    CARET("^"),
    PERCENT("%"),
    LTLT("<<"),
    GTGT(">>"),
    GTGTGT(">>>"),
    PLUSEQ("+="),
    SUBEQ("-="),
    STAREQ("*="),
    SLASHEQ("/="),
    AMPEQ("&="),
    BAREQ("|="),
    CARETEQ("^="),
    PERCENTEQ("%="),
    LTLTEQ("<<="),
    GTGTEQ(">>="),
    GTGTGTEQ(">>>="),
    MONKEYS_AT("@"),
    CUSTOM;
}

Token是一个枚举类，定义了java语言中的系统关键字和符号，Token. IDENTIFIER用于表示用户定义的名称，如类名、包名、变量名、方法名等。

这里有两个问题，Javac是如何分辨这一个个Token的呢？例如，它是怎么知道package就是一个Token.PACKAGE,而不是用户自定义的Token.INENTIFIER的名称呢。另一个问题是，Javac是如何知道哪些字符组合在一起就是一个Token的呢？

答案1：Javac在进行词法分析时会由JavacParser根据Java语言规范来控制什么顺序、什么地方应该出现什么Token,Token流的顺序要符合Java语言规范。如package这个关键词后面必然要跟着用户定义的变量表示符，在每个变量表示符之间必须用“.”分隔，结束时必须跟一个“;”。
下图是读取Token流程

QQ图片20180721132355.png

答案2：如何判断哪些字符组合是一个Token的规则是在Scanner的nextToken方法中定义的，每调用一次这个方法就会构造一个Token,而这些Token必然是com.sun.tools.javac.parser.Token中的任何元素之一。以下为源码：

public void nextToken() {
        try {
            this.prevEndPos = this.endPos;
            this.sp = 0;

            while(true) {
                this.pos = this.bp;
                switch(this.ch) {
                case '\t':
                case '\f':
                case ' ':
                    do {
                        do {
                            this.scanChar();
                        } while(this.ch == 32);
                    } while(this.ch == 9 || this.ch == 12);

                    this.endPos = this.bp;
                    this.processWhiteSpace();
                    break;
                case '\n':
                    this.scanChar();
                    this.endPos = this.bp;
                    this.processLineTerminator();
                    break;
                case '\u000b':
                case '\u000e':
                case '\u000f':
                case '\u0010':
                case '\u0011':
                case '\u0012':
                case '\u0013':
                case '\u0014':
                case '\u0015':
                case '\u0016':
                case '\u0017':
                case '\u0018':
                case '\u0019':
                case '\u001a':
                case '\u001b':
                case '\u001c':
                case '\u001d':
                case '\u001e':
                case '\u001f':
                case '!':
                case '#':
                case '%':
                case '&':
                case '*':
                case '+':
                case '-':
                case ':':
                case '<':
                case '=':
                case '>':
                case '?':
                case '@':
                case '\\':
                case '^':
                case '`':
                case '|':
                default:
                    if(this.isSpecial(this.ch)) {
                        this.scanOperator();
                        return;
                    } else {
                        boolean var6;
                        if(this.ch < 128) {
                            var6 = false;
                        } else {
                            char var2 = this.scanSurrogates();
                            if(var2 != 0) {
                                if(this.sp == this.sbuf.length) {
                                    this.putChar(var2);
                                } else {
                                    this.sbuf[this.sp++] = var2;
                                }

                                var6 = Character.isJavaIdentifierStart(Character.toCodePoint(var2, this.ch));
                            } else {
                                var6 = Character.isJavaIdentifierStart(this.ch);
                            }
                        }

                        if(var6) {
                            this.scanIdent();
                            return;
                        } else {
                            if(this.bp != this.buflen && (this.ch != 26 || this.bp + 1 != this.buflen)) {
                                this.lexError("illegal.char", new Object[]{String.valueOf(this.ch)});
                                this.scanChar();
                            } else {
                                this.token = Token.EOF;
                                this.pos = this.bp = this.eofPos;
                            }

                            return;
                        }
                    }
                case '\r':
                    this.scanChar();
                    if(this.ch == 10) {
                        this.scanChar();
                    }

                    this.endPos = this.bp;
                    this.processLineTerminator();
                    break;
                case '\"':
                    this.scanChar();

                    while(this.ch != 34 && this.ch != 13 && this.ch != 10 && this.bp < this.buflen) {
                        this.scanLitChar();
                    }

                    if(this.ch == 34) {
                        this.token = Token.STRINGLITERAL;
                        this.scanChar();
                    } else {
                        this.lexError(this.pos, "unclosed.str.lit", new Object[0]);
                    }

                    return;
                case '$':
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                case 'G':
                case 'H':
                case 'I':
                case 'J':
                case 'K':
                case 'L':
                case 'M':
                case 'N':
                case 'O':
                case 'P':
                case 'Q':
                case 'R':
                case 'S':
                case 'T':
                case 'U':
                case 'V':
                case 'W':
                case 'X':
                case 'Y':
                case 'Z':
                case '_':
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                case 'g':
                case 'h':
                case 'i':
                case 'j':
                case 'k':
                case 'l':
                case 'm':
                case 'n':
                case 'o':
                case 'p':
                case 'q':
                case 'r':
                case 's':
                case 't':
                case 'u':
                case 'v':
                case 'w':
                case 'x':
                case 'y':
                case 'z':
                    this.scanIdent();
                    return;
                case '\'':
                    this.scanChar();
                    if(this.ch == 39) {
                        this.lexError("empty.char.lit", new Object[0]);
                        return;
                    } else {
                        if(this.ch == 13 || this.ch == 10) {
                            this.lexError(this.pos, "illegal.line.end.in.char.lit", new Object[0]);
                        }

                        this.scanLitChar();
                        if(this.ch == 39) {
                            this.scanChar();
                            this.token = Token.CHARLITERAL;
                        } else {
                            this.lexError(this.pos, "unclosed.char.lit", new Object[0]);
                        }

                        return;
                    }
                case '(':
                    this.scanChar();
                    this.token = Token.LPAREN;
                    return;
                case ')':
                    this.scanChar();
                    this.token = Token.RPAREN;
                    return;
                case ',':
                    this.scanChar();
                    this.token = Token.COMMA;
                    return;
                case '.':
                    this.scanChar();
                    if(48 <= this.ch && this.ch <= 57) {
                        this.putChar('.');
                        this.scanFractionAndSuffix();
                        return;
                    }

                    if(this.ch == 46) {
                        this.putChar('.');
                        this.putChar('.');
                        this.scanChar();
                        if(this.ch == 46) {
                            this.scanChar();
                            this.putChar('.');
                            this.token = Token.ELLIPSIS;
                        } else {
                            this.lexError("malformed.fp.lit", new Object[0]);
                        }

                        return;
                    } else {
                        this.token = Token.DOT;
                        return;
                    }
                case '/':
                    this.scanChar();
                    if(this.ch != 47) {
                        if(this.ch != 42) {
                            if(this.ch == 61) {
                                this.name = this.names.slashequals;
                                this.token = Token.SLASHEQ;
                                this.scanChar();
                            } else {
                                this.name = this.names.slash;
                                this.token = Token.SLASH;
                            }

                            return;
                        }

                        this.scanChar();
                        Scanner.CommentStyle var1;
                        if(this.ch == 42) {
                            var1 = Scanner.CommentStyle.JAVADOC;
                            this.scanDocComment();
                        } else {
                            var1 = Scanner.CommentStyle.BLOCK;

                            while(this.bp < this.buflen) {
                                if(this.ch == 42) {
                                    this.scanChar();
                                    if(this.ch == 47) {
                                        break;
                                    }
                                } else {
                                    this.scanCommentChar();
                                }
                            }
                        }

                        if(this.ch != 47) {
                            this.lexError("unclosed.comment", new Object[0]);
                            return;
                        }

                        this.scanChar();
                        this.endPos = this.bp;
                        this.processComment(var1);
                    } else {
                        do {
                            this.scanCommentChar();
                        } while(this.ch != 13 && this.ch != 10 && this.bp < this.buflen);

                        if(this.bp < this.buflen) {
                            this.endPos = this.bp;
                            this.processComment(Scanner.CommentStyle.LINE);
                        }
                    }
                    break;
                case '0':
                    this.scanChar();
                    if(this.ch != 120 && this.ch != 88) {
                        this.putChar('0');
                        this.scanNumber(8);
                        return;
                    } else {
                        this.scanChar();
                        if(this.ch == 46) {
                            this.scanHexFractionAndSuffix(false);
                            return;
                        } else {
                            if(this.digit(16) < 0) {
                                this.lexError("invalid.hex.number", new Object[0]);
                            } else {
                                this.scanNumber(16);
                            }

                            return;
                        }
                    }
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    this.scanNumber(10);
                    return;
                case ';':
                    this.scanChar();
                    this.token = Token.SEMI;
                    return;
                case '[':
                    this.scanChar();
                    this.token = Token.LBRACKET;
                    return;
                case ']':
                    this.scanChar();
                    this.token = Token.RBRACKET;
                    return;
                case '{':
                    this.scanChar();
                    this.token = Token.LBRACE;
                    return;
                case '}':
                    this.scanChar();
                    this.token = Token.RBRACE;
                    return;
                }
            }
        } finally {
            this.endPos = this.bp;
            if(scannerDebug) {
                System.out.println("nextToken(" + this.pos + "," + this.endPos + ")=|" + new String(this.getRawCharacters(this.pos, this.endPos)) + "|");
            }

        }
    }

语法分析

语法分析器是将词法分析器分析的Token流组建成更加结构化的语法树，也就是将一个个单词组装成一句话，一个完整的语句。Javac的语法树使得Java源码更加结构化，这种结构化可以为后面的进一步处理提供方便。每个语法树上的节点都是com.sun.tools.javac.tree.JCTree的一个示例，关于语法树有以下规则 ：
1.每个语法节点都会实现一个接口xxxTree,这个接口又继承自com.sun.source.tree.Tree接口，如IfTree语法节点表示一个if类型的表达式，BinaryTree语法节点代表一个二元操作表达式。
2.每个语法节点都是com.sun.tools.javac.tree.JCTree的子类，并且会实现第一节点中的xxxTree接口类，这个类的名称类似于JCxxx,如实现IfTree接口的实现类为JCIf,实现BinaryTree接口的类为JCBinary等。
3.所有的JCxxx类都作为一个静态内部类定义在JCTree类中。

JCTree类中有如下3个重要的属性项。
1.Ttree tag:每个语法节点都会用一个整形常数表示，并且每个节点类型的数值是在前一个的基础上加1。顶层节点TOPLEVEL是1，而IMPORT节点等于TOPLEVEL加1，等于2.
2.pos：也是一个整数，它存储的是这个语法节点在源代码中的起始位置，一个文件的位置是0，而-1表示不存在。
3.type:它表示的是这个节点是什么Java类型，如是int、float还是String.

语义分析

在得到结构化可操作的语法树后，还需要经过语义分析器给这棵语法树做一些处理，如给类添加默认的构造函数，检查变量在使用前是否已经初始化，将一些常量合并处理，检查操作变量类型是否匹配，检查异常是否已经捕获或抛出，解除java语法糖等等。
一般有以下几个步骤：
1.将Java类中的符号输入到符号表。主要由com.sun.tools.javac.comp.Enter类来完成，首先把所有类中出现的符号输入到类自身的符号表中，所有类符号、类的参数类型符号、超类符号和继承的接口类型符号都存着到一个未处理的列表中，然后在MemberEnter.completer()方法中奖未处理列表中所有类都解析到各自的类符号表中。Enter类解析中会给类添加默认构造函数。
2.处理注解，由com.sun.tools.javac.processing.JavacProcessingEnvironment类完成
3.进行标注com.sun.tools.javac.comp.Attr，检查语义的合法性并进行逻辑判断。如变量的类型是否匹配，使用前是否已经初始化等。
4.进行数据流分析，检查变量在使用前是否已经被正确赋值，保证final修饰变量不会被重复赋值，确定方法的返回值类型，异常需要被捕获或者抛出，所有的语句都要被执行到（指检查是否有语句出现在return方法的后面）
5.执行com.suntools.javac.comp.Flow,可以总结为去掉无用的代码，如用假的if代码块；变量的自动转换；去除语法糖，如foreach变成普通for循环。

代码生成器

把修饰后的语法树生成最终的Java字节码，通过com.sun.tools.javac.jvm.Gen类遍历语法树来生成。有以下两个步骤：
1.将Java方法中的代码块转化成符合JVM语法的命令形式，JVM的操作都是基于栈的，所有的操作都必须经过出栈和进栈来完成。
2.按照JVM的文件组装格式讲字节码输出到以class为扩展名的文件中
这里还有两个辅助类：
1.Items，这个类表示任何可寻址的操作项，包括本地变量、类实例变量或者常量池中用户自定义的常量等。
2.Code,存储生成的字节码，并提供一些能够映射操作码的方法。
示例说明：

public class Daima{
  public static void main(String[] args){
    int rt = add(1,2);
}

public static int add(Integer a, Integer b){
  return a+b;
}
}

重点说明add方法是如何转成字节码，这个方法中有一个加法表达式，JVM是基于栈来操作数值的，所以要执行一个二元操作，必须将两个数值a和b放到操作栈，然后利用加法操作符执行加法操作，将加法的结果放到当前栈的栈项，最后将这个结果返回给调用者。

一张图总结Javac编译过程：

QQ图片20180722232142.png