The assembler now detects when too few arguments are passed to an opcode again.

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<Opcode?> = Array(256) { null }")
@@ -134,10 +136,20 @@ fun opcodeToCode(writer: PrintWriter, opcode: Map<String, Any>) {
     }
 
     @Suppress("UNCHECKED_CAST")
-    val params = paramsToCode(opcode["params"] as List<Map<String, Any>>, 4)
+    val params = opcode["params"] as List<Map<String, Any>>
+    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<String, Any>) {
         """
         |
         |val $valName = Opcode(
-        |    0x$codeStr,
+        |    code = 0x$codeStr,
-        |    "$mnemonic",
+        |    mnemonic = "$mnemonic",
-        |    $doc,
+        |    doc = $doc,
-        |    $params,
+        |    params = $paramsStr,
-        |    $stackInteraction,
+        |    stack = $stackInteraction,
+        |    varargs = $varargs,
+        |    known = $known,
         |).also { ${array}[0x$indexStr] = it }""".trimMargin()
     )
 }
@@ -165,12 +179,12 @@ fun paramsToCode(params: List<Map<String, Any>>, 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"

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt

@@ -412,7 +412,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
         srcLocs: MutableList<SrcLoc>,
         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<String>, 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<String>, 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<String>, 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(

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<Arg>()
                     paramToArgs.add(pArgs)
 
-                    // Variable length arguments are always last, so we can just gobble up all arguments
+                    // Variable length arguments are always last, so we can just gobble up all
-                    // from this point.
+                    // arguments from this point.
-                    if (type === ILabelVarType || type === RegRefVarType) {
+                    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])

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Disassembly.kt

@@ -180,10 +180,7 @@ private fun addTypeToArgs(params: List<Param>, args: List<Arg>): List<ArgWithTyp
     // Deal with varargs.
     val lastParam = params.lastOrNull()
 
-    if (
+    if (lastParam?.varargs == true) {
-        lastParam != null &&
-        (lastParam.type == ILabelVarType || lastParam.type == RegRefVarType)
-    ) {
         for (i in argsWithType.size until args.size) {
             argsWithType.add(ArgWithType(args[i], lastParam.type))
         }

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Opcode.kt

@@ -16,7 +16,9 @@ private val UNKNOWN_OPCODE_MNEMONIC_REGEX = Regex("""^unknown_((f8|f9)?[0-9a-f]{
 /**
  * Abstract super type of all types.
  */
-open class AnyType
+sealed class AnyType {
+    object Instance : AnyType()
+}
 
 /**
  * Purely abstract super type of all value types.
@@ -46,7 +48,9 @@ object FloatType : ValueType()
 /**
  * Abstract super type of all label types.
  */
-open class LabelType : ValueType()
+sealed class LabelType : ValueType() {
+    object Instance : LabelType()
+}
 
 /**
  * Named reference to an instruction.
@@ -116,7 +120,12 @@ class Param(
      * register reference.
      */
     val access: ParamAccess?,
-)
+) {
+    /**
+     * Whether or not this parameter takes a variable number of arguments.
+     */
+    val varargs: Boolean = type === ILabelVarType || type === RegRefVarType
+}
 
 enum class StackInteraction {
     Push,
@@ -148,17 +157,20 @@ class Opcode internal constructor(
      * Stack interaction.
      */
     val stack: StackInteraction?,
+    /**
+     * Whether or not the last parameter of this opcode takes a variable number of arguments.
+     */
+    val varargs: Boolean,
+    /**
+     * Whether or not the working of this opcode is known.
+     */
+    val known: Boolean,
 ) {
     /**
      * Byte size of the opcode, either 1 or 2.
      */
     val size: Int = if (code < 0xFF) 1 else 2
 
-    /**
-     * Whether or not the working of this opcode is known.
-     */
-    val known: Boolean = !mnemonic.startsWith("unknown_")
-
     override fun equals(other: Any?): Boolean = this === other
 
     override fun hashCode(): Int = code
@@ -189,7 +201,15 @@ private fun getOpcode(code: Int, index: Int, opcodes: Array<Opcode?>): 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
     }
 

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",
         )
     }

lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt

@@ -20,7 +20,7 @@ fun toInstructions(assembly: String): List<InstructionSegment> {
 }
 
 fun <T> assertDeepEquals(expected: List<T>, actual: List<T>, 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 <K, V> assertDeepEquals(
     actual: Map<K, V>,
     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 <K, V> 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())