大端字節序碼流中取出2字節

在這篇文章中，我們將看到如何為我們的語言生成字節碼。 到目前為止，我們已經看到了如何構建一種語言來表達我們想要的東西，如何驗證該語言，如何為該語言構建編輯器，但實際上我們還不能運行代碼。 是時候解決這個問題了。 通過為JVM進行編譯，我們的代碼將能夠在各種平臺上運行。 對我來說聽起來很棒！

建立自己的語言的系列

以前的帖子：

建立一個詞法分析器

建立一個解析器

創建帶有語法突出顯示的編輯器

使用自動補全功能構建編輯器

將解析樹映射到抽象語法樹

建模轉換

驗證方式

代碼在GitHub上的標簽為08_bytecode

添加打印聲明

在跳入字節碼生成之前，我們只需在我們的語言中添加一條打印語句即可。 這很容易：我們只需要在詞法分析器和解析器定義中更改幾行，就可以了。

// Changes to lexer PRINT : 'print';// Changes to parser statement : varDeclaration # varDeclarationStatement| assignment # assignmentStatement| print # printStatement ;print : PRINT LPAREN expression RPAREN ;

我們的編譯器的一般結構

讓我們從編譯器的入口點開始。 我們將從標準輸入或文件中獲取代碼（將被指定為第一個參數）。 一旦獲得代碼，我們將嘗試構建AST并檢查詞匯和語法錯誤。 如果沒有，我們將驗證AST并檢查語義錯誤。 如果仍然沒有錯誤，我們繼續進行字節碼生成。

fun main(args: Array<String>) {val code : InputStream? = when (args.size) {0 -> System.`in`1 -> FileInputStream(File(args[0]))else -> {System.err.println("Pass 0 arguments or 1")System.exit(1)null}}val parsingResult = SandyParserFacade.parse(code!!)if (!parsingResult.isCorrect()) {println("ERRORS:")parsingResult.errors.forEach { println(" * L${it.position.line}: ${it.message}") }return}val root = parsingResult.root!!println(root)val errors = root.validate()if (errors.isNotEmpty()) {println("ERRORS:")errors.forEach { println(" * L${it.position.line}: ${it.message}") }return}val bytes = JvmCompiler().compile(root, "MyClass")val fos = FileOutputStream("MyClass.class")fos.write(bytes)fos.close() }

請注意，在此示例中，我們始終會生成一個名為MyClass的類文件。 大概以后，我們想找到一種為類文件指定名稱的方法，但是現在這已經足夠了。

使用ASM生成字節碼

現在，讓我們潛入有趣的部分。 JvmCompiler的編譯方法是我們生成字節的地方，以后我們將其保存到類文件中。 我們如何產生這些字節？ 在ASM的幫助下，ASM是一個用于生成字節碼的庫。 現在，我們可以自己生成bytes數組，但要點是，它將涉及一些無聊的任務，例如生成類池結構。 ASM為我們做到了。 我們仍然需要對JVM的結構有所了解，但是我們可以生存下來而無需成為專家的精髓。

