String-returning functions now explicitly returning java.lang.String

assets/disk0/home/hdk/jmp.js

@@ -10,58 +10,4 @@ const magic = sys.peek(ptr)
 
 if (magic != 0xA5) return 1
 
-//////////////////////////////////
+eval(sys.toObjectCode(ptr))
-
-function seq(s) {
-    let out = ""
-    let cnt = 0
-    let oldchar = s[0]
-    for (let char of s) {
-        if (char === oldchar) {
-            cnt += 1
-        }
-        else {
-            out += ('' + cnt) + oldchar
-            cnt = 1
-        }
-        oldchar = char
-    }
-    return out + cnt + oldchar
-}
-
-let key = "00"
-let keyBytes = [0x00]
-let keyCursor = 0
-
-function getNewKeySeq() {
-    key = seq(key)
-    keyBytes = []
-    keyCursor = 0
-    for (let i = 0; i < key.length; i += 2) {
-        keyBytes.push(parseInt(key.substring(i, i+2), 16))
-    }
-}
-
-//////////////////////////////////
-
-const payloadSize = (sys.peek(ptr+1) << 16) | (sys.peek(ptr+2) << 8) | sys.peek(ptr+3)
-
-let encrypted = new Int8Array(payloadSize)
-
-// read and decrypt
-for (let outcnt = 0; outcnt < payloadSize; outcnt++) {
-    encrypted[outcnt] = sys.peek(ptr+4+outcnt) ^ keyBytes[keyCursor++]
-    if (keyCursor >= keyBytes.length) {
-        getNewKeySeq()
-    }
-}
-
-let image = gzip.decomp(encrypted)
-
-// convert java ByteArray into JS string
-var simg = ""
-for (let b of image) {
-    simg += String.fromCharCode(b & 255)
-}
-
-eval(simg)

tsvm_core/src/net/torvald/tsvm/Base64Delegate.kt

@@ -9,14 +9,14 @@ class Base64Delegate(val vm: VM) {
         return Base64Coder.decode(inputstr)
     }
 
-    fun atostr(inputstr: String): String {
+    fun atostr(inputstr: String): java.lang.String {
-        return Base64Coder.decode(inputstr).toString(VM.CHARSET)
+        return Base64Coder.decode(inputstr).toString(VM.CHARSET) as java.lang.String
     }
 
-    fun btoa(inputbytes: ByteArray): String {
+    fun btoa(inputbytes: ByteArray): java.lang.String {
         val sb = StringBuilder()
         sb.append(Base64Coder.encode(inputbytes))
-        return sb.toString()
+        return sb.toString() as java.lang.String
     }
 
     fun atoptr(inputstr: String): Int {

tsvm_core/src/net/torvald/tsvm/VMJSR223Delegate.kt

@@ -2,8 +2,10 @@ package net.torvald.tsvm
 
 import net.torvald.UnsafeHelper
 import net.torvald.UnsafePtr
+import net.torvald.terrarum.modulecomputers.virtualcomputer.tvd.toUint
 import net.torvald.terrarum.modulecomputers.virtualcomputer.tvd.toUlong
 import net.torvald.tsvm.peripheral.*
+import java.nio.charset.Charset
 
 /**
  * Pass the instance of the class to the ScriptEngine's binding, preferably under the namespace of "vm"
@@ -111,9 +113,9 @@ class VMJSR223Delegate(private val vm: VM) {
     fun mapRom(slot: Int) {
         vm.romMapping = slot.and(255)
     }
-    fun romReadAll(): String {
+    fun romReadAll(): java.lang.String {
-        if (vm.romMapping == 255 || vm.romMapping !in vm.roms.indices || vm.roms[vm.romMapping] == null) return ""
+        if (vm.romMapping == 255 || vm.romMapping !in vm.roms.indices || vm.roms[vm.romMapping] == null) return "" as java.lang.String
-        return vm.roms[vm.romMapping]!!.readAll()
+        return vm.roms[vm.romMapping]!!.readAll() as java.lang.String
     }
 
     // @return in milliseconds
@@ -262,6 +264,62 @@ class VMJSR223Delegate(private val vm: VM) {
     fun getMallocStatus(): IntArray {
         return intArrayOf(vm.MALLOC_UNIT, vm.allocatedBlockCount)
     }
+
+    fun toObjectCode(ptr: Int): java.lang.String {
+        val payloadSize = peek(ptr+1).shl(16) or peek(ptr+2).shl(8) or peek(ptr+3)
+
+        val decrypted = decryptPayload(ptr, payloadSize)
+        val image = CompressorDelegate.decomp(decrypted)
+        return java.lang.String(image)
+    }
+
+
+    private fun decryptPayload(ptr: Int, payloadSize: Int): ByteArray {
+        var key = "00"
+        var keyBytes = byteArrayOf(0x00)
+        var keyCursor = 0
+
+        fun seq(s: String): String {
+            var out = ""
+            var cnt = 0
+            var oldchar = s[0]
+
+            for (char in s) {
+                if (char == oldchar) {
+                    cnt += 1
+                } else {
+                    out += cnt.toString() + oldchar
+                    cnt = 1
+                }
+                oldchar = char
+            }
+
+            return out + cnt + oldchar
+        }
+
+        fun getNewKeySeq() {
+            key = seq(key)
+            keyBytes = ByteArray(key.length / 2)
+            keyCursor = 0
+
+            for (i in 0 until key.length step 2) {
+                keyBytes[i / 2] = key.substring(i, minOf(i + 2, key.length)).toInt(16).toByte()
+            }
+        }
+
+        ////////////////////////////
+
+        val encrypted = ByteArray(payloadSize)
+
+        for (outcnt in 0 until payloadSize) {
+            encrypted[outcnt] = (peek(ptr + 4 + outcnt) xor keyBytes[keyCursor++].toUint()).toByte()
+            if (keyCursor >= keyBytes.size) {
+                getNewKeySeq()
+            }
+        }
+
+        return encrypted
+    }
 }
 
 class VMSerialDebugger(private val vm: VM) {