java开发C编译器：把C程序编译成java字节码

更详细的讲解和代码调试演示过程，请参看视频
用java开发C语言编译器

如果你对机器学习感兴趣，请参看一下链接：
机器学习：神经网络导论

我们已经完成了C语言解释器的基本开发，当下解释器已经能解释执行大部分C语言程序了，接下来我们进入C语言编译器的开发工作。

我们把C代码编译成java字节码，这样我们的C语言便具备了可跨品台属性。通过把C语言编译成java字节码，我们不但能够继续学习和掌握编译原理相关的算法技术，于此同时，还能深入理解java虚拟机的基本原理，此乃一举两得之妙。完成本节内容后，我们的编译器能把下面的C源程序编译成java 汇编代码：

void main() {
    printf("Hello World!");
}

上面代码编译后形成下面内容(CSourceToJava.j)：

.class public CSourceToJava
.super java/lang/Object

.method public static main([Ljava/lang/String;)V
    getstatic   java/lang/System/out Ljava/io/PrintStream;
    ldc "Hello World!"
    invokevirtual   java/io/PrintStream/println(Ljava/lang/String;)V
    return
.end method
.end class

上面代码是基于java标准的java汇编代码，我们编译器的目标就是把C源程序转义成java汇编，最后再通过java汇编编译器将汇编代码转换成16进制的字节码。

市面上有不少java汇编编译器，最常用的是Jasmine，我们这里使用的是一个国外大牛开发的编译器叫oolong, 该编译器是一个jar包，当我们的编译器生成上面的java汇编代码后，通过以下命令把汇编代码转换成java字节码：

java -cp oolong.jar COM.sootNsmoke.oolong.Oolong CSourceToJava.j

运行上面程序后，在本地目录下会生成一个名为CSourceToJava.class的十六进制文件，用java命令可以直接运行该文件内容：
java CSourceToJava
运行后结果为：
Hello World!

实际上，上面的java汇编代码等价于下面的java源程序：

public class CSourceToJava {
    public static void main(String[]) {
        System.out.println("Hello World");
    }
}

大家不难把java汇编代码中的指令和源程序中的代码对应起来，例如：
.class public CSourceToJava 对应于public class CSourceToJava
.method public static main 对应于public static void main(String[])
等等。

要理解java汇编语言及其逻辑结构，我们需要掌握java虚拟机的指令集以及虚拟机的运行机制，这些都是我们后面要非常深入的，耐心的，细致的去研究和学习的内容，在这里我们先一掠而过，我们先通过动手实践，获取第一手的感性认识，为后面的学习打下基础。

我们看看如何实现java汇编程序的生成，首先我们新增一个CodeGenerator类，代码如下：

package backend.Compiler;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.io.PrintWriter;

public class CodeGenerator {
    private static PrintWriter assemblyFile;
    private static int instructionCount = 0;

    protected static String programName = "CSourceToJava";


    public CodeGenerator() {

        String assemblyFileName = programName + ".j";

        try {
            assemblyFile = new PrintWriter(new PrintStream(new 
                    File(assemblyFileName)));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    public void emitDirective(Directive directive) {
        assemblyFile.println(directive.toString());
        assemblyFile.flush();
        ++instructionCount;
    }

    public void emitDirective(Directive directive, String operand) {
        assemblyFile.println(directive.toString() + " " + operand);
        assemblyFile.flush();
        ++instructionCount;
    }

    public void emitDirective(Directive directive, int operand) {
        assemblyFile.println(directive.toString() + " " + operand);
        ++instructionCount;
    }

    public void emitDirective(Directive directive, String operand1, String operand2) {
        assemblyFile.println(directive.toString() + " " + operand1 + " " + operand2);
        ++instructionCount;
    }

    public void emitDirective(Directive directive, String operand1, String operand2, String operand3) {
        assemblyFile.println(directive.toString() + " " + operand1 + " " + operand2 + " " + operand3);
        ++instructionCount;
    }

    public void emit(Instruction opcode) {
        assemblyFile.println("\t" + opcode.toString());
        assemblyFile.flush();
        ++instructionCount;
    }

    public void emit(Instruction opcode, String operand) {
        assemblyFile.println("\t" + opcode.toString() + "\t" + operand);
        assemblyFile.flush();
        ++instructionCount;
    }

    public void emitBlankLine() {
        assemblyFile.println();
        assemblyFile.flush();
    }

    public void finish() {
        assemblyFile.close();
    }


}

该类先创建一个以.j结尾的文件，然后通过PrintWriter 把内容写入到该文件中，在该类中有很多以emit开头的函数，这些函数的作用就是把相关的java汇编指令写入文件。

在java汇编代码中，以符号”.”开头的，我们称之为宏指令，例如：
.class public CSourceToJava
.super java/lang/Object

java汇编代码中有一类专门指令叫操作符，例如：
getstatic
ldc
等等。

以上这些指令的作用我们会在后续课程中详细研究，在此先掠过。于是根据宏指令，我们有对应的以下java代码：

package backend.Compiler;

public enum Directive {
    CLASS_PUBLIC(".class public"),
    END_CLASS(".end class"),
    SUPER(".super"),
    FIELD_PRIVATE_STATIC(".field private static"),
    METHOD_STATIC(".method static"),
    METHOD_PUBLIC(".method public"),
    METHOD_PUBBLIC_STATIC(".method public static"),
    END_METHOD(".end method"),
    LIMIT_LOCALS(".limit locals"),
    LIMIT_STACK(".limit stack"),
    VAR(".var"),
    LINE(".line");

    private String text;

    Directive(String text) {
        this.text = text;
    }

    public String toString() {
        return text;
    }
}

根据操作符指令，我们也有对应的java类：

package backend.Compiler;

public enum Instruction {
    LDC("ldc"),

    GETSTATIC("getstatic"),

    INVOKEVIRTUAL("invokevirtual"),
    RETURN("return");

    private String text;
    Instruction(String s) {
        this.text = s;
    }

    public String toString() {
        return text;
    }
}

有了上面的基础后，我们就可以把java汇编代码的基础部分编译出来，我们构造一个 ProgramGenerator 类，它继承与CodeGenerator:

package backend.Compiler;

public class ProgramGenerator extends CodeGenerator {
    private static ProgramGenerator instance = null;

    public static ProgramGenerator getInstance() {
        if (instance == null) {
            instance = new ProgramGenerator();
        }

        return instance;
    }

    private ProgramGenerator()  {

    }

    public void generate() {
        emitDirective(Directive.CLASS_PUBLIC, programName);
        emitDirective(Directive.SUPER, "java/lang/Object");
        generateMainMethod();
    }

    private void generateMainMethod() {
        emitBlankLine();
        emitDirective(Directive.METHOD_PUBBLIC_STATIC, "main([Ljava/lang/String;)V");

    }

    public void finish() {
        emitDirective(Directive.END_METHOD);
        emitDirective(Directive.END_CLASS);

        super.finish();
    }
}

上面的ProgramGenerator可以生成java汇编源码中的以下部分：

.class public CSourceToJava
.super java/lang/Object

.method public static main([Ljava/lang/String;)V

.end method
.end class

接下来我们要生成打印字符串的部分，这部分工作在解析printf(“Hello World!”);这条语句时可以生成。在前面的课程中，我们已经详细解析如何实现printf库函数调用，它的实现是在ClibCall.java 中，我们就在对该库函数的解析中，生成对应的java汇编代码，因此实现代码如下，在ClibCall.java中：

 private Object handlePrintfCall() {
        ArrayList<Object> argsList = FunctionArgumentList.getFunctionArgumentList().getFuncArgList(false);
        String argStr = (String)argsList.get(0);
        String formatStr = "";

        int i = 0;
        int argCount = 1;
        while (i < argStr.length()) {
            if (argStr.charAt(i) == '%' && i+1 < argStr.length() && 
                    argStr.charAt(i+1) == 'd') {
                i += 2;
                formatStr += argsList.get(argCount);
                argCount++;
            } else {
                formatStr += argStr.charAt(i);
                i++;
            }
        }

        System.out.println(formatStr);

        generateJavaAssemblyForPrintf(formatStr);

        return null;
    }

    private void generateJavaAssemblyForPrintf(String s) {
        ProgramGenerator generator = ProgramGenerator.getInstance();
        generator.emit(Instruction.GETSTATIC, "java/lang/System/out Ljava/io/PrintStream;");
        generator.emit(Instruction.LDC, "\"" + s + "\"");
        String printMethod = "java/io/PrintStream/println(Ljava/lang/String;)V";
        generator.emit(Instruction.INVOKEVIRTUAL, printMethod);
        generator.emit(Instruction.RETURN);

    }

generateJavaAssemblyForPrintf 这个调用就用于生成输出字符串的java汇编源码，上面这段代码运行后，生成的java汇编代码为：

    getstatic   java/lang/System/out Ljava/io/PrintStream;
    ldc "Hello World!"
    invokevirtual   java/io/PrintStream/println(Ljava/lang/String;)V
    return

结论：
本节，我们初步接触了java汇编语言，了解到一些有关java虚拟机的宏指令和操作符指令，并通过一个实例，把C语言编写的代码转换成了java汇编代码，最后再通过汇编编译器把生成的java汇编转换成虚拟机可以加载执行的十六进制java字节码，通过实践，先让大家获得第一手感性认识，在后面的课程中，我们将深入研究java虚拟机的运行机制，并不断完善我们编译器的实现，最终能让我们的编译器能够正确的将C源程序编译成可运行的java字节码。

更详细的讲解和代码调试演示请参看视频。

更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：