Sancaros/phantasmal-world
1
0
Fork 0
mirror of https://github.com/DaanVandenBosch/phantasmal-world.git synced 2025-04-04 22:58:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Greatly improved script assembly performance.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2021-04-19 21:53:15 +02:00
parent feec12b308
commit 955d7dad29
26 changed files with 418 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/src/commonMain/kotlin/world/phantasmal/core/UnsafeCast.kt → core/src/commonMain/kotlin/world/phantasmal/core/unsafe/UnsafeCast.kt
View File

@ -1,4 +1,4 @@
package world.phantasmal.core
package world.phantasmal.core.unsafe
/**
* Asserts that T is not null. No runtime check happens in KJS. Should only be used when absolutely

14
core/src/commonMain/kotlin/world/phantasmal/core/unsafe/UnsafeMap.kt Normal file
View File

@ -0,0 +1,14 @@
package world.phantasmal.core.unsafe
/**
* Map optimized for JS (it compiles to the built-in Map).
* In JS, keys are compared by reference, equals and hashCode are NOT invoked. On JVM, equals and
* hashCode ARE used.
*/
expect class UnsafeMap<K, V>() {
fun get(key: K): V?
fun has(key: K): Boolean
fun forEach(callback: (value: V, key: K) -> Unit)
fun set(key: K, value: V)
fun delete(key: K): Boolean
}

22
core/src/jsMain/kotlin/world/phantasmal/core/Js.kt
View File

@ -43,10 +43,6 @@ inline val <T> JsPair<*, T>.second: T get() = asDynamic()[1].unsafeCast<T>()
inline operator fun <T> JsPair<T, *>.component1(): T = first
inline operator fun <T> JsPair<*, T>.component2(): T = second
@Suppress("FunctionName", "UNUSED_PARAMETER")
inline fun <A, B> JsPair(first: A, second: B): JsPair<A, B> =
js("[first, second]").unsafeCast<JsPair<A, B>>()
@Suppress("UNUSED_PARAMETER")
inline fun objectEntries(jsObject: dynamic): Array<JsPair<String, dynamic>> =
js("Object.entries(jsObject)").unsafeCast<Array<JsPair<String, dynamic>>>()
@ -67,21 +63,3 @@ inline fun <T> emptyJsSet(): JsSet<T> =
@Suppress("UNUSED_PARAMETER")
inline fun <T> jsSetOf(vararg values: T): JsSet<T> =
js("new Set(values)").unsafeCast<JsSet<T>>()
external interface JsMap<K, V> {
val size: Int
fun clear()
fun delete(key: K): Boolean
fun forEach(callback: (value: V, key: K) -> Unit)
fun get(key: K): V?
fun has(key: K): Boolean
fun set(key: K, value: V): JsMap<K, V>
}
@Suppress("UNUSED_PARAMETER")
inline fun <K, V> jsMapOf(vararg pairs: JsPair<K, V>): JsMap<K, V> =
js("new Map(pairs)").unsafeCast<JsMap<K, V>>()
inline fun <K, V> emptyJsMap(): JsMap<K, V> =
js("new Map()").unsafeCast<JsMap<K, V>>()

2
core/src/jsMain/kotlin/world/phantasmal/core/UnsafeCast.kt → core/src/jsMain/kotlin/world/phantasmal/core/unsafe/UnsafeCast.kt
View File

@ -1,4 +1,4 @@
package world.phantasmal.core
package world.phantasmal.core.unsafe
@Suppress("NOTHING_TO_INLINE")
actual inline fun <T> T?.unsafeAssertNotNull(): T = unsafeCast<T>()

10
core/src/jsMain/kotlin/world/phantasmal/core/unsafe/UnsafeMap.kt Normal file
View File

@ -0,0 +1,10 @@
package world.phantasmal.core.unsafe
@JsName("Map")
actual external class UnsafeMap<K, V> {
actual fun get(key: K): V?
actual fun has(key: K): Boolean
actual fun forEach(callback: (value: V, key: K) -> Unit)
actual fun set(key: K, value: V)
actual fun delete(key: K): Boolean
}

2
core/src/jvmMain/kotlin/world/phantasmal/core/UnsafeCast.kt → core/src/jvmMain/kotlin/world/phantasmal/core/unsafe/UnsafeCast.kt
View File

@ -1,4 +1,4 @@
package world.phantasmal.core
package world.phantasmal.core.unsafe
@Suppress("UNCHECKED_CAST", "NOTHING_TO_INLINE")
actual inline fun <T> T?.unsafeAssertNotNull(): T = this as T

19
core/src/jvmMain/kotlin/world/phantasmal/core/unsafe/UnsafeMap.kt Normal file
View File

