From 949af36381b33a7824e0750c713c060ad087048c Mon Sep 17 00:00:00 2001 From: Daan Vanden Bosch Date: Wed, 21 Apr 2021 16:36:31 +0200 Subject: [PATCH] The assembler now detects when too few arguments are passed to an opcode again. --- lib/build.gradle.kts | 32 +++++++++++----- .../world/phantasmal/lib/asm/Assembly.kt | 14 +++---- .../world/phantasmal/lib/asm/BytecodeIr.kt | 16 ++++---- .../world/phantasmal/lib/asm/Disassembly.kt | 5 +-- .../kotlin/world/phantasmal/lib/asm/Opcode.kt | 38 ++++++++++++++----- .../lib/fileFormats/quest/QuestTests.kt | 3 +- .../world/phantasmal/lib/test/TestUtils.kt | 8 ++-- 7 files changed, 72 insertions(+), 44 deletions(-) diff --git a/lib/build.gradle.kts b/lib/build.gradle.kts index 65ddbb52..e79cdd9b 100644 --- a/lib/build.gradle.kts +++ b/lib/build.gradle.kts @@ -98,6 +98,8 @@ val generateOpcodes = tasks.register("generateOpcodes") { outputFile.printWriter() .use { writer -> + writer.println("@file:Suppress(\"unused\")") + writer.println() writer.println("package $packageName") writer.println() writer.println("val OPCODES: Array = Array(256) { null }") @@ -134,10 +136,20 @@ fun opcodeToCode(writer: PrintWriter, opcode: Map) { } @Suppress("UNCHECKED_CAST") - val params = paramsToCode(opcode["params"] as List>, 4) + val params = opcode["params"] as List> + val paramsStr = paramsToCode(params, 4) + + val lastParam = params.lastOrNull() + val varargs = lastParam != null && when (lastParam["type"]) { + null -> error("No type for last parameter of $mnemonic opcode.") + "instruction_label_var", "reg_ref_var" -> true + else -> false + } + + val known = "mnemonic" in opcode val array = when (code) { - in 0..0xFF -> "OPCODES" + in 0x00..0xFF -> "OPCODES" in 0xF800..0xF8FF -> "OPCODES_F8" in 0xF900..0xF9FF -> "OPCODES_F9" else -> error("Invalid opcode $codeStr ($mnemonic).") @@ -148,11 +160,13 @@ fun opcodeToCode(writer: PrintWriter, opcode: Map) { """ | |val $valName = Opcode( - | 0x$codeStr, - | "$mnemonic", - | $doc, - | $params, - | $stackInteraction, + | code = 0x$codeStr, + | mnemonic = "$mnemonic", + | doc = $doc, + | params = $paramsStr, + | stack = $stackInteraction, + | varargs = $varargs, + | known = $known, |).also { ${array}[0x$indexStr] = it }""".trimMargin() ) } @@ -165,12 +179,12 @@ fun paramsToCode(params: List>, indent: Int): String { return params.joinToString(",\n", "listOf(\n", ",\n${i})") { param -> @Suppress("UNCHECKED_CAST") val type = when (param["type"]) { - "any" -> "AnyType()" + "any" -> "AnyType.Instance" "byte" -> "ByteType" "short" -> "ShortType" "int" -> "IntType" "float" -> "FloatType" - "label" -> "LabelType()" + "label" -> "LabelType.Instance" "instruction_label" -> "ILabelType" "data_label" -> "DLabelType" "string_label" -> "SLabelType" diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt index e8317e34..419accc6 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt @@ -412,7 +412,6 @@ private class Assembler(private val asm: List, private val inlineStackAr srcLocs: MutableList, stack: Boolean, ): Boolean { - var varargs = false var argCount = 0 var semiValid = true var shouldBeArg = true @@ -428,15 +427,10 @@ private class Assembler(private val asm: List, private val inlineStackAr if (paramI < opcode.params.size) { val param = opcode.params[paramI] - if (param.type === ILabelVarType || param.type === RegRefVarType) { - // A varargs parameter is always the last parameter. - varargs = true - } - if (tokenizer.type === Token.ArgSeparator) { if (shouldBeArg) { addError("Expected an argument.") - } else if (!varargs) { + } else if (!param.varargs) { paramI++ } @@ -653,7 +647,8 @@ private class Assembler(private val asm: List, private val inlineStackAr val errorLength = prevCol + prevLen - startCol - if (!varargs && argCount != paramCount) { + if (!opcode.varargs && argCount != paramCount) { + semiValid = argCount >= paramCount addError( startCol, errorLength, @@ -661,7 +656,8 @@ private class Assembler(private val asm: List, private val inlineStackAr if (paramCount == 1) "" else "s" }, got $argCount.", ) - } else if (varargs && argCount < paramCount) { + } else if (opcode.varargs && argCount < paramCount) { + semiValid = argCount >= paramCount - 1 // TODO: This check assumes we want at least 1 argument for a vararg parameter. // Is this correct? addError( diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt index f79212e1..e0def4c1 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt @@ -121,13 +121,13 @@ class Instruction( if (opcode.stack !== StackInteraction.Pop) { for (i in opcode.params.indices) { - val type = opcode.params[i].type + val param = opcode.params[i] val pArgs = mutableListOf() paramToArgs.add(pArgs) - // Variable length arguments are always last, so we can just gobble up all arguments - // from this point. - if (type === ILabelVarType || type === RegRefVarType) { + // Variable length arguments are always last, so we can just gobble up all + // arguments from this point. + if (param.varargs) { check(i == opcode.params.lastIndex) for (j in i until args.size) { @@ -150,11 +150,11 @@ class Instruction( val argSrcLocs = srcLoc?.args ?: return emptyList() - val type = opcode.params[paramIndex].type + val param = opcode.params[paramIndex] // Variable length arguments are always last, so we can just gobble up all SrcLocs from // paramIndex onward. - return if (type === ILabelVarType || type === RegRefVarType) { + return if (param.varargs) { argSrcLocs.drop(paramIndex) } else { listOf(argSrcLocs[paramIndex]) @@ -171,11 +171,11 @@ class Instruction( return emptyList() } - val type = opcode.params[paramIndex].type + val param = opcode.params[paramIndex] // Variable length arguments are always last, so we can just gobble up all SrcLocs from // paramIndex onward. - return if (type === ILabelVarType || type === RegRefVarType) { + return if (param.varargs) { argSrcLocs.drop(paramIndex) } else { listOf(argSrcLocs[paramIndex]) diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Disassembly.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Disassembly.kt index 17cdc7fc..88f5943a 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Disassembly.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Disassembly.kt @@ -180,10 +180,7 @@ private fun addTypeToArgs(params: List, args: List): List): Opcode { var opcode = opcodes[index] if (opcode == null) { - opcode = Opcode(code, "unknown_${code.toString(16)}", null, emptyList(), null) + opcode = Opcode( + code, + mnemonic = "unknown_${code.toString(16)}", + doc = null, + params = emptyList(), + stack = null, + varargs = false, + known = false, + ) opcodes[index] = opcode } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt index 0b383568..05435ffb 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt @@ -181,7 +181,8 @@ class QuestTests : LibTestSuite { // - It's ID is 33554458, according to the .bin, which is too big for the .qst format. // - It has an NPC with script label 100, but the code at that label is invalid. "/solo/ep1/side/26.qst", - // PRS-compressed file seems corrupt in Gallon's Plan, but qedit has no issues with it. + // TODO: PRS-compressed file seems corrupt in Gallon's Plan, but qedit has no issues + // with it. "/solo/ep1/side/quest035.qst", ) } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt index 424ac27e..2731f1d1 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt @@ -20,7 +20,7 @@ fun toInstructions(assembly: String): List { } fun assertDeepEquals(expected: List, actual: List, assertDeepEquals: (T, T) -> Unit) { - assertEquals(expected.size, actual.size) + assertEquals(expected.size, actual.size, "Unexpected list size") for (i in expected.indices) { assertDeepEquals(expected[i], actual[i]) @@ -32,7 +32,7 @@ fun assertDeepEquals( actual: Map, assertDeepEquals: (V, V) -> Unit, ) { - assertEquals(expected.size, actual.size) + assertEquals(expected.size, actual.size, "Unexpected map size") for ((key, value) in expected) { assertTrue(key in actual) @@ -41,7 +41,7 @@ fun assertDeepEquals( } fun assertDeepEquals(expected: Buffer, actual: Buffer) { - assertEquals(expected.size, actual.size) + assertEquals(expected.size, actual.size, "Unexpected buffer size") for (i in 0 until expected.size) { assertEquals(expected.getByte(i), actual.getByte(i)) @@ -49,7 +49,7 @@ fun assertDeepEquals(expected: Buffer, actual: Buffer) { } fun assertDeepEquals(expected: Cursor, actual: Cursor) { - assertEquals(expected.size, actual.size) + assertEquals(expected.size, actual.size, "Unexpected cursor size") while (expected.hasBytesLeft()) { assertEquals(expected.byte(), actual.byte())