mirror of
https://github.com/DaanVandenBosch/phantasmal-world.git
synced 2025-04-04 22:58:29 +08:00
Fixed a bug in the AssemblyWorker and tokenizer. Added several ASM-related tests.
This commit is contained in:
Daan Vanden Bosch
parent
c8c12f298f
commit
20ccbfc587
@ -296,6 +296,7 @@ private class LineTokenizer(private var line: String) {
|
||||
var prevWasBackSpace = false
|
||||
var terminated = false
|
||||
|
||||
loop@ // Use label as workaround for https://youtrack.jetbrains.com/issue/KT-43943.
|
||||
while (hasNext()) {
|
||||
when (peek()) {
|
||||
'\\' -> {
|
||||
@ -304,7 +305,7 @@ private class LineTokenizer(private var line: String) {
|
||||
'"' -> {
|
||||
if (!prevWasBackSpace) {
|
||||
terminated = true
|
||||
break
|
||||
break@loop
|
||||
}
|
||||
|
||||
prevWasBackSpace = false
|
||||
@ -317,13 +318,14 @@ private class LineTokenizer(private var line: String) {
|
||||
next()
|
||||
}
|
||||
|
||||
val lenWithoutQuotes = markedLen()
|
||||
val value = slice().replace("\\\"", "\"").replace("\\n", "\n")
|
||||
|
||||
return if (terminated) {
|
||||
next()
|
||||
Token.Str(col, markedLen() + 2, value)
|
||||
Token.Str(col, lenWithoutQuotes + 2, value)
|
||||
} else {
|
||||
Token.UnterminatedString(col, markedLen() + 1, value)
|
||||
Token.UnterminatedString(col, lenWithoutQuotes + 1, value)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -121,7 +121,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
private fun addInstruction(
|
||||
opcode: Opcode,
|
||||
args: List<Arg>,
|
||||
stackArgs: List<Arg>,
|
||||
token: Token?,
|
||||
argTokens: List<Token>,
|
||||
stackArgTokens: List<Token>,
|
||||
@ -150,8 +149,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
args = argTokens.map {
|
||||
SrcLoc(lineNo, it.col, it.len)
|
||||
},
|
||||
stackArgs = stackArgTokens.mapIndexed { i, sat ->
|
||||
StackArgSrcLoc(lineNo, sat.col, sat.len, stackArgs[i].value)
|
||||
stackArgs = stackArgTokens.map { sat ->
|
||||
SrcLoc(lineNo, sat.col, sat.len)
|
||||
},
|
||||
)
|
||||
)
|
||||
@ -386,7 +385,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
addError(
|
||||
identToken.col,
|
||||
errorLength,
|
||||
"Expected at least $paramCount argument ${if (paramCount == 1) "" else "s"}, got $argCount.",
|
||||
"Expected at least $paramCount argument${if (paramCount == 1) "" else "s"}, got $argCount.",
|
||||
)
|
||||
|
||||
return
|
||||
@ -411,7 +410,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
addInstruction(
|
||||
OP_ARG_PUSHB,
|
||||
listOf(arg),
|
||||
emptyList(),
|
||||
null,
|
||||
listOf(argToken),
|
||||
emptyList(),
|
||||
@ -420,7 +418,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
addInstruction(
|
||||
OP_ARG_PUSHR,
|
||||
listOf(arg),
|
||||
emptyList(),
|
||||
null,
|
||||
listOf(argToken),
|
||||
emptyList(),
|
||||
@ -435,7 +432,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
addInstruction(
|
||||
OP_ARG_PUSHB,
|
||||
listOf(arg),
|
||||
emptyList(),
|
||||
null,
|
||||
listOf(argToken),
|
||||
emptyList(),
|
||||
@ -451,7 +447,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
addInstruction(
|
||||
OP_ARG_PUSHW,
|
||||
listOf(arg),
|
||||
emptyList(),
|
||||
null,
|
||||
listOf(argToken),
|
||||
emptyList(),
|
||||
@ -462,7 +457,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
addInstruction(
|
||||
OP_ARG_PUSHL,
|
||||
listOf(arg),
|
||||
emptyList(),
|
||||
null,
|
||||
listOf(argToken),
|
||||
emptyList(),
|
||||
@ -473,7 +467,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
addInstruction(
|
||||
OP_ARG_PUSHL,
|
||||
listOf(Arg((arg.value as Float).toRawBits())),
|
||||
emptyList(),
|
||||
null,
|
||||
listOf(argToken),
|
||||
emptyList(),
|
||||
@ -484,7 +477,6 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
addInstruction(
|
||||
OP_ARG_PUSHS,
|
||||
listOf(arg),
|
||||
emptyList(),
|
||||
null,
|
||||
listOf(argToken),
|
||||
emptyList(),
|
||||
@ -502,12 +494,11 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
|
||||
}
|
||||
|
||||
val (args, argTokens) = insArgAndTokens.unzip()
|
||||
val (stackArgs, stackArgTokens) = stackArgAndTokens.unzip()
|
||||
val stackArgTokens = stackArgAndTokens.map { it.second }
|
||||
|
||||
addInstruction(
|
||||
opcode,
|
||||
args,
|
||||
stackArgs,
|
||||
identToken,
|
||||
argTokens,
|
||||
stackArgTokens,
|
||||
|
||||
@ -32,19 +32,19 @@ sealed class Segment(
|
||||
class InstructionSegment(
|
||||
labels: MutableList<Int>,
|
||||
val instructions: MutableList<Instruction>,
|
||||
srcLoc: SegmentSrcLoc,
|
||||
srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
|
||||
) : Segment(SegmentType.Instructions, labels, srcLoc)
|
||||
|
||||
class DataSegment(
|
||||
labels: MutableList<Int>,
|
||||
val data: Buffer,
|
||||
srcLoc: SegmentSrcLoc,
|
||||
srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
|
||||
) : Segment(SegmentType.Data, labels, srcLoc)
|
||||
|
||||
class StringSegment(
|
||||
labels: MutableList<Int>,
|
||||
var value: String,
|
||||
srcLoc: SegmentSrcLoc,
|
||||
srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
|
||||
) : Segment(SegmentType.String, labels, srcLoc)
|
||||
|
||||
/**
|
||||
@ -55,8 +55,8 @@ class Instruction(
|
||||
/**
|
||||
* Immediate arguments for the opcode.
|
||||
*/
|
||||
val args: List<Arg>,
|
||||
val srcLoc: InstructionSrcLoc?,
|
||||
val args: List<Arg> = emptyList(),
|
||||
val srcLoc: InstructionSrcLoc? = null,
|
||||
) {
|
||||
/**
|
||||
* Maps each parameter by index to its immediate arguments.
|
||||
@ -114,7 +114,7 @@ class Instruction(
|
||||
/**
|
||||
* Returns the source locations of the stack arguments for the parameter at the given index.
|
||||
*/
|
||||
fun getStackArgSrcLocs(paramIndex: Int): List<StackArgSrcLoc> {
|
||||
fun getStackArgSrcLocs(paramIndex: Int): List<SrcLoc> {
|
||||
val argSrcLocs = srcLoc?.stackArgs
|
||||
|
||||
if (argSrcLocs == null || paramIndex > argSrcLocs.lastIndex) {
|
||||
@ -189,7 +189,7 @@ data class Arg(val value: Any)
|
||||
/**
|
||||
* Position and length of related source assembly code.
|
||||
*/
|
||||
open class SrcLoc(
|
||||
class SrcLoc(
|
||||
val lineNo: Int,
|
||||
val col: Int,
|
||||
val len: Int,
|
||||
@ -200,15 +200,10 @@ open class SrcLoc(
|
||||
*/
|
||||
class InstructionSrcLoc(
|
||||
val mnemonic: SrcLoc?,
|
||||
val args: List<SrcLoc>,
|
||||
val stackArgs: List<StackArgSrcLoc>,
|
||||
val args: List<SrcLoc> = emptyList(),
|
||||
val stackArgs: List<SrcLoc> = emptyList(),
|
||||
)
|
||||
|
||||
/**
|
||||
* Locations of an instruction's stack arguments in the source assembly code.
|
||||
*/
|
||||
class StackArgSrcLoc(lineNo: Int, col: Int, len: Int, val value: Any) : SrcLoc(lineNo, col, len)
|
||||
|
||||
/**
|
||||
* Locations of a segment's labels in the source assembly code.
|
||||
*/
|
||||
|
||||
@ -89,6 +89,9 @@ class ControlFlowGraph(
|
||||
}
|
||||
|
||||
companion object {
|
||||
fun create(bytecodeIr: BytecodeIr): ControlFlowGraph =
|
||||
create(bytecodeIr.instructionSegments())
|
||||
|
||||
fun create(segments: List<InstructionSegment>): ControlFlowGraph {
|
||||
val cfg = ControlFlowGraphBuilder()
|
||||
|
||||
|
||||
@ -9,8 +9,8 @@ import world.phantasmal.lib.asm.OP_MAP_DESIGNATE_EX
|
||||
private val logger = KotlinLogging.logger {}
|
||||
|
||||
fun getMapDesignations(
|
||||
instructionSegments: List<InstructionSegment>,
|
||||
func0Segment: InstructionSegment,
|
||||
createCfg: () -> ControlFlowGraph,
|
||||
): Map<Int, Int> {
|
||||
val mapDesignations = mutableMapOf<Int, Int>()
|
||||
var cfg: ControlFlowGraph? = null
|
||||
@ -21,7 +21,7 @@ fun getMapDesignations(
|
||||
OP_MAP_DESIGNATE_EX.code,
|
||||
-> {
|
||||
if (cfg == null) {
|
||||
cfg = ControlFlowGraph.create(instructionSegments)
|
||||
cfg = createCfg()
|
||||
}
|
||||
|
||||
val areaId = getRegisterValue(cfg, inst, inst.args[0].value as Int)
|
||||
|
||||
@ -393,13 +393,13 @@ private fun parseInstructionsSegment(
|
||||
// Parse the arguments.
|
||||
try {
|
||||
val args = parseInstructionArguments(cursor, opcode, dcGcFormat)
|
||||
instructions.add(Instruction(opcode, args, null))
|
||||
instructions.add(Instruction(opcode, args))
|
||||
} catch (e: Exception) {
|
||||
if (lenient) {
|
||||
logger.error(e) {
|
||||
"Exception occurred while parsing arguments for instruction ${opcode.mnemonic}."
|
||||
}
|
||||
instructions.add(Instruction(opcode, emptyList(), null))
|
||||
instructions.add(Instruction(opcode, emptyList()))
|
||||
} else {
|
||||
throw e
|
||||
}
|
||||
|
||||
@ -9,6 +9,7 @@ import world.phantasmal.lib.Episode
|
||||
import world.phantasmal.lib.asm.BytecodeIr
|
||||
import world.phantasmal.lib.asm.InstructionSegment
|
||||
import world.phantasmal.lib.asm.OP_SET_EPISODE
|
||||
import world.phantasmal.lib.asm.dataFlowAnalysis.ControlFlowGraph
|
||||
import world.phantasmal.lib.asm.dataFlowAnalysis.getMapDesignations
|
||||
import world.phantasmal.lib.compression.prs.prsDecompress
|
||||
import world.phantasmal.lib.cursor.Cursor
|
||||
@ -105,7 +106,8 @@ fun parseBinDatToQuest(
|
||||
npc.episode = episode
|
||||
}
|
||||
|
||||
mapDesignations = getMapDesignations(instructionSegments, label0Segment)
|
||||
mapDesignations =
|
||||
getMapDesignations(label0Segment) { ControlFlowGraph.create(bytecodeIr) }
|
||||
} else {
|
||||
result.addProblem(Severity.Warning, "No instruction segment for label 0 found.")
|
||||
}
|
||||
|
||||
@ -55,4 +55,31 @@ class AsmTokenizationTests : LibTestSuite() {
|
||||
assertEquals(4, tokens4[0].col)
|
||||
assertEquals(2, tokens4[0].len)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun strings_are_parsed_as_Str_tokens() {
|
||||
val tokens0 = tokenizeLine(""" "one line" """)
|
||||
|
||||
assertEquals(1, tokens0.size)
|
||||
assertEquals(Token.Str::class, tokens0[0]::class)
|
||||
assertEquals("one line", (tokens0[0] as Token.Str).value)
|
||||
assertEquals(2, tokens0[0].col)
|
||||
assertEquals(10, tokens0[0].len)
|
||||
|
||||
val tokens1 = tokenizeLine(""" "two\nlines" """)
|
||||
|
||||
assertEquals(1, tokens1.size)
|
||||
assertEquals(Token.Str::class, tokens1[0]::class)
|
||||
assertEquals("two\nlines", (tokens1[0] as Token.Str).value)
|
||||
assertEquals(2, tokens1[0].col)
|
||||
assertEquals(12, tokens1[0].len)
|
||||
|
||||
val tokens2 = tokenizeLine(""" "is \"this\" escaped?" """)
|
||||
|
||||
assertEquals(1, tokens2.size)
|
||||
assertEquals(Token.Str::class, tokens2[0]::class)
|
||||
assertEquals("is \"this\" escaped?", (tokens2[0] as Token.Str).value)
|
||||
assertEquals(2, tokens2[0].col)
|
||||
assertEquals(22, tokens2[0].len)
|
||||
}
|
||||
}
|
||||
|
||||
@ -2,35 +2,252 @@ package world.phantasmal.lib.asm
|
||||
|
||||
import world.phantasmal.core.Success
|
||||
import world.phantasmal.lib.test.LibTestSuite
|
||||
import world.phantasmal.lib.test.assertDeepEquals
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class AssemblyTests : LibTestSuite() {
|
||||
@Test
|
||||
fun assemble_basic_script() {
|
||||
fun basic_script() {
|
||||
val result = assemble("""
|
||||
0:
|
||||
set_episode 0
|
||||
bb_map_designate 1, 2, 3, 4
|
||||
set_floor_handler 0, 150
|
||||
set_floor_handler 1, 151
|
||||
set_qt_success 250
|
||||
bb_map_designate 0, 0, 0, 0
|
||||
bb_map_designate 1, 1, 0, 0
|
||||
ret
|
||||
1:
|
||||
ret
|
||||
250:
|
||||
gset 101
|
||||
window_msg "You've been awarded 500 Meseta."
|
||||
bgm 1
|
||||
winend
|
||||
pl_add_meseta 0, 500
|
||||
150:
|
||||
set_mainwarp 1
|
||||
ret
|
||||
""".trimIndent().split('\n'))
|
||||
|
||||
assertTrue(result is Success)
|
||||
assertTrue(result.problems.isEmpty())
|
||||
assertEquals(3, result.value.segments.size)
|
||||
|
||||
assertDeepEquals(BytecodeIr(listOf(
|
||||
InstructionSegment(
|
||||
labels = mutableListOf(0),
|
||||
instructions = mutableListOf(
|
||||
Instruction(
|
||||
opcode = OP_SET_EPISODE,
|
||||
args = listOf(Arg(0)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(2, 5, 11),
|
||||
args = listOf(SrcLoc(2, 17, 1)),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_BB_MAP_DESIGNATE,
|
||||
args = listOf(Arg(1), Arg(2), Arg(3), Arg(4)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(3, 5, 16),
|
||||
args = listOf(
|
||||
SrcLoc(3, 22, 1),
|
||||
SrcLoc(3, 25, 1),
|
||||
SrcLoc(3, 28, 1),
|
||||
SrcLoc(3, 31, 1),
|
||||
),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_ARG_PUSHL,
|
||||
args = listOf(Arg(0)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = null,
|
||||
args = listOf(SrcLoc(4, 23, 1)),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_ARG_PUSHW,
|
||||
args = listOf(Arg(150)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = null,
|
||||
args = listOf(SrcLoc(4, 26, 3)),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_SET_FLOOR_HANDLER,
|
||||
args = emptyList(),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(4, 5, 17),
|
||||
args = emptyList(),
|
||||
stackArgs = listOf(
|
||||
SrcLoc(4, 23, 1),
|
||||
SrcLoc(4, 26, 3),
|
||||
),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_RET,
|
||||
args = emptyList(),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(5, 5, 3),
|
||||
args = emptyList(),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
),
|
||||
srcLoc = SegmentSrcLoc(labels = mutableListOf(SrcLoc(1, 1, 2))),
|
||||
),
|
||||
InstructionSegment(
|
||||
labels = mutableListOf(150),
|
||||
instructions = mutableListOf(
|
||||
Instruction(
|
||||
opcode = OP_ARG_PUSHL,
|
||||
args = listOf(Arg(1)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = null,
|
||||
args = listOf(SrcLoc(7, 18, 1)),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_SET_MAINWARP,
|
||||
args = emptyList(),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(7, 5, 12),
|
||||
args = emptyList(),
|
||||
stackArgs = listOf(SrcLoc(7, 18, 1)),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_RET,
|
||||
args = emptyList(),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(8, 5, 3),
|
||||
args = emptyList(),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
),
|
||||
srcLoc = SegmentSrcLoc(labels = mutableListOf(SrcLoc(6, 1, 4))),
|
||||
)
|
||||
)), result.value)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun pass_register_value_via_stack_with_inline_args() {
|
||||
val result = assemble("""
|
||||
0:
|
||||
leti r255, 7
|
||||
exit r255
|
||||
ret
|
||||
""".trimIndent().split('\n'))
|
||||
|
||||
assertTrue(result is Success)
|
||||
assertTrue(result.problems.isEmpty())
|
||||
|
||||
assertDeepEquals(BytecodeIr(
|
||||
listOf(
|
||||
InstructionSegment(
|
||||
labels = mutableListOf(0),
|
||||
instructions = mutableListOf(
|
||||
Instruction(
|
||||
opcode = OP_LETI,
|
||||
args = listOf(Arg(255), Arg(7)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(2, 5, 4),
|
||||
args = listOf(SrcLoc(2, 10, 4), SrcLoc(2, 16, 1)),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_ARG_PUSHR,
|
||||
args = listOf(Arg(255)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = null,
|
||||
args = listOf(SrcLoc(3, 10, 4)),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_EXIT,
|
||||
args = emptyList(),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(3, 5, 4),
|
||||
args = emptyList(),
|
||||
stackArgs = listOf(SrcLoc(3, 10, 4)),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_RET,
|
||||
args = emptyList(),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(4, 5, 3),
|
||||
args = emptyList(),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
),
|
||||
srcLoc = SegmentSrcLoc(
|
||||
labels = mutableListOf(SrcLoc(1, 1, 2))
|
||||
),
|
||||
)
|
||||
)
|
||||
), result.value)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun pass_register_reference_via_stack_with_inline_args() {
|
||||
val result = assemble("""
|
||||
0:
|
||||
p_dead_v3 r200, 3
|
||||
ret
|
||||
""".trimIndent().split('\n'))
|
||||
|
||||
assertTrue(result is Success)
|
||||
assertTrue(result.problems.isEmpty())
|
||||
|
||||
assertDeepEquals(BytecodeIr(
|
||||
listOf(
|
||||
InstructionSegment(
|
||||
labels = mutableListOf(0),
|
||||
instructions = mutableListOf(
|
||||
Instruction(
|
||||
opcode = OP_ARG_PUSHB,
|
||||
args = listOf(Arg(200)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = null,
|
||||
args = listOf(SrcLoc(2, 15, 4)),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_ARG_PUSHL,
|
||||
args = listOf(Arg(3)),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = null,
|
||||
args = listOf(SrcLoc(2, 21, 1)),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_P_DEAD_V3,
|
||||
args = emptyList(),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(2, 5, 9),
|
||||
args = emptyList(),
|
||||
stackArgs = listOf(SrcLoc(2, 15, 4), SrcLoc(2, 21, 1)),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_RET,
|
||||
args = emptyList(),
|
||||
srcLoc = InstructionSrcLoc(
|
||||
mnemonic = SrcLoc(3, 5, 3),
|
||||
args = emptyList(),
|
||||
stackArgs = emptyList(),
|
||||
),
|
||||
),
|
||||
),
|
||||
srcLoc = SegmentSrcLoc(
|
||||
labels = mutableListOf(SrcLoc(1, 1, 2))
|
||||
),
|
||||
)
|
||||
)
|
||||
), result.value)
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,72 @@
|
||||
package world.phantasmal.lib.asm
|
||||
|
||||
import world.phantasmal.core.Success
|
||||
import world.phantasmal.lib.fileFormats.quest.parseBin
|
||||
import world.phantasmal.lib.fileFormats.quest.parseBytecode
|
||||
import world.phantasmal.lib.test.LibTestSuite
|
||||
import world.phantasmal.lib.test.assertDeepEquals
|
||||
import world.phantasmal.lib.test.readFile
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class DisassemblyAssemblyRoundTripTests : LibTestSuite() {
|
||||
@Test
|
||||
fun assembling_disassembled_bytecode_should_result_in_the_same_IR() = asyncTest {
|
||||
assembling_disassembled_bytecode_should_result_in_the_same_IR(inlineStackArgs = false)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun assembling_disassembled_bytecode_should_result_in_the_same_IR_inline_args() = asyncTest {
|
||||
assembling_disassembled_bytecode_should_result_in_the_same_IR(inlineStackArgs = true)
|
||||
}
|
||||
|
||||
private suspend fun assembling_disassembled_bytecode_should_result_in_the_same_IR(
|
||||
inlineStackArgs: Boolean,
|
||||
) {
|
||||
val bin = parseBin(readFile("/quest27_e_decompressed.bin"))
|
||||
val expectedIr = parseBytecode(
|
||||
bin.bytecode,
|
||||
bin.labelOffsets,
|
||||
setOf(0),
|
||||
dcGcFormat = false,
|
||||
lenient = false,
|
||||
).unwrap()
|
||||
|
||||
val assemblyResult =
|
||||
assemble(disassemble(expectedIr, inlineStackArgs), inlineStackArgs)
|
||||
|
||||
assertTrue(assemblyResult.problems.isEmpty())
|
||||
assertTrue(assemblyResult is Success)
|
||||
assertDeepEquals(expectedIr, assemblyResult.value, ignoreSrcLocs = true)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun disassembling_assembled_bytecode_should_result_in_the_same_ASM() = asyncTest {
|
||||
disassembling_assembled_bytecode_should_result_in_the_same_ASM(inlineStackArgs = false)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun disassembling_assembled_bytecode_should_result_in_the_same_ASM_inline_args() = asyncTest {
|
||||
disassembling_assembled_bytecode_should_result_in_the_same_ASM(inlineStackArgs = true)
|
||||
}
|
||||
|
||||
private suspend fun disassembling_assembled_bytecode_should_result_in_the_same_ASM(
|
||||
inlineStackArgs: Boolean,
|
||||
) {
|
||||
val bin = parseBin(readFile("/quest27_e_decompressed.bin"))
|
||||
val ir = parseBytecode(
|
||||
bin.bytecode,
|
||||
bin.labelOffsets,
|
||||
setOf(0),
|
||||
dcGcFormat = false,
|
||||
lenient = false,
|
||||
).unwrap()
|
||||
|
||||
val expectedAsm = disassemble(ir, inlineStackArgs)
|
||||
val actualAsm =
|
||||
disassemble(assemble(expectedAsm, inlineStackArgs).unwrap(), inlineStackArgs)
|
||||
|
||||
assertDeepEquals(expectedAsm, actualAsm, ::assertEquals)
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,108 @@
|
||||
package world.phantasmal.lib.asm
|
||||
|
||||
import world.phantasmal.lib.test.LibTestSuite
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
class DisassemblyTests : LibTestSuite() {
|
||||
@Test
|
||||
fun vararg_instructions() {
|
||||
val ir = BytecodeIr(listOf(
|
||||
InstructionSegment(
|
||||
labels = mutableListOf(0),
|
||||
instructions = mutableListOf(
|
||||
Instruction(
|
||||
opcode = OP_SWITCH_JMP,
|
||||
args = listOf(
|
||||
Arg(90),
|
||||
Arg(100),
|
||||
Arg(101),
|
||||
Arg(102),
|
||||
),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_RET,
|
||||
args = emptyList()
|
||||
),
|
||||
),
|
||||
)
|
||||
))
|
||||
|
||||
val asm = """
|
||||
|.code
|
||||
|
|
||||
|0:
|
||||
| switch_jmp r90, 100, 101, 102
|
||||
| ret
|
||||
|
|
||||
""".trimMargin()
|
||||
|
||||
testWithAllOptions(ir, asm, asm)
|
||||
}
|
||||
|
||||
// arg_push* instructions should always be output when in a va list whether inline stack
|
||||
// arguments is on or off.
|
||||
@Test
|
||||
fun va_list_instructions() {
|
||||
val ir = BytecodeIr(listOf(
|
||||
InstructionSegment(
|
||||
labels = mutableListOf(0),
|
||||
instructions = mutableListOf(
|
||||
Instruction(
|
||||
opcode = OP_VA_START,
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_ARG_PUSHW,
|
||||
args = listOf(Arg(1337)),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_VA_CALL,
|
||||
args = listOf(Arg(100)),
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_VA_END,
|
||||
),
|
||||
Instruction(
|
||||
opcode = OP_RET,
|
||||
),
|
||||
),
|
||||
)
|
||||
))
|
||||
|
||||
val asm = """
|
||||
|.code
|
||||
|
|
||||
|0:
|
||||
| va_start
|
||||
| arg_pushw 1337
|
||||
| va_call 100
|
||||
| va_end
|
||||
| ret
|
||||
|
|
||||
""".trimMargin()
|
||||
|
||||
testWithAllOptions(ir, asm, asm)
|
||||
}
|
||||
|
||||
private fun testWithAllOptions(
|
||||
ir: BytecodeIr,
|
||||
expectedInlineAsm: String,
|
||||
expectedManualAsm: String,
|
||||
) {
|
||||
val asmInline = disassemble(ir, inlineStackArgs = true)
|
||||
|
||||
assertEquals(
|
||||
expectedInlineAsm.split('\n'),
|
||||
asmInline,
|
||||
"With inlineStackArgs",
|
||||
)
|
||||
|
||||
val asmManual = disassemble(ir, inlineStackArgs = false)
|
||||
|
||||
assertEquals(
|
||||
expectedManualAsm.split('\n'),
|
||||
asmManual,
|
||||
"Without inlineStackArgs",
|
||||
)
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,81 @@
|
||||
package world.phantasmal.lib.test
|
||||
|
||||
import world.phantasmal.lib.asm.*
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertNull
|
||||
|
||||
fun assertDeepEquals(expected: BytecodeIr, actual: BytecodeIr, ignoreSrcLocs: Boolean = false) {
|
||||
assertDeepEquals(expected.segments,
|
||||
actual.segments
|
||||
) { a, b -> assertDeepEquals(a, b, ignoreSrcLocs) }
|
||||
}
|
||||
|
||||
fun assertDeepEquals(expected: Segment, actual: Segment, ignoreSrcLocs: Boolean = false) {
|
||||
assertEquals(expected::class, actual::class)
|
||||
assertDeepEquals(expected.labels, actual.labels, ::assertEquals)
|
||||
|
||||
if (!ignoreSrcLocs) {
|
||||
assertDeepEquals(expected.srcLoc, actual.srcLoc)
|
||||
}
|
||||
|
||||
when (expected) {
|
||||
is InstructionSegment -> {
|
||||
actual as InstructionSegment
|
||||
assertDeepEquals(expected.instructions, actual.instructions) { a, b ->
|
||||
assertDeepEquals(a, b, ignoreSrcLocs)
|
||||
}
|
||||
}
|
||||
is DataSegment -> {
|
||||
actual as DataSegment
|
||||
assertDeepEquals(expected.data, actual.data)
|
||||
}
|
||||
is StringSegment -> {
|
||||
actual as StringSegment
|
||||
assertEquals(expected.value, actual.value)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun assertDeepEquals(expected: Instruction, actual: Instruction, ignoreSrcLocs: Boolean = false) {
|
||||
assertEquals(expected.opcode, actual.opcode)
|
||||
assertDeepEquals(expected.args, actual.args, ::assertEquals)
|
||||
|
||||
if (!ignoreSrcLocs) {
|
||||
assertDeepEquals(expected.srcLoc, actual.srcLoc)
|
||||
}
|
||||
}
|
||||
|
||||
fun assertDeepEquals(expected: SrcLoc?, actual: SrcLoc?) {
|
||||
if (expected == null) {
|
||||
assertNull(actual)
|
||||
return
|
||||
}
|
||||
|
||||
assertNotNull(actual)
|
||||
assertEquals(expected.lineNo, actual.lineNo)
|
||||
assertEquals(expected.col, actual.col)
|
||||
assertEquals(expected.len, actual.len)
|
||||
}
|
||||
|
||||
fun assertDeepEquals(expected: InstructionSrcLoc?, actual: InstructionSrcLoc?) {
|
||||
if (expected == null) {
|
||||
assertNull(actual)
|
||||
return
|
||||
}
|
||||
|
||||
assertNotNull(actual)
|
||||
assertDeepEquals(expected.mnemonic, actual.mnemonic)
|
||||
assertDeepEquals(expected.args, actual.args, ::assertDeepEquals)
|
||||
assertDeepEquals(expected.stackArgs, actual.stackArgs, ::assertDeepEquals)
|
||||
}
|
||||
|
||||
fun assertDeepEquals(expected: SegmentSrcLoc?, actual: SegmentSrcLoc?) {
|
||||
if (expected == null) {
|
||||
assertNull(actual)
|
||||
return
|
||||
}
|
||||
|
||||
assertNotNull(actual)
|
||||
assertDeepEquals(expected.labels, actual.labels, ::assertDeepEquals)
|
||||
}
|
||||
@ -3,7 +3,9 @@ package world.phantasmal.lib.test
|
||||
import world.phantasmal.core.Success
|
||||
import world.phantasmal.lib.asm.InstructionSegment
|
||||
import world.phantasmal.lib.asm.assemble
|
||||
import world.phantasmal.lib.buffer.Buffer
|
||||
import world.phantasmal.lib.cursor.Cursor
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
expect suspend fun readFile(path: String): Cursor
|
||||
@ -16,3 +18,21 @@ fun toInstructions(assembly: String): List<InstructionSegment> {
|
||||
|
||||
return result.value.instructionSegments()
|
||||
}
|
||||
|
||||
fun <T> assertDeepEquals(expected: List<T>, actual: List<T>, assertDeepEquals: (T, T) -> Unit) {
|
||||
assertEquals(expected.size, actual.size)
|
||||
|
||||
for (i in actual.indices) {
|
||||
assertDeepEquals(expected[i], actual[i])
|
||||
}
|
||||
}
|
||||
|
||||
fun assertDeepEquals(expected: Buffer, actual: Buffer): Boolean {
|
||||
if (expected.size != actual.size) return false
|
||||
|
||||
for (i in 0 until expected.size) {
|
||||
if (expected.getByte(i) != actual.getByte(i)) return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
BIN
lib/src/commonTest/resources/quest27_e.bin
Normal file
BIN
lib/src/commonTest/resources/quest27_e.bin
Normal file
Binary file not shown.
BIN
lib/src/commonTest/resources/quest27_e_decompressed.bin
Normal file
BIN
lib/src/commonTest/resources/quest27_e_decompressed.bin
Normal file
Binary file not shown.
@ -33,8 +33,8 @@ infix fun Val<Boolean>.and(other: Val<Boolean>): Val<Boolean> =
|
||||
infix fun Val<Boolean>.or(other: Val<Boolean>): Val<Boolean> =
|
||||
map(this, other) { a, b -> a || b }
|
||||
|
||||
// Use != because of https://youtrack.jetbrains.com/issue/KT-31277.
|
||||
infix fun Val<Boolean>.xor(other: Val<Boolean>): Val<Boolean> =
|
||||
// Use != because of https://youtrack.jetbrains.com/issue/KT-31277.
|
||||
map(this, other) { a, b -> a != b }
|
||||
|
||||
operator fun Val<Boolean>.not(): Val<Boolean> = map { !it }
|
||||
@ -42,6 +42,9 @@ operator fun Val<Boolean>.not(): Val<Boolean> = map { !it }
|
||||
operator fun Val<Int>.plus(other: Int): Val<Int> =
|
||||
map { it + other }
|
||||
|
||||
operator fun Val<Int>.minus(other: Int): Val<Int> =
|
||||
map { it - other }
|
||||
|
||||
fun Val<String>.isEmpty(): Val<Boolean> =
|
||||
map { it.isEmpty() }
|
||||
|
||||
|
||||
@ -2,16 +2,31 @@ package world.phantasmal.web.assemblyWorker
|
||||
|
||||
import world.phantasmal.core.*
|
||||
import world.phantasmal.lib.asm.*
|
||||
import world.phantasmal.lib.asm.dataFlowAnalysis.ControlFlowGraph
|
||||
import world.phantasmal.lib.asm.dataFlowAnalysis.getMapDesignations
|
||||
import world.phantasmal.lib.asm.dataFlowAnalysis.getStackValue
|
||||
import world.phantasmal.web.shared.*
|
||||
import world.phantasmal.web.shared.AssemblyProblem
|
||||
import kotlin.math.min
|
||||
import world.phantasmal.lib.asm.AssemblyProblem as AssemblerAssemblyProblem
|
||||
|
||||
class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) {
|
||||
// User input.
|
||||
private var inlineStackArgs: Boolean = true
|
||||
private val asm: JsArray<String> = jsArrayOf()
|
||||
|
||||
// Output.
|
||||
private var bytecodeIr = BytecodeIr(emptyList())
|
||||
private var problems: List<AssemblyProblem>? = null
|
||||
|
||||
// Derived data.
|
||||
private var _cfg: ControlFlowGraph? = null
|
||||
private val cfg: ControlFlowGraph
|
||||
get() {
|
||||
if (_cfg == null) _cfg = ControlFlowGraph.create(bytecodeIr)
|
||||
return _cfg!!
|
||||
}
|
||||
|
||||
private var mapDesignations: Map<Int, Int>? = null
|
||||
|
||||
fun receiveMessage(message: ClientMessage) =
|
||||
@ -137,6 +152,8 @@ class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) {
|
||||
}
|
||||
|
||||
private fun processAsm() {
|
||||
_cfg = null
|
||||
|
||||
val assemblyResult = assemble(asm.asArray().toList(), inlineStackArgs)
|
||||
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
@ -144,7 +161,10 @@ class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) {
|
||||
AssemblyProblem(it.severity, it.uiMessage)
|
||||
}
|
||||
|
||||
sendMessage(ServerNotification.Problems(problems))
|
||||
if (problems != this.problems) {
|
||||
this.problems = problems
|
||||
sendMessage(ServerNotification.Problems(problems))
|
||||
}
|
||||
|
||||
if (assemblyResult is Success) {
|
||||
bytecodeIr = assemblyResult.value
|
||||
@ -152,9 +172,9 @@ class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) {
|
||||
val instructionSegments = bytecodeIr.instructionSegments()
|
||||
|
||||
instructionSegments.find { 0 in it.labels }?.let { label0Segment ->
|
||||
val designations = getMapDesignations(instructionSegments, label0Segment)
|
||||
val designations = getMapDesignations(label0Segment) { cfg }
|
||||
|
||||
if (mapDesignations != designations) {
|
||||
if (designations != mapDesignations) {
|
||||
mapDesignations = designations
|
||||
sendMessage(ServerNotification.MapDesignations(
|
||||
designations
|
||||
@ -349,10 +369,14 @@ class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) {
|
||||
// Stack arguments.
|
||||
val argSrcLocs = inst.getStackArgSrcLocs(paramIdx)
|
||||
|
||||
for (argSrcLoc in argSrcLocs) {
|
||||
for ((i, argSrcLoc) in argSrcLocs.withIndex()) {
|
||||
if (positionInside(lineNo, col, argSrcLoc)) {
|
||||
val label = argSrcLoc.value as Int
|
||||
result = getLabelDefinitions(label)
|
||||
val labelValues = getStackValue(cfg, inst, argSrcLocs.lastIndex - i)
|
||||
|
||||
if (labelValues.size <= 5) {
|
||||
result = labelValues.flatMap(::getLabelDefinitions)
|
||||
}
|
||||
|
||||
break@loop
|
||||
}
|
||||
}
|
||||
|
||||
@ -53,10 +53,12 @@ dependencies {
|
||||
testImplementation(project(":test-utils"))
|
||||
}
|
||||
|
||||
// TODO: Figure out how to trigger this task automatically.
|
||||
tasks.register<Copy>("copyAssemblyWorkerJs") {
|
||||
val copyAssemblyWorkerJsTask = tasks.register<Copy>("copyAssemblyWorkerJs") {
|
||||
val workerDist = project(":web:assembly-worker").buildDir.resolve("distributions")
|
||||
from(workerDist.resolve("assembly-worker.js"), workerDist.resolve("assembly-worker.js.map"))
|
||||
into(buildDir.resolve("processedResources/js/main"))
|
||||
dependsOn(":web:assembly-worker:build")
|
||||
}
|
||||
|
||||
// TODO: Figure out how to make this work with --continuous.
|
||||
tasks.getByName("processResources").dependsOn(copyAssemblyWorkerJsTask)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user