@ -0,0 +1,19 @@
package world.phantasmal.core.unsafe
actual class UnsafeMap<K, V> {
private val map = HashMap<K, V>()
actual fun get(key: K): V? = map[key]
actual fun has(key: K): Boolean = key in map
actual fun forEach(callback: (value: V, key: K) -> Unit) {
map.forEach { (k, v) -> callback(v, k) }
}
actual fun set(key: K, value: V) {
map[key] = value
}
actual fun delete(key: K): Boolean = map.remove(key) != null
}

2
lib/build.gradle.kts
View File

@ -40,7 +40,9 @@ kotlin {
sourceSets {
all {
languageSettings.useExperimentalAnnotation("kotlin.RequiresOptIn")
languageSettings.useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
languageSettings.useExperimentalAnnotation("kotlin.time.ExperimentalTime")
}
commonMain {

112
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/AsmTokenization.kt
View File

@ -2,12 +2,33 @@ package world.phantasmal.lib.asm
import world.phantasmal.core.fastIsWhitespace
import world.phantasmal.core.isDigit
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
private val HEX_INT_REGEX = Regex("""^0[xX][0-9a-fA-F]+$""")
private val FLOAT_REGEX = Regex("""^-?\d+(\.\d+)?(e-?\d+)?$""")
private val IDENT_REGEX = Regex("""^[a-z][a-z0-9_=<>!]*$""")
const val TOKEN_INT32 = 1
const val TOKEN_FLOAT32 = 2
const val TOKEN_INVALID_NUMBER = 3
const val TOKEN_REGISTER = 4
const val TOKEN_LABEL = 5
const val TOKEN_SECTION_CODE = 6
const val TOKEN_SECTION_DATA = 7
const val TOKEN_SECTION_STR = 8
const val TOKEN_INVALID_SECTION = 9
const val TOKEN_STR = 10
const val TOKEN_UNTERMINATED_STR = 11
const val TOKEN_IDENT = 12
const val TOKEN_INVALID_IDENT = 13
const val TOKEN_ARG_SEP = 14
sealed class Token {
/**
* This property is used for increased perf type checks in JS.
*/
abstract val type: Int
abstract val col: Int
abstract val len: Int
@ -15,80 +36,143 @@ sealed class Token {
override val col: Int,
override val len: Int,
val value: Int,
) : Token()
) : Token() {
override val type = TOKEN_INT32
}
class Float32(
override val col: Int,
override val len: Int,
val value: Float,
) : Token()
) : Token() {
override val type = TOKEN_FLOAT32
}
class InvalidNumber(
override val col: Int,
override val len: Int,
) : Token()
) : Token() {
override val type = TOKEN_INVALID_NUMBER
}
class Register(
override val col: Int,
override val len: Int,
val value: Int,
) : Token()
) : Token() {
override val type = TOKEN_REGISTER
}
class Label(
override val col: Int,
override val len: Int,
val value: Int,
) : Token()
) : Token() {
override val type = TOKEN_LABEL
}
sealed class Section : Token() {
class Code(
override val col: Int,
override val len: Int,
) : Section()
) : Section() {
override val type = TOKEN_SECTION_CODE
}
class Data(
override val col: Int,
override val len: Int,
) : Section()
) : Section() {
override val type = TOKEN_SECTION_DATA
}
class Str(
override val col: Int,
override val len: Int,
) : Section()
) : Section() {
override val type = TOKEN_SECTION_STR
}
}
class InvalidSection(
override val col: Int,
override val len: Int,
) : Token()
) : Token() {
override val type = TOKEN_INVALID_SECTION
}
class Str(
override val col: Int,
override val len: Int,
val value: String,
) : Token()
) : Token() {
override val type = TOKEN_STR
}
class UnterminatedString(
override val col: Int,
override val len: Int,
val value: String,
) : Token()
) : Token() {
override val type = TOKEN_UNTERMINATED_STR
}
class Ident(
override val col: Int,
override val len: Int,
val value: String,
) : Token()
) : Token() {
override val type = TOKEN_IDENT
}
class InvalidIdent(
override val col: Int,
override val len: Int,
) : Token()
) : Token() {
override val type = TOKEN_INVALID_IDENT
}
class ArgSeparator(
override val col: Int,
override val len: Int,
) : Token()
) : Token() {
override val type = TOKEN_ARG_SEP
}
@OptIn(ExperimentalContracts::class)
@Suppress("NOTHING_TO_INLINE")
inline fun isInt32(): Boolean {
contract { returns(true) implies (this@Token is Int32) }
return type == TOKEN_INT32
}
@OptIn(ExperimentalContracts::class)
@Suppress("NOTHING_TO_INLINE")
inline fun isFloat32(): Boolean {
contract { returns(true) implies (this@Token is Float32) }
return type == TOKEN_FLOAT32
}
@OptIn(ExperimentalContracts::class)
@Suppress("NOTHING_TO_INLINE")
inline fun isRegister(): Boolean {
contract { returns(true) implies (this@Token is Register) }
return type == TOKEN_REGISTER
}
@OptIn(ExperimentalContracts::class)
@Suppress("NOTHING_TO_INLINE")
inline fun isStr(): Boolean {
contract { returns(true) implies (this@Token is Str) }
return type == TOKEN_STR
}
@OptIn(ExperimentalContracts::class)
@Suppress("NOTHING_TO_INLINE")
inline fun isArgSeparator(): Boolean {
contract { returns(true) implies (this@Token is ArgSeparator) }
return type == TOKEN_ARG_SEP
}
}
fun tokenizeLine(line: String): MutableList<Token> =

