3.4.0

Author: elect86

.idea/gradle.xml

@@ -17,17 +17,16 @@ To have a quick idea what this library offers, take a look at the [tests](https:
 
 ### Differences with kotlin stdlib: 
 
-- this project uses classes instead inline classes. To address this in critical scenarios where allocations may have a sensitive impact, primitive variable holding the utype value is a `var`, so you can re-use the same istance over and over again
-- utypes extend `Number` abstract class
+- this project uses classes instead inline classes. To address this in critical scenarios where allocations may have a sensitive impact, primitive variable holding the unsigned 
+type value is a `var`, so you can re-use the same instance over and over again
+- unsigned types extend `Number` abstract class
 - automatic conversions
 - it is possible to string format by calling the corresponding `format()` method, eg: `ubyte.format("%08x")`
-- all the utypes implement all the function, including `shl` and `shr` for `Ubyte` and `Ushort`
-- if you add an `Ushort` to another `Ushort` you get an `Ushort` (and not an `Uint`)
+- all the unsigned types implement all the function, including `shl` and `shr` for `Ubyte` and `Ushort`
+- there is no automatic padding to integer for unsigned bytes and shorts, so if you add an `Ushort` to another `Ushort` you get an `Ushort` (and not an `Uint`)
 
 ### Install:
 
-With Gradle `kx.util` plugin, everything is nicely aligned and the boilerplate code is gone
-
 #### mary
 ```kotlin
 repositories {

.idea/kotlinc.xml

@@ -1,43 +1,75 @@
 import magik.createGithubPublication
 import magik.github
 import org.jetbrains.kotlin.gradle.dsl.KotlinCompile
+import uns.gen.GenerateCode
 import java.util.*
 
 plugins {
-    kotlin("jvm") version embeddedKotlinVersion
+    kotlin("multiplatform") version embeddedKotlinVersion
     id("elect86.magik") version "0.3.3"
     `maven-publish`
     signing
     `jvm-test-suite`
-//    id("com.github.johnrengelman.shadow") version "8.1.1"
+    //    id("com.github.johnrengelman.shadow") version "8.1.1"
 }
 
 repositories { mavenCentral() }
 
-dependencies {
-    testImplementation("io.kotest:kotest-runner-junit5:5.7.1")
-    testImplementation("io.kotest:kotest-assertions-core:5.7.1")
+kotlin {
+    jvm {
+        jvmToolchain(11)
+        withJava()
+    }
+    val hostOs = System.getProperty("os.name")
+    val isArm64 = System.getProperty("os.arch") == "aarch64"
+    val isMingwX64 = hostOs.startsWith("Windows")
+    val nativeTarget = when {
+        hostOs == "Mac OS X" && isArm64 -> macosArm64("native")
+        hostOs == "Mac OS X" && !isArm64 -> macosX64("native")
+        hostOs == "Linux" && isArm64 -> linuxArm64("native")
+        hostOs == "Linux" && !isArm64 -> linuxX64("native")
+        isMingwX64 -> mingwX64("native")
+        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
+    }
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                implementation("com.ionspin.kotlin:bignum:0.3.8")
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+            }
+        }
+        val jvmMain by getting
+        val jvmTest by getting
+        //        val jsMain by getting
+        //        val jsTest by getting
+        val nativeMain by getting
+        val nativeTest by getting
+    }
 }
 
-kotlin.jvmToolchain { languageVersion.set(JavaLanguageVersion.of(11)) }
-
 tasks {
+    val generateCode by registering(GenerateCode::class)
+    kotlin.sourceSets.commonMain { kotlin.srcDir(generateCode) }
     withType<KotlinCompile<*>>().all { kotlinOptions { freeCompilerArgs += listOf("-opt-in=kotlin.RequiresOptIn") } }
 }
 
 testing.suites {
     val test by getting(JvmTestSuite::class) { useJUnitJupiter() }
 }
 
-java {
-    withJavadocJar()
-    withSourcesJar()
-}
+//java {
+//    withJavadocJar()
+//    withSourcesJar()
+//}
 
 
 configure<PublishingExtension> {
     publications {
-        createGithubPublication("Github") {
+        createGithubPublication {
             from(components["java"])
             suppressAllPomMetadataWarnings()
         }
@@ -50,31 +82,18 @@ configure<PublishingExtension> {
                 usage("java-runtime") { fromResolutionResult() }
             }
             pom {
-                name.set("kotlin-unsigned")
-                description.set("unsigned support for Kotlin via boxed types and unsigned operators")
-                url.set("https://github.com/kotlin-graphics/kotlin-unsigned")
-                licenses {
-                    license {
-                        name.set("MIT")
-                        url.set("https://choosealicense.com/licenses/mit/")
-                    }
-                }
+                name = "kotlin-unsigned"
+                description = "unsigned support for Kotlin via boxed types and unsigned operators"
+                url = "https://github.com/kotlin-graphics/kotlin-unsigned"
+                licenses { license { name = "MIT"; url = "https://choosealicense.com/licenses/mit/" } }
                 developers {
-                    developer {
-                        id.set("elect86")
-                        name.set("Giuseppe Barbieri")
-                        email.set("[email protected]")
-                    }
-                    developer {
-                        id.set("bixilon")
-                        name.set("Moritz Zwerger")
-                        email.set("[email protected]")
-                    }
+                    developer { id = "elect86"; name = "Giuseppe Barbieri"; email = "[email protected]" }
+                    developer { id = "bixilon"; name = "Moritz Zwerger"; email = "[email protected]" }
                 }
                 scm {
-                    connection.set("scm:git:https://github.com/kotlin-graphics/kotlin-unsigned.git")
-                    developerConnection.set("scm:git:ssh://[email protected]:kotlin-graphics/kotlin-unsigned.git")
-                    url.set("https://github.com/kotlin-graphics/kotlin-unsigned")
+                    connection = "scm:git:https://github.com/kotlin-graphics/kotlin-unsigned.git"
+                    developerConnection = "scm:git:ssh://[email protected]:kotlin-graphics/kotlin-unsigned.git"
+                    url = "https://github.com/kotlin-graphics/kotlin-unsigned"
                 }
             }
         }

.idea/misc.xml

@@ -0,0 +1,7 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    gradlePluginPortal()
+}

.kotlintest/spec_failures

@@ -0,0 +1 @@
+rootProject.name = "buildSrc"

.travis.yml

@@ -0,0 +1,63 @@
+package uns
+
+import uns.gen.Generator
+import uns.gen.generate
+
+fun arrays() {
+    generate("arrays") {
+        imports += "kotlin.jvm.JvmInline"
+        imports += "kotlin.jvm.JvmName"
+        imports += "kotlin.experimental.ExperimentalTypeInference"
+        experimentals += Generator.Experimentals.UnsignedTypes
+        experimentals += Generator.Experimentals.TypeInference
+        for (info in unsInfos) {
+            val Type = info.type
+            val TypeArray = Type + "Array"
+            val CounterArray = info.counterType + "Array"
+            val CounterType = info.counterType
+            +"""
+                @JvmInline
+                value class $TypeArray(val data: $CounterArray) {
+                
+                    operator fun get(index: I32): $Type = $Type(data[index])
+                
+                    operator fun set(index: I32, value: $Type) { data[index] = value.v }
+                    
+                    val indices: IntRange
+                        get() = data.indices
+                }
+                
+                fun $TypeArray(size: I32): $TypeArray = $TypeArray($CounterArray(size))
+                @OverloadResolutionByLambdaReturnType
+                @JvmName("$TypeArray$CounterType")
+                inline fun $TypeArray(size: I32, init: (I32) -> $CounterType): $TypeArray = $TypeArray($CounterArray(size, init))
+                @OverloadResolutionByLambdaReturnType
+                @JvmName("$TypeArray$Type")
+                inline fun $TypeArray(size: I32, init: (I32) -> $Type): $TypeArray {
+                    val array = $TypeArray($CounterArray(size))
+                    for (i in array.indices)
+                        array[i] = init(i)
+                    return array
+                }"""
+            if (info.bits != 32)
+                +"""
+                    @OverloadResolutionByLambdaReturnType
+                    @JvmName("${TypeArray}I32")
+                    inline fun $TypeArray(size: I32, init: (I32) -> I32): $TypeArray {
+                        val array = $TypeArray($CounterArray(size))
+                        for (i in array.indices)
+                            array.data[i] = init(i).to$CounterType()
+                        return array
+                    }
+                    @OverloadResolutionByLambdaReturnType
+                    @JvmName("${TypeArray}U32")
+                    inline fun $TypeArray(size: I32, init: (I32) -> U32): $TypeArray {
+                        val array = $TypeArray($CounterArray(size))
+                        for (i in array.indices)
+                            array.data[i] = init(i).to$CounterType()
+                        return array
+                    }"""
+        }
+    }
+}
+