refactor: add more platforms

Author: iseki0

build.gradle.kts

@@ -46,6 +46,26 @@ kotlin {
     js {
         browser()
     }
+
+    macosX64()
+    macosArm64()
+    iosSimulatorArm64()
+    iosX64()
+    iosArm64()
+
+    watchosArm32()
+    watchosArm64()
+    watchosX64()
+    watchosSimulatorArm64()
+    tvosSimulatorArm64()
+    tvosX64()
+    tvosArm64()
+
+    linuxX64()
+    linuxArm64()
+    mingwX64()
+    
+
     sourceSets {
         all {
             languageSettings {

gradle.properties

@@ -1,3 +1,6 @@
-kotlin.code.style=official
-org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 org.gradle.configuration-cache=true
+org.gradle.caching=true
+org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
+kotlin.daemon.jvmargs=-Xmx6g
+kotlin.native.enableKlibsCrossCompilation=true
+org.gradle.jvmargs=-Xmx2g

src/commonMain/kotlin/space/iseki/bencoding/BinaryStringStrategy.kt

@@ -1,7 +1,6 @@
 package space.iseki.bencoding
 
 import kotlinx.serialization.descriptors.SerialDescriptor
-import space.iseki.bencoding.internal.bytes2StringIso88591
 import kotlin.io.encoding.ExperimentalEncodingApi
 
 /**
@@ -39,7 +38,7 @@ enum class BinaryStringStrategy {
         strategy = strategy,
         options = options,
         base64 = { kotlin.io.encoding.Base64.encode(decodeByteArray()) },
-        raw = { decodeRaw(decodeByteArray()) },
+        raw = { bytes2StringIso88591(decodeByteArray()) },
     )
 
     context(BencodeEncoder)
@@ -85,11 +84,7 @@ enum class BinaryStringStrategy {
         return bytes
     }
 
-    private fun decodeRaw(bytes: ByteArray): String {
-        return bytes2StringIso88591(bytes) ?: decodeRawFallback(bytes)
-    }
-
-    private fun decodeRawFallback(bytes: ByteArray): String {
+    private fun bytes2StringIso88591(bytes: ByteArray): String {
         val chars = CharArray(bytes.size)
         for (i in bytes.indices) {
             chars[i] = (bytes[i].toInt() and 0xff).toChar()

src/commonMain/kotlin/space/iseki/bencoding/internal/BytesLexer.kt

@@ -14,7 +14,7 @@ internal class BytesLexer(private val bytes: ByteArray) : CommonLexer() {
         while (i < bytes.size && (bytes[i] in '0'.code..'9'.code || bytes[i] == '-'.code.toByte())) i++
         if (i == pos) decodeError("invalid number")
         try {
-            return bytes2Long(bytes, pos, i - pos)
+            return bytes.copyOfRange(pos, i).decodeToString().toLong()
         } catch (e: NumberFormatException) {
             decodeError("invalid number")
         } finally {

src/commonMain/kotlin/space/iseki/bencoding/internal/Utils.kt

@@ -3,14 +3,55 @@ package space.iseki.bencoding.internal
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.descriptors.SerialDescriptor
 import space.iseki.bencoding.BinaryString
-
-internal expect fun bytes2Long(bytes: ByteArray, off: Int, len: Int): Long
-internal expect fun bytes2StringIso88591(bytes: ByteArray, off: Int = 0, len: Int = bytes.size): String?
+import kotlin.math.max
 
 @OptIn(ExperimentalSerializationApi::class)
 internal fun SerialDescriptor.binaryStringAnnotation(childIndex: Int) =
     getElementAnnotations(childIndex).firstOrNull { it is BinaryString } as BinaryString?
 
-internal expect fun createBytesWriter0(): BWriter
 internal fun createBytesWriter(): BWriter = createBytesWriter0()
 
+internal fun createBytesWriter0(): BWriter = object : BWriter {
+    private var pos = 0
+    private fun ensureSize(delta: Int) {
+        val newLen = pos + delta
+        if (newLen < ba.size) {
+            return
+        }
+        val target = ByteArray(newLength(ba.size, delta, ba.size))
+        ba.copyInto(target)
+        ba = target
+    }
+
+    private var ba = ByteArray(32)
+    override fun writeData(b: Int) {
+        ensureSize(1)
+        ba[pos++] = b.toByte()
+    }
+
+    override fun writeData(b: ByteArray) {
+        ensureSize(b.size)
+        b.copyInto(ba, pos)
+        pos += b.size
+    }
+
+    override fun getByteArray(): ByteArray {
+        return ba.sliceArray(0 until pos)
+    }
+}
+
+private fun newLength(oldLength: Int, minGrowth: Int, prefGrowth: Int): Int {
+    val prefLength = (oldLength + max(minGrowth, prefGrowth)) // might overflow
+    return if (0 < prefLength && prefLength <= Int.MAX_VALUE - 8) {
+        prefLength
+    } else {
+        val minLength = oldLength + minGrowth
+        return if (minLength < 0) { // overflow
+            throw Error("Required array length $oldLength + $minGrowth is too large")
+        } else if (minLength <= Int.MAX_VALUE - 8) {
+            Int.MAX_VALUE - 8
+        } else {
+            minLength
+        }
+    }
+}