class JvmCompiler {fun compile(root: SandyFile, name: String) : ByteArray {// this is how we tell ASM that we want to start writing a new class. We ask it to calculate some values for usval cw = ClassWriter(ClassWriter.COMPUTE_FRAMES or ClassWriter.COMPUTE_MAXS)// here we specify that the class is in the format introduced with Java 8 (so it would require a JRE >= 8 to run)// we also specify the name of the class, the fact it extends Object and it implements no interfacescw.visit(V1_8, ACC_PUBLIC, name, null, "java/lang/Object", null)// our class will have just one method: the main method. We have to specify its signature// this string just says that it takes an array of Strings and return nothing (void)val mainMethodWriter = cw.visitMethod(ACC_PUBLIC or ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null)mainMethodWriter.visitCode()// labels are used by ASM to mark points in the codeval methodStart = Label()val methodEnd = Label()// with this call we indicate to what point in the method the label methodStart correspondsmainMethodWriter.visitLabel(methodStart)// Variable declarations:// we find all variable declarations in our code and we assign to them an index value// our vars map will tell us which variable name corresponds to which indexvar nextVarIndex = 0val vars = HashMap<String, Var>()root.specificProcess(VarDeclaration::class.java) {val index = nextVarIndex++vars[it.varName] = Var(it.type(vars), index)mainMethodWriter.visitLocalVariable(it.varName, it.type(vars).jvmDescription, null, methodStart, methodEnd, index)}// time to generate bytecode for all the statementsroot.statements.forEach { s ->when (s) {is VarDeclaration -> {// we calculate the type of the variable (more details later)val type = vars[s.varName]!!.type// the JVM is a stack based machine: it operated with values we have put on the stack// so as first thing when we meet a variable declaration we put its value on the stacks.value.pushAs(mainMethodWriter, vars, type)// now, depending on the type of the variable we use different operations to store the value// we put on the stack into the variable. Note that we refer to the variable using its index, not its namewhen (type) {IntType -> mainMethodWriter.visitVarInsn(ISTORE, vars[s.varName]!!.index)DecimalType -> mainMethodWriter.visitVarInsn(DSTORE, vars[s.varName]!!.index)else -> throw UnsupportedOperationException(type.javaClass.canonicalName)}}is Print -> {// this means that we access the field "out" of "java.lang.System" which is of type "java.io.PrintStream"mainMethodWriter.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;")// we push the value we want to print on the stacks.value.push(mainMethodWriter, vars)// we call the method println of System.out to print the value. It will take its parameter from the stack// note that we have to tell the JVM which variant of println to call. To do that we describe the signature of the method,// depending on the type of the value we want to print. If we want to print an int we will produce the signature "(I)V",// we will produce "(D)V" for a doublemainMethodWriter.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(${s.value.type(vars).jvmDescription})V", false)}is Assignment -> {val type = vars[s.varName]!!.type// This code is the same we have seen for variable declarationss.value.pushAs(mainMethodWriter, vars, type)when (type) {IntType -> mainMethodWriter.visitVarInsn(ISTORE, vars[s.varName]!!.index)DecimalType -> mainMethodWriter.visitVarInsn(DSTORE, vars[s.varName]!!.index)else -> throw UnsupportedOperationException(type.javaClass.canonicalName)}}else -> throw UnsupportedOperationException(s.javaClass.canonicalName)}}// We just says that here is the end of the methodmainMethodWriter.visitLabel(methodEnd)// And we had the return instructionmainMethodWriter.visitInsn(RETURN)mainMethodWriter.visitEnd()mainMethodWriter.visitMaxs(-1, -1)cw.visitEnd()return cw.toByteArray()}}

關于類型

好的，我們已經看到我們的代碼使用類型。 這是必需的，因為根據類型，我們需要使用不同的說明。 例如，將值放入整數變量中，我們使用ISTORE；而將值放入雙重變量中，我們使用DSTORE 。 當我們以整數調用System.out.println時，我們需要指定簽名（I）V，而當我們調用它以打印雙精度字符時，則需要指定（D）V 。

為此，我們需要了解每個表達式的類型。 在我們超簡單的語言中，我們現在僅使用int和double 。 在真實的語言中，我們可能想使用更多的類型，但這足以向您展示這些原理。

interface SandyType {// given a type we want to get the corresponding string used in the JVM// for example: int -> I, double -> D, Object -> Ljava/lang/Object; String -> [Ljava.lang.String;val jvmDescription: String }object IntType : SandyType {override val jvmDescription: Stringget() = "I" }object DecimalType : SandyType {override val jvmDescription: Stringget() = "D" }fun Expression.type(vars: Map<String, Var>) : SandyType {return when (this) {// an int literal has type int. Easy :)is IntLit -> IntTypeis DecLit -> DecimalType// the result of a binary expression depends on the type of the operandsis BinaryExpression -> {val leftType = left.type(vars)val rightType = right.type(vars)if (leftType != IntType && leftType != DecimalType) {throw UnsupportedOperationException()}if (rightType != IntType && rightType != DecimalType) {throw UnsupportedOperationException()}// an operation on two integers produces integersif (leftType == IntType && rightType == IntType) {return IntType// if at least a double is involved the result is a double} else {return DecimalType}}// when we refer to a variable the type is the type of the variableis VarReference -> vars[this.varName]!!.type// when we cast to a value, the resulting value is that type :)is TypeConversion -> this.targetType.toSandyType()else -> throw UnsupportedOperationException(this.javaClass.canonicalName)} }

表達方式

如我們所見，JVM是基于堆棧的計算機。 因此，每次我們想使用一個值時，都會將其壓入堆棧，然后執行一些操作。 讓我們看看如何將值推入堆棧

// Convert, if needed fun Expression.pushAs(methodWriter: MethodVisitor, vars: Map<String, Var>, desiredType: SandyType) {push(methodWriter, vars)val myType = type(vars)if (myType != desiredType) {if (myType == IntType && desiredType == DecimalType) {methodWriter.visitInsn(I2D)} else if (myType == DecimalType && desiredType == IntType) {methodWriter.visitInsn(D2I)} else {throw UnsupportedOperationException("Conversion from $myType to $desiredType")}} }fun Expression.push(methodWriter: MethodVisitor, vars: Map<String, Var>) {when (this) {// We have specific operations to push integers and double valuesis IntLit -> methodWriter.visitLdcInsn(Integer.parseInt(this.value))is DecLit -> methodWriter.visitLdcInsn(java.lang.Double.parseDouble(this.value))// to push a sum we first push the two operands and then invoke an operation which// depend on the type of the operands (do we sum integers or doubles?)is SumExpression -> {left.pushAs(methodWriter, vars, this.type(vars))right.pushAs(methodWriter, vars, this.type(vars))when (this.type(vars)) {IntType -> methodWriter.visitInsn(IADD)DecimalType -> methodWriter.visitInsn(DADD)else -> throw UnsupportedOperationException("Summing ${this.type(vars)}")}}is SubtractionExpression -> {left.pushAs(methodWriter, vars, this.type(vars))right.pushAs(methodWriter, vars, this.type(vars))when (this.type(vars)) {IntType -> methodWriter.visitInsn(ISUB)DecimalType -> methodWriter.visitInsn(DSUB)else -> throw UnsupportedOperationException("Summing ${this.type(vars)}")}}is DivisionExpression -> {left.pushAs(methodWriter, vars, this.type(vars))right.pushAs(methodWriter, vars, this.type(vars))when (this.type(vars)) {IntType -> methodWriter.visitInsn(IDIV)DecimalType -> methodWriter.visitInsn(DDIV)else -> throw UnsupportedOperationException("Summing ${this.type(vars)}")}}is MultiplicationExpression -> {left.pushAs(methodWriter, vars, this.type(vars))right.pushAs(methodWriter, vars, this.type(vars))when (this.type(vars)) {IntType -> methodWriter.visitInsn(IMUL)DecimalType -> methodWriter.visitInsn(DMUL)else -> throw UnsupportedOperationException("Summing ${this.type(vars)}")}}// to push a variable we just load the value from the symbol tableis VarReference -> {val type = vars[this.varName]!!.typewhen (type) {IntType -> methodWriter.visitVarInsn(ILOAD, vars[this.varName]!!.index)DecimalType -> methodWriter.visitVarInsn(DLOAD, vars[this.varName]!!.index)else -> throw UnsupportedOperationException(type.javaClass.canonicalName)}}// the pushAs operation take care of conversions, as neededis TypeConversion -> {this.value.pushAs(methodWriter, vars, this.targetType.toSandyType())}else -> throw UnsupportedOperationException(this.javaClass.canonicalName)} }

Gradle

我們還可以創建gradle任務來編譯源文件

main = "me.tomassetti.sandy.compiling.JvmKt"args = "$sourceFile"classpath = sourceSets.main.runtimeClasspath }

結論

我們沒有詳細介紹，我們急于瀏覽代碼。 我的目的只是給您概述用于生成字節碼的一般策略。 當然，如果您想構建一種嚴肅的語言，則需要做一些研究并理解JVM的內部，這是無可避免的。 我只是希望這個簡短的介紹足以使您了解到這并不那么令人恐懼或復雜，大多數人都認為。

翻譯自: https://www.javacodegeeks.com/2016/09/generating-bytecode.html

大端字節序碼流中取出2字節

總結

以上是生活随笔為你收集整理的大端字节序码流中取出2字节_产生字节码的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。