136
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt
View File

@ -5,6 +5,7 @@ import world.phantasmal.core.Problem
import world.phantasmal.core.PwResult
import world.phantasmal.core.Severity
import world.phantasmal.lib.buffer.Buffer
import kotlin.time.measureTimedValue
private val logger = KotlinLogging.logger {}
@ -28,13 +29,13 @@ fun assemble(
}."
}
val result = Assembler(asm, inlineStackArgs).assemble()
val (result, time) = measureTimedValue { Assembler(asm, inlineStackArgs).assemble() }
logger.trace {
val warnings = result.problems.count { it.severity == Severity.Warning }
val errors = result.problems.count { it.severity == Severity.Error }
"Assembly finished with $warnings warnings and $errors errors."
"Assembly finished in ${time.inMilliseconds}ms with $warnings warnings and $errors errors."
}
return result
@ -69,7 +70,16 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
val token = tokens.removeFirst()
var hasLabel = false
// Token type checks are ordered from most frequent to least frequent for increased
// perf.
when (token) {
is Token.Ident -> {
if (section === SegmentType.Instructions) {
parseInstruction(token)
} else {
addUnexpectedTokenError(token)
}
}
is Token.Label -> {
parseLabel(token)
hasLabel = true
@ -78,26 +88,19 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
parseSection(token)
}
is Token.Int32 -> {
if (section == SegmentType.Data) {
if (section === SegmentType.Data) {
parseBytes(token)
} else {
addUnexpectedTokenError(token)
}
}
is Token.Str -> {
if (section == SegmentType.String) {
if (section === SegmentType.String) {
parseString(token)
} else {
addUnexpectedTokenError(token)
}
}
is Token.Ident -> {
if (section === SegmentType.Instructions) {
parseInstruction(token)
} else {
addUnexpectedTokenError(token)
}
}
is Token.InvalidSection -> {
addError(token, "Invalid section type.")
}
@ -146,11 +149,13 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
mnemonic = token?.let {
SrcLoc(lineNo, token.col, token.len)
},
args = argTokens.map {
// Use mapTo with ArrayList for better perf in JS.
args = argTokens.mapTo(ArrayList(argTokens.size)) {
SrcLoc(lineNo, it.col, it.len)
},
stackArgs = stackArgTokens.map { sat ->
SrcLoc(lineNo, sat.col, sat.len)
// Use mapTo with ArrayList for better perf in JS.
stackArgs = stackArgTokens.mapTo(ArrayList(argTokens.size)) {
SrcLoc(lineNo, it.col, it.len)
},
)
)
@ -356,15 +361,19 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
if (opcode == null) {
addError(identToken, "Unknown opcode.")
} else {
val varargs = opcode.params.any {
it.type is ILabelVarType || it.type is RegRefVarType
}
// Use find instead of any for better JS perf.
val varargs = opcode.params.find {
it.type === ILabelVarType || it.type === RegRefVarType
} != null
val paramCount =
if (!inlineStackArgs && opcode.stack == StackInteraction.Pop) 0
if (!inlineStackArgs && opcode.stack === StackInteraction.Pop) 0
else opcode.params.size
val argCount = tokens.count { it !is Token.ArgSeparator }
// Use fold instead of count for better JS perf.
val argCount = tokens.fold(0) { sum, token ->
if (token.isArgSeparator()) sum else sum + 1
}
val lastToken = tokens.lastOrNull()
val errorLength = lastToken?.let { it.col + it.len - identToken.col } ?: 0
@ -413,7 +422,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
val arg = stackArgs.getOrNull(i) ?: continue
val argToken = stackTokens.getOrNull(i) ?: continue
if (argToken is Token.Register) {
if (argToken.isRegister()) {
if (param.type is RegTupRefType) {
addInstruction(
OP_ARG_PUSHB,
@ -433,8 +442,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
}
} else {
when (param.type) {
is ByteType,
is RegRefType,
ByteType,
RegRefType,
is RegTupRefType,
-> {
addInstruction(
@ -446,11 +455,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
)
}
is ShortType,
ShortType,
is LabelType,
is ILabelType,
is DLabelType,
is SLabelType,
-> {
addInstruction(
OP_ARG_PUSHW,
@ -461,7 +467,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
)
}
is IntType -> {
IntType -> {
addInstruction(
OP_ARG_PUSHL,
listOf(arg),
@ -471,7 +477,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
)
}
is FloatType -> {
FloatType -> {
addInstruction(
OP_ARG_PUSHL,
listOf(Arg((arg.value as Float).toRawBits())),
@ -481,7 +487,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
)
}
is StringType -> {
StringType -> {
addInstruction(
OP_ARG_PUSHS,
listOf(arg),
@ -528,12 +534,12 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
val token = tokens[i]
val param = params[paramI]
if (token is Token.ArgSeparator) {
if (token.isArgSeparator()) {
if (shouldBeArg) {
addError(token, "Expected an argument.")
} else if (
param.type !is ILabelVarType &&
param.type !is RegRefVarType
param.type !== ILabelVarType &&
param.type !== RegRefVarType
) {
paramI++
}
@ -551,28 +557,24 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
var match: Boolean
when (token) {
is Token.Int32 -> {
when {
token.isInt32() -> {
when (param.type) {
is ByteType -> {
ByteType -> {
match = true
parseInt(1, token, args, argTokens)
}
is ShortType,
ShortType,
is LabelType,
is ILabelType,
is DLabelType,
is SLabelType,
is ILabelVarType,
-> {
match = true
parseInt(2, token, args, argTokens)
}
is IntType -> {
IntType -> {
match = true
parseInt(4, token, args, argTokens)
}
is FloatType -> {
FloatType -> {
match = true
args.add(Arg(token.value))
argTokens.add(token)
@ -583,8 +585,8 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
}
}
is Token.Float32 -> {
match = param.type == FloatType
token.isFloat32() -> {
match = param.type === FloatType
if (match) {
args.add(Arg(token.value))
@ -592,17 +594,17 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
}
}
is Token.Register -> {
token.isRegister() -> {
match = stack ||
param.type is RegRefType ||
param.type is RegRefVarType ||
param.type === RegRefType ||
param.type === RegRefVarType ||
param.type is RegTupRefType
parseRegister(token, args, argTokens)
}
is Token.Str -> {
match = param.type is StringType
token.isStr() -> {
match = param.type === StringType
if (match) {
args.add(Arg(token.value))
@ -619,22 +621,24 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
semiValid = false
val typeStr: String? = when (param.type) {
is ByteType -> "an 8-bit integer"
is ShortType -> "a 16-bit integer"
is IntType -> "a 32-bit integer"
is FloatType -> "a float"
is LabelType -> "a label"
ByteType -> "an 8-bit integer"
ShortType -> "a 16-bit integer"
IntType -> "a 32-bit integer"
FloatType -> "a float"
is ILabelType,
is ILabelVarType,
ILabelType,
ILabelVarType,
-> "an instruction label"
is DLabelType -> "a data label"
is SLabelType -> "a string label"
is StringType -> "a string"
DLabelType -> "a data label"
SLabelType -> "a string label"
is RegRefType,
is RegRefVarType,
is LabelType -> "a label"
StringType -> "a string"
RegRefType,
RegRefVarType,
is RegTupRefType,
-> "a register reference"
@ -660,11 +664,18 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
argTokens: MutableList<Token>,
) {
val value = token.value
// Fast-path 32-bit ints for improved JS perf. Otherwise maxValue would have to be a Long
// or UInt, which incurs a perf hit in JS.
if (size == 4) {
args.add(Arg(value))
argTokens.add(token)
} else {
val bitSize = 8 * size
// Minimum of the signed version of this integer type.
val minValue = -(1 shl (bitSize - 1))
// Maximum of the unsigned version of this integer type.
val maxValue = (1L shl (bitSize)) - 1L
val maxValue = (1 shl (bitSize)) - 1
when {
value < minValue -> {
@ -679,6 +690,7 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
}
}
}
}
private fun parseRegister(
token: Token.Register,

56
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt
View File

@ -1,5 +1,6 @@
package world.phantasmal.lib.asm
import world.phantasmal.core.unsafe.unsafeAssertNotNull
import world.phantasmal.lib.buffer.Buffer
import kotlin.math.ceil
@ -47,7 +48,7 @@ class InstructionSegment(
override fun copy(): InstructionSegment =
InstructionSegment(
ArrayList(labels),
instructions.mapTo(mutableListOf()) { it.copy() },
instructions.mapTo(ArrayList(instructions.size)) { it.copy() },
srcLoc.copy(),
)
}
@ -101,19 +102,24 @@ class Instruction(
/**
* Immediate arguments for the opcode.
*/
val args: List<Arg> = emptyList(),
val srcLoc: InstructionSrcLoc? = null,
val args: List<Arg>,
val srcLoc: InstructionSrcLoc?,
) {
/**
* Maps each parameter by index to its immediate arguments.
*/
private val paramToArgs: List<List<Arg>>
// Avoid using lazy to keep GC pressure low.
private var paramToArgs: List<List<Arg>>? = null
init {
/**
* Returns the immediate arguments for the parameter at the given index.
*/
fun getArgs(paramIndex: Int): List<Arg> {
if (paramToArgs == null) {
val paramToArgs: MutableList<MutableList<Arg>> = mutableListOf()
this.paramToArgs = paramToArgs
if (opcode.stack != StackInteraction.Pop) {
if (opcode.stack !== StackInteraction.Pop) {
for (i in opcode.params.indices) {
val type = opcode.params[i].type
val pArgs = mutableListOf<Arg>()
@ -121,7 +127,7 @@ class Instruction(
// Variable length arguments are always last, so we can just gobble up all arguments
// from this point.
if (type is ILabelVarType || type is RegRefVarType) {
if (type === ILabelVarType || type === RegRefVarType) {
check(i == opcode.params.lastIndex)
for (j in i until args.size) {
@ -134,10 +140,8 @@ class Instruction(
}
}
/**
* Returns the immediate arguments for the parameter at the given index.
*/
fun getArgs(paramIndex: Int): List<Arg> = paramToArgs[paramIndex]
return paramToArgs.unsafeAssertNotNull()[paramIndex]
}
/**
* Returns the source locations of the immediate arguments for the parameter at the given index.
@ -150,7 +154,7 @@ class Instruction(
// Variable length arguments are always last, so we can just gobble up all SrcLocs from
// paramIndex onward.
return if (type is ILabelVarType || type is RegRefVarType) {
return if (type === ILabelVarType || type === RegRefVarType) {
argSrcLocs.drop(paramIndex)
} else {
listOf(argSrcLocs[paramIndex])
@ -171,7 +175,7 @@ class Instruction(
// Variable length arguments are always last, so we can just gobble up all SrcLocs from
// paramIndex onward.
return if (type is ILabelVarType || type is RegRefVarType) {
return if (type === ILabelVarType || type === RegRefVarType) {
argSrcLocs.drop(paramIndex)
} else {
listOf(argSrcLocs[paramIndex])
@ -185,31 +189,28 @@ class Instruction(
fun getSize(dcGcFormat: Boolean): Int {
var size = opcode.size
if (opcode.stack == StackInteraction.Pop) return size
if (opcode.stack === StackInteraction.Pop) return size
for (i in opcode.params.indices) {
val type = opcode.params[i].type
val args = getArgs(i)
size += when (type) {
is ByteType,
is RegRefType,
is RegTupRefType,
ByteType,
RegRefType,
-> 1
// Ensure this case is before the LabelType case because ILabelVarType extends
// LabelType.
is ILabelVarType -> 1 + 2 * args.size
ILabelVarType -> 1 + 2 * args.size
is ShortType,
is LabelType,
-> 2
ShortType -> 2
is IntType,
is FloatType,
IntType,
FloatType,
-> 4
is StringType -> {
StringType -> {
if (dcGcFormat) {
(args[0].value as String).length + 1
} else {
@ -217,7 +218,12 @@ class Instruction(
}
}
is RegRefVarType -> 1 + args.size
RegRefVarType -> 1 + args.size
// Check RegTupRefType and LabelType last, because "is" checks are very slow in JS.
is RegTupRefType -> 1
is LabelType -> 2
else -> error("Parameter type ${type::class} not implemented.")
}

16
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Opcode.kt
View File

@ -1,11 +1,13 @@
package world.phantasmal.lib.asm
private val MNEMONIC_TO_OPCODES: MutableMap<String, Opcode> by lazy {
val map = mutableMapOf<String, Opcode>()
import world.phantasmal.core.unsafe.UnsafeMap
OPCODES.forEach { if (it != null) map[it.mnemonic] = it }
OPCODES_F8.forEach { if (it != null) map[it.mnemonic] = it }
OPCODES_F9.forEach { if (it != null) map[it.mnemonic] = it }
private val MNEMONIC_TO_OPCODES: UnsafeMap<String, Opcode> by lazy {
val map = UnsafeMap<String, Opcode>()
OPCODES.forEach { if (it != null) map.set(it.mnemonic, it) }
OPCODES_F8.forEach { if (it != null) map.set(it.mnemonic, it) }
OPCODES_F9.forEach { if (it != null) map.set(it.mnemonic, it) }
map
}
@ -170,13 +172,13 @@ fun codeToOpcode(code: Int): Opcode =
}
fun mnemonicToOpcode(mnemonic: String): Opcode? {
var opcode = MNEMONIC_TO_OPCODES[mnemonic]
var opcode = MNEMONIC_TO_OPCODES.get(mnemonic)
if (opcode == null) {
UNKNOWN_OPCODE_MNEMONIC_REGEX.matchEntire(mnemonic)?.destructured?.let { (codeStr) ->
val code = codeStr.toInt(16)
opcode = codeToOpcode(code)
MNEMONIC_TO_OPCODES[mnemonic] = opcode!!
MNEMONIC_TO_OPCODES.set(mnemonic, opcode!!)
}
}

10
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bytecode.kt
View File

@ -466,13 +466,13 @@ private fun parseInstructionsSegment(
// Parse the arguments.
try {
val args = parseInstructionArguments(cursor, opcode, dcGcFormat)
instructions.add(Instruction(opcode, args))
instructions.add(Instruction(opcode, args, srcLoc = null))
} catch (e: Exception) {
if (lenient) {
logger.error(e) {
"Exception occurred while parsing arguments for instruction ${opcode.mnemonic}."
}
instructions.add(Instruction(opcode, emptyList()))
instructions.add(Instruction(opcode, emptyList(), srcLoc = null))
} else {
throw e
}
@ -590,7 +590,8 @@ private fun parseInstructionArguments(
is StringType -> {
val maxBytes = min(4096, cursor.bytesLeft)
args.add(Arg(
args.add(
Arg(
if (dcGcFormat) {
cursor.stringAscii(
maxBytes,
@ -604,7 +605,8 @@ private fun parseInstructionArguments(
dropRemaining = false
)
},
))
)
)
}
is RegRefType,

24
lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyTests.kt
View File

@ -7,7 +7,8 @@ import kotlin.test.assertEquals
class DisassemblyTests : LibTestSuite {
@Test
fun vararg_instructions() {
val ir = BytecodeIr(listOf(
val ir = BytecodeIr(
listOf(
InstructionSegment(
labels = mutableListOf(0),
instructions = mutableListOf(
@ -19,14 +20,17 @@ class DisassemblyTests : LibTestSuite {
Arg(101),
Arg(102),
),
srcLoc = null,
),
Instruction(
opcode = OP_RET,
args = emptyList()
args = emptyList(),
srcLoc = null,
),
),
)
))
)
)
val asm = """
|.code
@ -44,30 +48,40 @@ class DisassemblyTests : LibTestSuite {
// arguments is on or off.
@Test
fun va_list_instructions() {
val ir = BytecodeIr(listOf(
val ir = BytecodeIr(
listOf(
InstructionSegment(
labels = mutableListOf(0),
instructions = mutableListOf(
Instruction(
opcode = OP_VA_START,
args = emptyList(),
srcLoc = null,
),
Instruction(
opcode = OP_ARG_PUSHW,
args = listOf(Arg(1337)),
srcLoc = null,
),
Instruction(
opcode = OP_VA_CALL,
args = listOf(Arg(100)),
srcLoc = null,
),
Instruction(
opcode = OP_VA_END,
args = emptyList(),
srcLoc = null,
),
Instruction(
opcode = OP_RET,
args = emptyList(),
srcLoc = null,
),
),
)
))
)
)
val asm = """
|.code

2
observable/src/commonMain/kotlin/world/phantasmal/observable/value/AbstractDependentVal.kt
View File

@ -2,7 +2,7 @@ package world.phantasmal.observable.value
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.core.unsafeAssertNotNull
import world.phantasmal.core.unsafe.unsafeAssertNotNull
import world.phantasmal.observable.Observer
/**

2
observable/src/commonMain/kotlin/world/phantasmal/observable/value/FlatteningDependentVal.kt
View File

@ -2,7 +2,7 @@ package world.phantasmal.observable.value
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.core.unsafeAssertNotNull
import world.phantasmal.core.unsafe.unsafeAssertNotNull
import world.phantasmal.observable.Observer
/**

2
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/AbstractListVal.kt
View File

@ -2,7 +2,7 @@ package world.phantasmal.observable.value.list
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.core.unsafeAssertNotNull
import world.phantasmal.core.unsafe.unsafeAssertNotNull
import world.phantasmal.observable.ChangeEvent
import world.phantasmal.observable.Observable
import world.phantasmal.observable.Observer

2
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/DependentListVal.kt
View File

@ -1,6 +1,6 @@
package world.phantasmal.observable.value.list
import world.phantasmal.core.unsafeAssertNotNull
import world.phantasmal.core.unsafe.unsafeAssertNotNull
import world.phantasmal.observable.value.Val
/**

2
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FlatteningDependentListVal.kt
View File

@ -1,7 +1,7 @@
package world.phantasmal.observable.value.list
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.unsafeAssertNotNull
import world.phantasmal.core.unsafe.unsafeAssertNotNull
import world.phantasmal.observable.value.Val
/**

2
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FoldedVal.kt
View File

@ -2,7 +2,7 @@ package world.phantasmal.observable.value.list
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.core.unsafeAssertNotNull
import world.phantasmal.core.unsafe.unsafeAssertNotNull
import world.phantasmal.observable.Observer
import world.phantasmal.observable.value.AbstractVal

5
web/src/main/kotlin/world/phantasmal/web/core/rendering/conversion/MeshBuilder.kt
View File

@ -3,17 +3,16 @@ package world.phantasmal.web.core.rendering.conversion
import org.khronos.webgl.Float32Array
import org.khronos.webgl.Uint16Array
import org.khronos.webgl.set
import world.phantasmal.core.JsMap
import world.phantasmal.core.asArray
import world.phantasmal.core.emptyJsMap
import world.phantasmal.core.jsArrayOf
import world.phantasmal.core.unsafe.UnsafeMap
import world.phantasmal.lib.fileFormats.ninja.XvrTexture
import world.phantasmal.web.externals.three.*
import world.phantasmal.webui.obj
class MeshBuilder(
private val textures: List<XvrTexture?> = emptyList(),
private val textureCache: JsMap<Int, Texture?> = emptyJsMap(),
private val textureCache: UnsafeMap<Int, Texture?> = UnsafeMap(),
) {
private val positions = mutableListOf<Vector3>()
private val normals = mutableListOf<Vector3>()

21
web/src/main/kotlin/world/phantasmal/web/core/rendering/conversion/NinjaGeometryConversion.kt
View File

@ -4,6 +4,7 @@ import mu.KotlinLogging
import org.khronos.webgl.Float32Array
import org.khronos.webgl.Uint16Array
import world.phantasmal.core.*
import world.phantasmal.core.unsafe.UnsafeMap
import world.phantasmal.lib.fileFormats.*
import world.phantasmal.lib.fileFormats.ninja.*
import world.phantasmal.web.core.dot
@ -128,12 +129,13 @@ fun renderGeometryToGroup(
processMesh: (AreaSection, AreaObject, Mesh) -> Unit = { _, _, _ -> },
): Group {
val group = Group()
val textureCache = emptyJsMap<Int, Texture?>()
val meshCache = emptyJsMap<XjObject, Mesh>()
val textureCache = UnsafeMap<Int, Texture?>()
val meshCache = UnsafeMap<XjObject, Mesh>()
for ((sectionIndex, section) in renderGeometry.sections.withIndex()) {
for (areaObj in section.objects) {
group.add(areaObjectToMesh(
group.add(
areaObjectToMesh(
textures,
textureCache,
meshCache,
@ -141,11 +143,13 @@ fun renderGeometryToGroup(
sectionIndex,
areaObj,
processMesh,
))
)
)
}
for (areaObj in section.animatedObjects) {
group.add(areaObjectToMesh(
group.add(
areaObjectToMesh(
textures,
textureCache,
meshCache,
@ -153,7 +157,8 @@ fun renderGeometryToGroup(
sectionIndex,
areaObj,
processMesh,
))
)
)
}
}
@ -200,8 +205,8 @@ fun AreaObject.fingerPrint(): String =
private fun areaObjectToMesh(
textures: List<XvrTexture?>,
textureCache: JsMap<Int, Texture?>,
meshCache: JsMap<XjObject, Mesh>,
textureCache: UnsafeMap<Int, Texture?>,
meshCache: UnsafeMap<XjObject, Mesh>,
section: AreaSection,
sectionIndex: Int,
areaObj: AreaObject,

15
web/src/main/kotlin/world/phantasmal/web/core/stores/ItemDropStore.kt
View File

@ -1,7 +1,6 @@
package world.phantasmal.web.core.stores
import world.phantasmal.core.JsMap
import world.phantasmal.core.emptyJsMap
import world.phantasmal.core.unsafe.UnsafeMap
import world.phantasmal.lib.fileFormats.quest.NpcType
import world.phantasmal.web.core.loading.AssetLoader
import world.phantasmal.web.core.models.Server
@ -25,21 +24,21 @@ class ItemDropStore(
private suspend fun loadEnemyDropTable(server: Server): EnemyDropTable {
val drops = assetLoader.load<List<EnemyDrop>>("/enemy_drops.${server.slug}.json")
val table = emptyJsMap<Difficulty, JsMap<SectionId, JsMap<NpcType, EnemyDrop>>>()
val itemTypeToDrops = emptyJsMap<Int, MutableList<EnemyDrop>>()
val table = UnsafeMap<Difficulty, UnsafeMap<SectionId, UnsafeMap<NpcType, EnemyDrop>>>()
val itemTypeToDrops = UnsafeMap<Int, MutableList<EnemyDrop>>()
for (drop in drops) {
var diffTable = table.get(drop.difficulty)
if (diffTable == null) {
diffTable = emptyJsMap()
diffTable = UnsafeMap()
table.set(drop.difficulty, diffTable)
}
var sectionIdTable = diffTable.get(drop.sectionId)
if (sectionIdTable == null) {
sectionIdTable = emptyJsMap()
sectionIdTable = UnsafeMap()
diffTable.set(drop.sectionId, sectionIdTable)
}
@ -60,11 +59,11 @@ class ItemDropStore(
}
class EnemyDropTable(
private val table: JsMap<Difficulty, JsMap<SectionId, JsMap<NpcType, EnemyDrop>>>,
private val table: UnsafeMap<Difficulty, UnsafeMap<SectionId, UnsafeMap<NpcType, EnemyDrop>>>,
/**
* Mapping of [ItemType] ids to [EnemyDrop]s.
*/
private val itemTypeToDrops: JsMap<Int, MutableList<EnemyDrop>>,
private val itemTypeToDrops: UnsafeMap<Int, MutableList<EnemyDrop>>,
) {
fun getDrop(difficulty: Difficulty, sectionId: SectionId, npcType: NpcType): EnemyDrop? =
table.get(difficulty)?.get(sectionId)?.get(npcType)

17
web/src/main/kotlin/world/phantasmal/web/huntOptimizer/stores/HuntOptimizerStore.kt
View File

@ -5,6 +5,7 @@ import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import mu.KotlinLogging
import world.phantasmal.core.*
import world.phantasmal.core.unsafe.UnsafeMap
import world.phantasmal.lib.fileFormats.quest.NpcType
import world.phantasmal.observable.value.Val
import world.phantasmal.observable.value.list.ListVal
@ -134,7 +135,7 @@ class HuntOptimizerStore(
// enemies that drop the item multiplied by the corresponding drop rate as its value.
val variables: dynamic = obj {}
// Each variable has a matching FullMethod.
val fullMethods = emptyJsMap<String, FullMethod>()
val fullMethods = UnsafeMap<String, FullMethod>()
val wantedItemTypeIds = emptyJsSet<Int>()
@ -148,7 +149,7 @@ class HuntOptimizerStore(
for (method in methods) {
// Calculate enemy counts including rare enemies
// Counts include rare enemies, so they are fractional.
val counts = emptyJsMap<NpcType, Double>()
val counts = UnsafeMap<NpcType, Double>()
for ((enemyType, count) in method.enemyCounts) {
val rareEnemyType = enemyType.rareType
@ -191,15 +192,15 @@ class HuntOptimizerStore(
dropTable: EnemyDropTable,
wantedItemTypeIds: JsSet<Int>,
method: HuntMethodModel,
defaultCounts: JsMap<NpcType, Double>,
defaultCounts: UnsafeMap<NpcType, Double>,
splitPanArms: Boolean,
variables: dynamic,
fullMethods: JsMap<String, FullMethod>,
fullMethods: UnsafeMap<String, FullMethod>,
) {
val counts: JsMap<NpcType, Double>?
val counts: UnsafeMap<NpcType, Double>?
if (splitPanArms) {
var splitPanArmsCounts: JsMap<NpcType, Double>? = null
var splitPanArmsCounts: UnsafeMap<NpcType, Double>? = null
// Create a secondary counts map if there are any pan arms that can be split
// into migiums and hidooms.
@ -207,7 +208,7 @@ class HuntOptimizerStore(
val panArms2Count = defaultCounts.get(NpcType.PanArms2)
if (panArmsCount != null || panArms2Count != null) {
splitPanArmsCounts = emptyJsMap()
splitPanArmsCounts = UnsafeMap()
if (panArmsCount != null) {
splitPanArmsCounts.delete(NpcType.PanArms)
@ -262,7 +263,7 @@ class HuntOptimizerStore(
wantedItemTypeIds: JsSet<Int>,
constraints: dynamic,
variables: dynamic,
fullMethods: JsMap<String, FullMethod>,
fullMethods: UnsafeMap<String, FullMethod>,
): List<OptimalMethodModel> {
val result = Solver.Solve(obj {
optimize = "time"

2
web/src/main/kotlin/world/phantasmal/web/questEditor/stores/AsmStore.kt
View File

@ -140,7 +140,7 @@ class AsmStore(
})
setBytecodeIrTimeout?.let(window::clearTimeout)
setBytecodeIrTimeout = window.setTimeout(::setBytecodeIr, 300)
setBytecodeIrTimeout = window.setTimeout(::setBytecodeIr, 1000)
// TODO: Update breakpoints.
}

2
webui/src/main/kotlin/world/phantasmal/webui/dom/HTMLElementSizeVal.kt
View File

@ -3,7 +3,7 @@ package world.phantasmal.webui.dom
import org.w3c.dom.HTMLElement
import world.phantasmal.core.disposable.Disposable
import world.phantasmal.core.disposable.disposable
import world.phantasmal.core.unsafeAssertNotNull
import world.phantasmal.core.unsafe.unsafeAssertNotNull
import world.phantasmal.observable.Observer
import world.phantasmal.observable.value.AbstractVal