Fixed some bugs in object code parsing.

lib/build.gradle.kts

@@ -92,7 +92,7 @@ val generateOpcodes = tasks.register("generateOpcodes") {
 
 fun opcodeToCode(writer: PrintWriter, opcode: Map<String, Any>) {
     val code = (opcode["code"] as String).drop(2).toInt(16)
-    val codeStr = code.toString(16).padStart(2, '0')
+    val codeStr = code.toString(16).toUpperCase().padStart(2, '0')
     val mnemonic = opcode["mnemonic"] as String? ?: "unknown_$codeStr"
     val description = opcode["description"] as String?
     val stack = opcode["stack"] as String?
@@ -119,6 +119,7 @@ fun opcodeToCode(writer: PrintWriter, opcode: Map<String, Any>) {
         in 0xF900..0xF9FF -> "OPCODES_F9"
         else -> error("Invalid opcode $codeStr ($mnemonic).")
     }
+    val indexStr = (code and 0xFF).toString(16).toUpperCase().padStart(2, '0')
 
     writer.println(
         """
@@ -128,7 +129,7 @@ fun opcodeToCode(writer: PrintWriter, opcode: Map<String, Any>) {
         |    ${description?.let { "\"$it\"" }},
         |    $params,
         |    $stackInteraction,
-        |).also { ${array}[0x$codeStr] = it }""".trimMargin()
+        |).also { ${array}[0x$indexStr] = it }""".trimMargin()
     )
 }
 

lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/dataFlowAnalysis/GetStackValue.kt

@@ -6,7 +6,7 @@ import world.phantasmal.lib.assembly.*
 private val logger = KotlinLogging.logger {}
 
 /**
- * Computes the possible values of a stack element at the nth position from the top right before a
+ * Computes the possible values of a stack element at the nth position from the top, right before a
  * specific instruction.
  */
 fun getStackValue(cfg: ControlFlowGraph, instruction: Instruction, position: Int): ValueSet {

lib/src/commonMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt

@@ -106,8 +106,14 @@ expect class Buffer {
     fun fill(value: Byte): Buffer
 
     companion object {
+        /**
+         * Returns a new buffer the given initial capacity and size 0.
+         */
         fun withCapacity(initialCapacity: Int, endianness: Endianness = Endianness.Little): Buffer
 
+        /**
+         * Returns a new buffer with an initial size and capacity of [initialSize].
+         */
         fun withSize(initialSize: Int, endianness: Endianness = Endianness.Little): Buffer
 
         fun fromByteArray(array: ByteArray, endianness: Endianness = Endianness.Little): Buffer

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/ObjectCode.kt

@@ -6,6 +6,7 @@ import world.phantasmal.core.PwResultBuilder
 import world.phantasmal.core.Severity
 import world.phantasmal.lib.assembly.*
 import world.phantasmal.lib.assembly.dataFlowAnalysis.ControlFlowGraph
+import world.phantasmal.lib.assembly.dataFlowAnalysis.ValueSet
 import world.phantasmal.lib.assembly.dataFlowAnalysis.getRegisterValue
 import world.phantasmal.lib.assembly.dataFlowAnalysis.getStackValue
 import world.phantasmal.lib.buffer.Buffer
@@ -22,6 +23,9 @@ val SEGMENT_PRIORITY = mapOf(
     SegmentType.Data to 0,
 )
 
+/**
+ * These functions are built into the client and can optionally be overridden on BB.
+ */
 val BUILTIN_FUNCTIONS = setOf(
     60,
     70,
@@ -45,8 +49,8 @@ fun parseObjectCode(
     objectCode: Buffer,
     labelOffsets: IntArray,
     entryLabels: Set<Int>,
-    lenient: Boolean,
     dcGcFormat: Boolean,
+    lenient: Boolean,
 ): PwResult<List<Segment>> {
     val cursor = BufferCursor(objectCode)
     val labelHolder = LabelHolder(labelOffsets)
@@ -215,27 +219,35 @@ private fun findAndParseSegments(
 
                         is RegTupRefType -> {
                             // Never on the stack.
-                            val arg = instruction.args[i]
+                            var firstRegister: ValueSet? = null
 
                             for (j in param.type.registerTuples.indices) {
                                 val regTup = param.type.registerTuples[j]
 
                                 if (regTup.type is ILabelType) {
-                                    val labelValues = getRegisterValue(
+                                    if (firstRegister == null) {
-                                        cfg,
+                                        firstRegister = getStackValue(cfg, instruction, i)
-                                        instruction,
+                                    }
-                                        arg.value as Int + j,
-                                    )
 
-                                    if (labelValues.size <= 10) {
+                                    for (reg in firstRegister) {
-                                        for (label in labelValues) {
+                                        val labelValues = getRegisterValue(
-                                            newLabels[label] = SegmentType.Instructions
+                                            cfg,
+                                            instruction,
+                                            reg + j,
+                                        )
+
+                                        if (labelValues.size <= 10) {
+                                            for (label in labelValues) {
+                                                newLabels[label] = SegmentType.Instructions
+                                            }
                                         }
                                     }
                                 }
                             }
                         }
                     }
+
+                    i++
                 }
             }
         }
@@ -378,7 +390,7 @@ private fun parseInstructionsSegment(
         val mainOpcode = cursor.u8()
 
         val fullOpcode = when (mainOpcode.toInt()) {
-            0xF8, 0xF9 -> ((mainOpcode.toUInt() shl 8) or cursor.u8().toUInt()).toInt()
+            0xF8, 0xF9 -> ((mainOpcode.toInt() shl 8) or cursor.u8().toInt())
             else -> mainOpcode.toInt()
         }
 
@@ -479,6 +491,8 @@ private fun parseInstructionArguments(
     val args = mutableListOf<Arg>()
 
     if (opcode.stack != StackInteraction.Pop) {
+        var varargCount = 0
+
         for (param in opcode.params) {
             when (param.type) {
                 is ByteType ->
@@ -521,6 +535,7 @@ private fun parseInstructionArguments(
                 }
 
                 is ILabelVarType -> {
+                    varargCount++
                     val argSize = cursor.u8()
                     args.addAll(cursor.u16Array(argSize.toInt()).map { Arg(it.toInt()) })
                 }
@@ -532,6 +547,7 @@ private fun parseInstructionArguments(
                 }
 
                 is RegRefVarType -> {
+                    varargCount++
                     val argSize = cursor.u8()
                     args.addAll(cursor.u8Array(argSize.toInt()).map { Arg(it.toInt()) })
                 }
@@ -539,6 +555,12 @@ private fun parseInstructionArguments(
                 else -> error("Parameter type ${param.type} not implemented.")
             }
         }
+
+        val minExpectedArgs = opcode.params.size - varargCount
+
+        check(args.size >= minExpectedArgs) {
+            "Expected to parse at least $minExpectedArgs, only parsed ${args.size}."
+        }
     }
 
     return args

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt

@@ -67,8 +67,8 @@ fun parseBinDatToQuest(
         bin.objectCode,
         bin.labelOffsets,
         extractScriptEntryPoints(objects, npcs),
-        lenient,
         bin.format == BinFormat.DC_GC,
+        lenient,
     )
 
     rb.addResult(objectCodeResult)

lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/ObjectCode.kt

@@ -0,0 +1,43 @@
+package world.phantasmal.lib.fileFormats.quest
+
+import world.phantasmal.core.Success
+import world.phantasmal.lib.assembly.InstructionSegment
+import world.phantasmal.lib.assembly.OP_BB_MAP_DESIGNATE
+import world.phantasmal.lib.assembly.OP_SET_EPISODE
+import world.phantasmal.lib.buffer.Buffer
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class ObjectCode {
+    @Test
+    fun minimal() {
+        val buffer = Buffer.fromByteArray(ubyteArrayOf(
+            0xF8u, 0xBCu, 0x01u, 0x00u, 0x00u, 0x00u,        // set_episode 1
+            0xF9u, 0x51u, 0x03u, 0x15u, 0x00u, 0x02u, 0x00u, // bb_map_designate 3, 21, 2, 0
+            0x01u                                            // ret
+        ).toByteArray())
+
+        val result = parseObjectCode(
+            buffer,
+            labelOffsets = intArrayOf(0),
+            entryLabels = setOf(0),
+            dcGcFormat = false,
+            lenient = false
+        )
+
+        assertTrue(result is Success)
+        assertTrue(result.problems.isEmpty())
+
+        val segments = result.value
+        val segment = segments[0]
+
+        assertTrue(segment is InstructionSegment)
+        assertEquals(OP_SET_EPISODE, segment.instructions[0].opcode)
+        assertEquals(1, segment.instructions[0].args[0].value)
+        assertEquals(OP_BB_MAP_DESIGNATE, segment.instructions[1].opcode)
+        assertEquals(3, segment.instructions[1].args[0].value)
+        assertEquals(21, segment.instructions[1].args[1].value)
+        assertEquals(2, segment.instructions[1].args[2].value)
+    }
+}