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字节码。

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

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