regenerate skeletons and set version 10.4

This makes the naming consistent with the other cbm-like targets (c64, pet, c128). Only the x16 specific ones remain in the cx16 namespace, such as cx16.KEYHDL

Probably the most impactful is the move of cx16.CINV to cbm.CINV

.idea/kotlinc.xml

@@ -4,6 +4,6 @@
     <option name="jvmTarget" value="11" />
   </component>
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.9.20" />
+    <option name="version" value="1.9.24" />
   </component>
-</project>
+</project>

.idea/libraries/KotlinJavaRuntime.xml

@@ -1,23 +1,23 @@
 <component name="libraryTable">
   <library name="KotlinJavaRuntime" type="repository">
-    <properties maven-id="org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.22" />
+    <properties maven-id="org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.0.20" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.22/kotlin-stdlib-jdk8-1.9.22.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.22/kotlin-stdlib-1.9.22.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.0.20/kotlin-stdlib-jdk8-2.0.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.0.20/kotlin-stdlib-2.0.20.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.9.22/kotlin-stdlib-jdk7-1.9.22.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.0.20/kotlin-stdlib-jdk7-2.0.20.jar!/" />
     </CLASSES>
     <JAVADOC>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.22/kotlin-stdlib-jdk8-1.9.22-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.22/kotlin-stdlib-1.9.22-javadoc.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.0.20/kotlin-stdlib-jdk8-2.0.20-javadoc.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.0.20/kotlin-stdlib-2.0.20-javadoc.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0-javadoc.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.9.22/kotlin-stdlib-jdk7-1.9.22-javadoc.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.0.20/kotlin-stdlib-jdk7-2.0.20-javadoc.jar!/" />
     </JAVADOC>
     <SOURCES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.22/kotlin-stdlib-jdk8-1.9.22-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.22/kotlin-stdlib-1.9.22-sources.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/2.0.20/kotlin-stdlib-jdk8-2.0.20-sources.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/2.0.20/kotlin-stdlib-2.0.20-sources.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0-sources.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.9.22/kotlin-stdlib-jdk7-1.9.22-sources.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/2.0.20/kotlin-stdlib-jdk7-2.0.20-sources.jar!/" />
     </SOURCES>
   </library>
 </component>

.idea/libraries/antlr_antlr4.xml

@@ -1,13 +1,13 @@
 <component name="libraryTable">
   <library name="antlr.antlr4" type="repository">
-    <properties maven-id="org.antlr:antlr4:4.13.1">
+    <properties maven-id="org.antlr:antlr4:4.13.2">
       <exclude>
         <dependency maven-id="com.ibm.icu:icu4j" />
       </exclude>
     </properties>
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.13.1/antlr4-4.13.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.13.1/antlr4-runtime-4.13.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.13.2/antlr4-4.13.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.13.2/antlr4-runtime-4.13.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr-runtime/3.5.3/antlr-runtime-3.5.3.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/antlr/ST4/4.3.4/ST4-4.3.4.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/abego/treelayout/org.abego.treelayout.core/1.0.3/org.abego.treelayout.core-1.0.3.jar!/" />

.idea/libraries/io_kotest_assertions_core_jvm.xml

@@ -1,21 +1,18 @@
 <component name="libraryTable">
   <library name="io.kotest.assertions.core.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.8.0" />
+    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.9.1" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.8.0/kotest-assertions-core-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.8.10/kotlin-stdlib-jdk8-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.8.10/kotlin-stdlib-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.8.10/kotlin-stdlib-jdk7-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.8.0/kotest-assertions-shared-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.9.1/kotest-assertions-core-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.9.1/kotest-assertions-shared-jvm-5.9.1.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.8.10/kotlin-stdlib-common-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.7.0/kotlinx-coroutines-jdk8-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.8.10/kotlin-reflect-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.8.0/kotest-common-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.8.0/kotest-assertions-api-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.7.0/kotlinx-coroutines-core-jvm-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/23.0.0/annotations-23.0.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.23/kotlin-stdlib-1.9.23.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.8.0/kotlinx-coroutines-jdk8-1.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.9.23/kotlin-reflect-1.9.23.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.9.1/kotest-common-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.9.1/kotest-assertions-api-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.8.0/kotlinx-coroutines-core-jvm-1.8.0.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/io_kotest_runner_junit5_jvm.xml

@@ -1,30 +1,30 @@
 <component name="libraryTable">
   <library name="io.kotest.runner.junit5.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.8.0" />
+    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.9.1" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.8.0/kotest-runner-junit5-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.8.0/kotest-framework-api-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.8.0/kotest-assertions-shared-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.9.1/kotest-runner-junit5-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.9.1/kotest-framework-api-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.9.1/kotest-assertions-shared-jvm-5.9.1.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.7.0/kotlinx-coroutines-test-jvm-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.8.0/kotest-common-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.8.0/kotest-framework-engine-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.162/classgraph-4.8.162.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.8.0/kotlinx-coroutines-test-jvm-1.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.9.1/kotest-common-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.9.1/kotest-framework-engine-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.172/classgraph-4.8.172.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/com/github/ajalt/mordant/1.2.1/mordant-1.2.1.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/com/github/ajalt/colormath/1.2.0/colormath-1.2.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.7.0/kotlinx-coroutines-debug-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.8.0/kotlinx-coroutines-debug-1.8.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna/5.9.0/jna-5.9.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna-platform/5.9.0/jna-platform-5.9.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.10.9/byte-buddy-1.10.9.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.10.9/byte-buddy-agent-1.10.9.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.8.0/kotest-framework-discovery-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.8.0/kotest-assertions-core-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.7.0/kotlinx-coroutines-jdk8-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.8.0/kotest-assertions-api-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.8.0/kotest-extensions-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.8.0/kotest-framework-concurrency-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.7.0/kotlinx-coroutines-core-jvm-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.9.1/kotest-framework-discovery-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.9.1/kotest-assertions-core-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.8.0/kotlinx-coroutines-jdk8-1.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.9.1/kotest-assertions-api-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.9.1/kotest-extensions-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.9.1/kotest-framework-concurrency-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.8.0/kotlinx-coroutines-core-jvm-1.8.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/23.0.0/annotations-23.0.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.8.2/junit-platform-engine-1.8.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.8.2/junit-platform-commons-1.8.2.jar!/" />
@@ -32,11 +32,8 @@
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-suite-api/1.8.2/junit-platform-suite-api-1.8.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-launcher/1.8.2/junit-platform-launcher-1.8.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.2/junit-jupiter-api-5.8.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.8.10/kotlin-stdlib-jdk8-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.8.10/kotlin-stdlib-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.8.10/kotlin-stdlib-jdk7-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.8.10/kotlin-stdlib-common-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.8.10/kotlin-reflect-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.23/kotlin-stdlib-1.9.23.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.9.23/kotlin-reflect-1.9.23.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/michael_bull_kotlin_result_jvm.xml

@@ -1,8 +1,8 @@
 <component name="libraryTable">
   <library name="michael.bull.kotlin.result.jvm" type="repository">
-    <properties maven-id="com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.20" />
+    <properties maven-id="com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.0" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/1.1.20/kotlin-result-jvm-1.1.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/2.0.0/kotlin-result-jvm-2.0.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.22/kotlin-stdlib-1.9.22.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
     </CLASSES>

.idea/misc.xml

@@ -22,7 +22,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <type id="Python" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="openjdk-11" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

README.md

@@ -53,6 +53,7 @@ What does Prog8 provide?
 
 - all advantages of a higher level language over having to write assembly code manually
 - programs run very fast because compilation to native machine code
+- code often is smaller and faster than equivalent C code compiled with CC65 or even LLVM-MOS
 - modularity, symbol scoping, subroutines
 - various data types other than just bytes (16-bit words, floats, strings)
 - floating point math is supported if the target system provides floating point library routines (C64 and Cx16 both do)
@@ -66,7 +67,7 @@ What does Prog8 provide?
 - conditional branches
 - ``when`` statement to provide a concise jump table alternative to if/elseif chains
 - ``in`` expression for concise and efficient multi-value/containment check 
-- many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``sort`` and ``reverse``
+- several specialized built-in functions such as ``lsb``, ``msb``, ``min``, ``max``, ``rol``, ``ror``
 - various powerful built-in libraries to do I/O, number conversions, graphics and more  
 - convenience abstractions for low level aspects such as ZeroPage handling, program startup, explicit memory addresses
 - inline assembly allows you to have full control when every cycle or byte matters

codeCore/build.gradle

@@ -6,9 +6,8 @@ plugins {
 }
 
 java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(javaVersion)
-    }
+    targetCompatibility = JavaLanguageVersion.of(javaVersion)
+    sourceCompatibility = JavaLanguageVersion.of(javaVersion)
 }
 
 compileKotlin {
@@ -26,7 +25,7 @@ compileTestKotlin {
 dependencies {
     // should have no dependencies to other modules
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.20"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.0"
 }
 
 sourceSets {

codeCore/src/prog8/code/SymbolTable.kt

@@ -82,8 +82,7 @@ class SymbolTable(astProgram: PtProgram) : StNode(astProgram.name, StNodeType.GL
     override fun lookup(scopedName: String) = flat[scopedName]
 
     fun getLength(name: String): Int? {
-        val node = flat[name]
-        return when(node) {
+        return when(val node = flat[name]) {
             is StMemVar -> node.length
             is StMemorySlab -> node.size.toInt()
             is StStaticVariable -> node.length
@@ -223,7 +222,7 @@ class StMemVar(name: String,
     init{
         require(dt!=DataType.BOOL && dt!=DataType.ARRAY_BOOL)
         if(dt in ArrayDatatypes || dt == DataType.STR)
-            require(length!=null) { "memory mapped array or string must have known length" }
+            requireNotNull(length)
     }
 }
 

codeCore/src/prog8/code/ast/AstExpressions.kt

@@ -230,7 +230,7 @@ class PtBool(val value: Boolean, position: Position) : PtExpression(DataType.BOO
 
     companion object {
         fun fromNumber(number: Number, position: Position): PtBool =
-            PtBool(if(number==0.0) false else true, position)
+            PtBool(number != 0.0, position)
     }
 
     override fun hashCode(): Int = Objects.hash(type, value)
@@ -267,12 +267,12 @@ class PtNumber(type: DataType, val number: Double, position: Position) : PtExpre
     override fun hashCode(): Int = Objects.hash(type, number)
 
     override fun equals(other: Any?): Boolean {
-        if(other==null || other !is PtNumber)
-            return false
+        return if(other==null || other !is PtNumber)
+            false
         else if(type!=DataType.BOOL && other.type!=DataType.BOOL)
-            return number==other.number
+            number==other.number
         else
-            return type==other.type && number==other.number
+            type==other.type && number==other.number
     }
 
     operator fun compareTo(other: PtNumber): Int = number.compareTo(other.number)

codeCore/src/prog8/code/ast/AstPrinter.kt

@@ -63,18 +63,18 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                     "???"
             }
             is PtAsmSub -> {
-                val params = node.parameters.map {
-                                val register = it.first.registerOrPair
-                                val statusflag = it.first.statusflag
-                                "${it.second.type} ${it.second.name} @${register ?: statusflag}"
-                            }.joinToString(", ")
+                val params = node.parameters.joinToString(", ") {
+                    val register = it.first.registerOrPair
+                    val statusflag = it.first.statusflag
+                    "${it.second.type} ${it.second.name} @${register ?: statusflag}"
+                }
                 val clobbers = if (node.clobbers.isEmpty()) "" else "clobbers ${node.clobbers}"
                 val returns = if (node.returns.isEmpty()) "" else {
-                    "-> ${node.returns.map {
-                        val register = it.first.registerOrPair
-                        val statusflag = it.first.statusflag
-                        "${it.second} @${register ?: statusflag}"}
-                        .joinToString(", ")
+                    "-> ${node.returns.joinToString(", ") {
+                            val register = it.first.registerOrPair
+                            val statusflag = it.first.statusflag
+                            "${it.second} @${register ?: statusflag}"
+                        }
                     }"
                 }
                 val str = if (node.inline) "inline " else ""
@@ -108,7 +108,7 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                 }
             }
             is PtSub -> {
-                val params = node.parameters.map { "${it.type} ${it.name}" }.joinToString(", ")
+                val params = node.parameters.joinToString(", ") { "${it.type} ${it.name}" }
                 var str = "sub ${node.name}($params) "
                 if(node.returntype!=null)
                     str += "-> ${node.returntype.name.lowercase()}"

codeCore/src/prog8/code/core/BuiltinFunctions.kt

@@ -76,14 +76,14 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "ror"       to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
     "rol2"      to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
     "ror2"      to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
-    "sort"      to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
-    "reverse"   to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
     // cmp returns a status in the carry flag, but not a proper return value
     "cmp"       to FSignature(false, listOf(FParam("value1", IntegerDatatypes), FParam("value2", NumericDatatypes)), null),
     "prog8_lib_stringcompare"     to FSignature(true, listOf(FParam("str1", arrayOf(DataType.STR)), FParam("str2", arrayOf(DataType.STR))), DataType.BYTE),
     "prog8_lib_arraycopy"         to FSignature(false, listOf(FParam("source", ArrayDatatypes), FParam("target", ArrayDatatypes)), null),
     "prog8_lib_square_byte"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.BYTE, DataType.UBYTE))), DataType.UBYTE),
     "prog8_lib_square_word"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.WORD, DataType.UWORD))), DataType.UWORD),
+    "prog8_ifelse_bittest_set"    to FSignature(true, listOf(FParam("variable", ByteDatatypes), FParam("bitnumber", arrayOf(DataType.UBYTE))), DataType.BOOL),
+    "prog8_ifelse_bittest_notset" to FSignature(true, listOf(FParam("variable", ByteDatatypes), FParam("bitnumber", arrayOf(DataType.UBYTE))), DataType.BOOL),
     "abs"       to FSignature(true, listOf(FParam("value", NumericDatatypes)), null),
     "abs__byte"  to FSignature(true, listOf(FParam("value", arrayOf(DataType.BYTE))), DataType.BYTE),
     "abs__word"  to FSignature(true, listOf(FParam("value", arrayOf(DataType.WORD))), DataType.WORD),
@@ -99,8 +99,6 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "divmod"           to FSignature(false, listOf(FParam("dividend", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("divisor", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("quotient", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("remainder", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
     "divmod__ubyte"    to FSignature(false, listOf(FParam("dividend", arrayOf(DataType.UBYTE)), FParam("divisor", arrayOf(DataType.UBYTE)), FParam("quotient", arrayOf(DataType.UBYTE)), FParam("remainder", arrayOf(DataType.UBYTE))), null),
     "divmod__uword"    to FSignature(false, listOf(FParam("dividend", arrayOf(DataType.UWORD)), FParam("divisor", arrayOf(DataType.UWORD)), FParam("quotient", arrayOf(DataType.UWORD)), FParam("remainder", arrayOf(DataType.UWORD))), null),
-    "any"       to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.BOOL),
-    "all"       to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.BOOL),
     "lsb"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE),
     "msb"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE),
     "mkword"    to FSignature(true, listOf(FParam("msb", arrayOf(DataType.UBYTE)), FParam("lsb", arrayOf(DataType.UBYTE))), DataType.UWORD),
@@ -136,6 +134,5 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
 val InplaceModifyingBuiltinFunctions = setOf(
     "setlsb", "setmsb",
     "rol", "ror", "rol2", "ror2",
-    "sort", "reverse",
     "divmod", "divmod__ubyte", "divmod__uword"
 )

codeCore/src/prog8/code/core/Conversions.kt

@@ -1,6 +1,11 @@
 package prog8.code.core
 
 import kotlin.math.abs
+import kotlin.math.pow
+
+val powersOfTwoFloat = (0..16).map { (2.0).pow(it) }.toTypedArray()
+val negativePowersOfTwoFloat = powersOfTwoFloat.map { -it }.toTypedArray()
+val powersOfTwoInt = (0..16).map { 2.0.pow(it).toInt() }.toTypedArray()
 
 fun Number.toHex(): String {
     //  0..15 -> "0".."15"

codeCore/src/prog8/code/core/Enumerations.kt

@@ -78,7 +78,7 @@ enum class RegisterOrPair {
     R8, R9, R10, R11, R12, R13, R14, R15;
 
     companion object {
-        val names by lazy { values().map { it.toString()} }
+        val names by lazy { entries.map { it.toString()} }
         fun fromCpuRegister(cpu: CpuRegister): RegisterOrPair {
             return when(cpu) {
                 CpuRegister.A -> A
@@ -104,7 +104,7 @@ enum class Statusflag {
     Pn;     // don't use
 
     companion object {
-        val names by lazy { values().map { it.toString()} }
+        val names by lazy { entries.map { it.toString()} }
     }
 }
 

codeCore/src/prog8/code/core/IMachineDefinition.kt

@@ -29,7 +29,6 @@ interface IMachineDefinition {
     fun convertFloatToBytes(num: Double): List<UByte>
     fun convertBytesToFloat(bytes: List<UByte>): Double
 
-    fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String>
     fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path)
     fun isIOAddress(address: UInt): Boolean
 }

codeCore/src/prog8/code/core/IStringEncoding.kt

@@ -8,7 +8,8 @@ enum class Encoding(val prefix: String) {
     ISO("iso"),                 // cx16  (iso-8859-15)
     ISO5("iso5"),               // cx16  (iso-8859-5, cyrillic)
     ISO16("iso16"),             // cx16  (iso-8859-16, eastern european)
-    CP437("cp437")              // cx16  (ibm pc, codepage 437)
+    CP437("cp437"),             // cx16  (ibm pc, codepage 437)
+    KATAKANA("kata")                 // cx16  (katakana)
 }
 
 interface IStringEncoding {

codeCore/src/prog8/code/optimize/Optimizer.kt

@@ -11,6 +11,7 @@ fun optimizeIntermediateAst(program: PtProgram, options: CompilationOptions, st:
         return
     while (errors.noErrors() &&
         (optimizeCommonSubExpressions(program, errors)
+                + optimizeBitTest(program, options)
                 + optimizeAssignTargets(program, st, errors)) > 0
     ) {
         // keep rolling
@@ -164,6 +165,51 @@ private fun optimizeAssignTargets(program: PtProgram, st: SymbolTable, errors: I
     return changes
 }
 
+
+private fun optimizeBitTest(program: PtProgram, options: CompilationOptions): Int {
+    if(options.compTarget.machine.cpu == CpuType.VIRTUAL)
+        return 0        // the special bittest optimization is not yet valid for the IR
+
+    var changes = 0
+    var recurse = true
+    walkAst(program) { node: PtNode, depth: Int ->
+        if(node is PtIfElse) {
+            val condition = node.condition as? PtBinaryExpression
+            if(condition!=null && (condition.operator=="==" || condition.operator=="!=")) {
+                if(condition.right.asConstInteger()==0) {
+                    val and = condition.left as? PtBinaryExpression
+                    if(and != null && and.operator=="&" && and.type == DataType.UBYTE) {
+                        val variable = and.left as? PtIdentifier
+                        val bitmask = and.right.asConstInteger()
+                        if(variable!=null && variable.type in ByteDatatypes && (bitmask==128 || bitmask==64)) {
+                            val setOrNot = if(condition.operator=="!=") "set" else "notset"
+                            val index = node.parent.children.indexOf(node)
+                            val bittestCall = PtBuiltinFunctionCall("prog8_ifelse_bittest_$setOrNot", false, true, DataType.BOOL, node.condition.position)
+                            bittestCall.add(variable)
+                            if(bitmask==128)
+                                bittestCall.add(PtNumber(DataType.UBYTE, 7.0, and.right.position))
+                            else
+                                bittestCall.add(PtNumber(DataType.UBYTE, 6.0, and.right.position))
+                            val ifElse = PtIfElse(node.position)
+                            ifElse.add(bittestCall)
+                            ifElse.add(node.ifScope)
+                            if(node.hasElse())
+                                ifElse.add(node.elseScope)
+                            node.parent.children[index] = ifElse
+                            ifElse.parent = node.parent
+                            changes++
+                            recurse = false
+                        }
+                    }
+                }
+            }
+        }
+        recurse
+    }
+    return changes
+}
+
+
 internal fun isSame(identifier: PtIdentifier, type: DataType, returnedRegister: RegisterOrPair): Boolean {
     if(returnedRegister in Cx16VirtualRegisters) {
         val regname = returnedRegister.name.lowercase()

codeCore/src/prog8/code/target/C64Target.kt

@@ -21,13 +21,21 @@ class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by Cb
 }
 
 
+val CompilationTargets = listOf(
+    C64Target.NAME,
+    C128Target.NAME,
+    Cx16Target.NAME,
+    PETTarget.NAME,
+    AtariTarget.NAME,
+    VMTarget.NAME
+)
 
 fun getCompilationTargetByName(name: String) = when(name.lowercase()) {
-        C64Target.NAME -> C64Target()
-        C128Target.NAME -> C128Target()
-        Cx16Target.NAME -> Cx16Target()
-        PETTarget.NAME -> PETTarget()
-        AtariTarget.NAME -> AtariTarget()
-        VMTarget.NAME -> VMTarget()
-        else -> throw IllegalArgumentException("invalid compilation target")
-    }
+    C64Target.NAME -> C64Target()
+    C128Target.NAME -> C128Target()
+    Cx16Target.NAME -> Cx16Target()
+    PETTarget.NAME -> PETTarget()
+    AtariTarget.NAME -> AtariTarget()
+    VMTarget.NAME -> VMTarget()
+    else -> throw IllegalArgumentException("invalid compilation target")
+}

codeCore/src/prog8/code/target/Encoder.kt

@@ -19,6 +19,7 @@ object Encoder: IStringEncoding {
             Encoding.ISO5 -> IsoCyrillicEncoding.encode(str)
             Encoding.ISO16 -> IsoEasternEncoding.encode(str)
             Encoding.CP437 -> Cp437Encoding.encode(str)
+            Encoding.KATAKANA -> KatakanaEncoding.encode(str)
             else -> throw InternalCompilerException("unsupported encoding $encoding")
         }
         return coded.fold(
@@ -35,6 +36,7 @@ object Encoder: IStringEncoding {
             Encoding.ISO5 -> IsoCyrillicEncoding.decode(bytes)
             Encoding.ISO16 -> IsoEasternEncoding.decode(bytes)
             Encoding.CP437 -> Cp437Encoding.decode(bytes)
+            Encoding.KATAKANA -> KatakanaEncoding.decode(bytes)
             else -> throw InternalCompilerException("unsupported encoding $encoding")
         }
         return decoded.fold(

codeCore/src/prog8/code/target/atari/AtariMachineDefinition.kt

@@ -25,13 +25,6 @@ class AtariMachineDefinition: IMachineDefinition {
     override fun convertFloatToBytes(num: Double): List<UByte> = TODO("atari float to bytes")
     override fun convertBytesToFloat(bytes: List<UByte>): Double = TODO("atari bytes to float")
 
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return if (compilerOptions.output == OutputType.XEX)
-            listOf("syslib")
-        else
-            emptyList()
-    }
-
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
         val emulatorName: String
         val cmdline: List<String>

codeCore/src/prog8/code/target/c128/C128MachineDefinition.kt

@@ -36,13 +36,6 @@ class C128MachineDefinition: IMachineDefinition {
         return m5.toDouble()
     }
 
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return if (compilerOptions.launcher == CbmPrgLauncherType.BASIC || compilerOptions.output == OutputType.PRG)
-            listOf("syslib")
-        else
-            emptyList()
-    }
-
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
         if(selectedEmulator!=1) {
             System.err.println("The c128 target only supports the main emulator (Vice).")

codeCore/src/prog8/code/target/c64/C64MachineDefinition.kt

@@ -37,13 +37,6 @@ class C64MachineDefinition: IMachineDefinition {
         return m5.toDouble()
     }
 
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return if (compilerOptions.launcher == CbmPrgLauncherType.BASIC || compilerOptions.output == OutputType.PRG)
-            listOf("syslib")
-        else
-            emptyList()
-    }
-
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
         if(selectedEmulator!=1) {
             System.err.println("The c64 target only supports the main emulator (Vice).")

codeCore/src/prog8/code/target/cx16/CX16MachineDefinition.kt

@@ -36,13 +36,6 @@ class CX16MachineDefinition: IMachineDefinition {
         return m5.toDouble()
     }
 
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return if (compilerOptions.launcher == CbmPrgLauncherType.BASIC || compilerOptions.output == OutputType.PRG)
-            listOf("syslib")
-        else
-            emptyList()
-    }
-
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
         val emulator: String
         val extraArgs: List<String>

codeCore/src/prog8/code/target/encodings/KatakanaEncoding.kt

@@ -0,0 +1,122 @@
+package prog8.code.target.encodings
+
+import com.github.michaelbull.result.Err
+import com.github.michaelbull.result.Ok
+import com.github.michaelbull.result.Result
+import java.io.CharConversionException
+import java.nio.charset.Charset
+
+
+object JapaneseCharacterConverter {
+    // adapted from https://github.com/raminduw/Japanese-Character-Converter
+
+    private val ZENKAKU_KATAKANA = charArrayOf(
+        'ァ', 'ア', 'ィ', 'イ', 'ゥ',
+        'ウ', 'ェ', 'エ', 'ォ', 'オ', 'カ', 'ガ', 'キ', 'ギ', 'ク', 'グ', 'ケ', 'ゲ',
+        'コ', 'ゴ', 'サ', 'ザ', 'シ', 'ジ', 'ス', 'ズ', 'セ', 'ゼ', 'ソ', 'ゾ', 'タ',
+        'ダ', 'チ', 'ヂ', 'ッ', 'ツ', 'ヅ', 'テ', 'デ', 'ト', 'ド', 'ナ', 'ニ', 'ヌ',
+        'ネ', 'ノ', 'ハ', 'バ', 'パ', 'ヒ', 'ビ', 'ピ', 'フ', 'ブ', 'プ', 'ヘ', 'ベ',
+        'ペ', 'ホ', 'ボ', 'ポ', 'マ', 'ミ', 'ム', 'メ', 'モ', 'ャ', 'ヤ', 'ュ', 'ユ',
+        'ョ', 'ヨ', 'ラ', 'リ', 'ル', 'レ', 'ロ', 'ヮ', 'ワ', 'ヰ', 'ヱ', 'ヲ', 'ン',
+        'ヴ', 'ヵ', 'ヶ'
+    )
+
+    private val HANKAKU_HIRAGANA = charArrayOf(
+        'ぁ', 'あ', 'ぃ', 'い', 'ぅ', 'う', 'ぇ', 'え',
+        'ぉ', 'お', 'か', 'が', 'き', 'ぎ', 'く', 'ぐ',
+        'け', 'げ', 'こ', 'ご', 'さ', 'ざ', 'し', 'じ',
+        'す', 'ず', 'せ', 'ぜ', 'そ', 'ぞ', 'た', 'だ',
+        'ち', 'ぢ', 'っ', 'つ', 'づ', 'て', 'で', 'と',
+        'ど', 'な', 'に', 'ぬ', 'ね', 'の', 'は', 'ば',
+        'ぱ', 'ひ', 'び', 'ぴ', 'ふ', 'ぶ', 'ぷ', 'へ',
+        'べ', 'ぺ', 'ほ', 'ぼ', 'ぽ', 'ま', 'み', 'む',
+        'め', 'も', 'ゃ', 'や', 'ゅ', 'ゆ', 'ょ', 'よ',
+        'ら', 'り', 'る', 'れ', 'ろ', 'ゎ', 'わ', 'ゐ',
+        'ゑ', 'を', 'ん', 'ゔ', 'ゕ', 'ゖ'
+    )
+
+    private val HANKAKU_KATAKANA = arrayOf(
+        "ｧ", "ｱ", "ｨ", "ｲ", "ｩ",
+        "ｳ", "ｪ", "ｴ", "ｫ", "ｵ", "ｶ", "ｶﾞ", "ｷ", "ｷﾞ", "ｸ", "ｸﾞ", "ｹ",
+        "ｹﾞ", "ｺ", "ｺﾞ", "ｻ", "ｻﾞ", "ｼ", "ｼﾞ", "ｽ", "ｽﾞ", "ｾ", "ｾﾞ", "ｿ",
+        "ｿﾞ", "ﾀ", "ﾀﾞ", "ﾁ", "ﾁﾞ", "ｯ", "ﾂ", "ﾂﾞ", "ﾃ", "ﾃﾞ", "ﾄ", "ﾄﾞ",
+        "ﾅ", "ﾆ", "ﾇ", "ﾈ", "ﾉ", "ﾊ", "ﾊﾞ", "ﾊﾟ", "ﾋ", "ﾋﾞ", "ﾋﾟ", "ﾌ",
+        "ﾌﾞ", "ﾌﾟ", "ﾍ", "ﾍﾞ", "ﾍﾟ", "ﾎ", "ﾎﾞ", "ﾎﾟ", "ﾏ", "ﾐ", "ﾑ", "ﾒ",
+        "ﾓ", "ｬ", "ﾔ", "ｭ", "ﾕ", "ｮ", "ﾖ", "ﾗ", "ﾘ", "ﾙ", "ﾚ", "ﾛ", "ﾜ",
+        "ﾜ", "ｲ", "ｴ", "ｦ", "ﾝ", "ｳﾞ", "ｶ", "ｹ"
+    )
+
+    private val ZENKAKU_KATAKANA_FIRST_CHAR_CODE = ZENKAKU_KATAKANA.first().code
+    private val HANKAKU_HIRAGANA_FIRST_CHAR_CODE = HANKAKU_HIRAGANA.first().code
+
+    private fun zenkakuKatakanaToHankakuKatakana(c: Char): String = if (c in ZENKAKU_KATAKANA) HANKAKU_KATAKANA[c.code - ZENKAKU_KATAKANA_FIRST_CHAR_CODE] else c.toString()
+    private fun hankakuKatakanaToZenkakuKatakana(c: Char): Char = if (c in HANKAKU_HIRAGANA) ZENKAKU_KATAKANA[c.code - HANKAKU_HIRAGANA_FIRST_CHAR_CODE] else c
+
+    fun zenkakuKatakanaToHankakuKatakana(s: String): String = buildString {
+        for (element in s) {
+            val converted = hankakuKatakanaToZenkakuKatakana(element)
+            val convertedChar = zenkakuKatakanaToHankakuKatakana(converted)
+            append(convertedChar)
+        }
+    }
+}
+
+object KatakanaEncoding {
+    val charset: Charset = Charset.forName("JIS_X0201")
+
+    fun encode(str: String): Result<List<UByte>, CharConversionException> {
+        return try {
+            val mapped = str.map { chr ->
+                when (chr) {
+
+                    '\u0000' -> 0u
+                    '\u00a0' -> 0xa0u // $a0 isn't technically a part of JIS X 0201 spec, and so we need to handle this ourselves
+
+                    '♥' -> 0xe3u
+                    '♦' -> 0xe4u
+                    '♣' -> 0xe5u
+                    '♠' -> 0xe6u
+
+                    '大' -> 0xeau
+                    '中' -> 0xebu
+                    '小' -> 0xecu
+                    '百' -> 0xedu
+                    '千' -> 0xeeu
+                    '万' -> 0xefu
+                    '♪' -> 0xf0u
+                    '土' -> 0xf1u
+                    '金' -> 0xf2u
+                    '木' -> 0xf3u
+                    '水' -> 0xf4u
+                    '火' -> 0xf5u
+                    '月' -> 0xf6u
+                    '日' -> 0xf7u
+                    '時' -> 0xf8u
+                    '分' -> 0xf9u
+                    '秒' -> 0xfau
+                    '年' -> 0xfbu
+                    '円' -> 0xfcu
+                    '人' -> 0xfdu
+                    '生' -> 0xfeu
+                    '〒' -> 0xffu
+                    in '\u8000'..'\u80ff' -> {
+                        // special case: take the lower 8 bit hex value directly
+                        (chr.code - 0x8000).toUByte()
+                    }
+                    else -> charset.encode(chr.toString())[0].toUByte()
+                }
+            }
+            Ok(mapped)
+        } catch (ce: CharConversionException) {
+            Err(ce)
+        }
+    }
+
+    fun decode(bytes: Iterable<UByte>): Result<String, CharConversionException> {
+        return try {
+            Ok(String(bytes.map { it.toByte() }.toByteArray(), charset))
+        } catch (ce: CharConversionException) {
+            Err(ce)
+        }
+    }
+}

codeCore/src/prog8/code/target/pet/PETMachineDefinition.kt

@@ -36,13 +36,6 @@ class PETMachineDefinition: IMachineDefinition {
         return m5.toDouble()
     }
 
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return if (compilerOptions.launcher == CbmPrgLauncherType.BASIC || compilerOptions.output == OutputType.PRG)
-            listOf("syslib")
-        else
-            emptyList()
-    }
-
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
         if(selectedEmulator!=1) {
             System.err.println("The pet target only supports the main emulator (Vice).")

codeCore/src/prog8/code/target/virtual/VirtualMachineDefinition.kt

@@ -50,10 +50,6 @@ class VirtualMachineDefinition: IMachineDefinition {
         return Double.fromBits(b0 or b1 or b2 or b3 or b4 or b5 or b6 or b7)
     }
 
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return listOf("syslib")
-    }
-
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
         println("\nStarting Virtual Machine...")
         // to not have external module dependencies in our own module, we launch the virtual machine via reflection

codeGenCpu6502/build.gradle

@@ -5,9 +5,8 @@ plugins {
 }
 
 java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(javaVersion)
-    }
+    targetCompatibility = JavaLanguageVersion.of(javaVersion)
+    sourceCompatibility = JavaLanguageVersion.of(javaVersion)
 }
 
 compileKotlin {
@@ -26,9 +25,9 @@ dependencies {
     implementation project(':codeCore')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.20"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.0"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.9.1'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }

codeGenCpu6502/src/prog8/codegen/cpu6502/AsmGen.kt

@@ -100,8 +100,7 @@ class AsmGen6502(val prefixSymbols: Boolean): ICodeGeneratorBackend {
         }
 
         nodesToPrefix.forEach { (parent, index) ->
-            val node = parent.children[index]
-            when(node) {
+            when(val node = parent.children[index]) {
                 is PtIdentifier -> parent.children[index] = node.prefix(parent, st)
                 is PtFunctionCall ->  throw AssemblyError("PtFunctionCall should be processed in their own list, last")
                 is PtJump -> parent.children[index] = node.prefix(parent, st)
@@ -247,7 +246,7 @@ class AsmGen6502Internal (
 
         if(errors.noErrors()) {
             val output = options.outputDir.resolve("${program.name}.asm")
-            val asmLines = assembly.asSequence().flatMapTo(mutableListOf()) { it.split('\n') }
+            val asmLines = assembly.flatMapTo(mutableListOf()) { it.split('\n') }
             if(options.compTarget.name==Cx16Target.NAME) {
                 scanInvalid65816instructions(asmLines)
                 if(!errors.noErrors()) {
@@ -820,17 +819,15 @@ class AsmGen6502Internal (
         loopEndLabels.pop()
     }
 
-    private fun repeatWordCount(count: Int, stmt: PtRepeatLoop) {
-        require(count in 257..65535) { "invalid repeat count ${stmt.position}" }
+    private fun repeatWordCount(iterations: Int, stmt: PtRepeatLoop) {
+        require(iterations in 257..65535) { "invalid repeat count ${stmt.position}" }
         val repeatLabel = makeLabel("repeat")
         val counterVar = createRepeatCounterVar(DataType.UWORD, isTargetCpu(CpuType.CPU65c02), stmt)
-        // the iny + double dec is microoptimization of the 16 bit loop
+        val loopcount = if(iterations and 0x00ff == 0) iterations else iterations + 0x0100   // so that the loop can simply use a double-dec
         out("""
-            ldy  #>$count
-            lda  #<$count
-            beq  +
-            iny
-+           sta  $counterVar
+            ldy  #>$loopcount
+            lda  #<$loopcount
+            sta  $counterVar
             sty  $counterVar+1
 $repeatLabel""")
         translate(stmt.statements)
@@ -883,8 +880,8 @@ $repeatLabel""")
     }
 
     private fun repeatCountInY(stmt: PtRepeatLoop, endLabel: String) {
-        // note: Y must just have been loaded with the (variable) number of loops to be performed!
         val repeatLabel = makeLabel("repeat")
+        out("  cpy  #0")
         if(isTargetCpu(CpuType.CPU65c02)) {
             val counterVar = createRepeatCounterVar(DataType.UBYTE, true, stmt)
             out("  beq  $endLabel |  sty  $counterVar")
@@ -1320,91 +1317,6 @@ $repeatLabel""")
         }
     }
 
-    internal fun popCpuStack(asmsub: PtAsmSub, parameter: PtSubroutineParameter, reg: RegisterOrStatusflag) {
-        val shouldKeepA = asmsub.parameters.any { it.first.registerOrPair==RegisterOrPair.AX || it.first.registerOrPair==RegisterOrPair.AY}
-        if(reg.statusflag!=null) {
-            if(shouldKeepA)
-                out("  sta  P8ZP_SCRATCH_REG")
-            out("""
-                    clc
-                    pla
-                    beq  +
-                    sec
-+""")
-            if(shouldKeepA)
-                out("  lda  P8ZP_SCRATCH_REG")
-        }
-        else {
-            if (parameter.type in ByteDatatypesWithBoolean) {
-                if (isTargetCpu(CpuType.CPU65c02)) {
-                    when (reg.registerOrPair) {
-                        RegisterOrPair.A -> out("  pla")
-                        RegisterOrPair.X -> out("  plx")
-                        RegisterOrPair.Y -> out("  ply")
-                        in Cx16VirtualRegisters -> out("  pla |  sta  cx16.${reg.registerOrPair!!.name.lowercase()}")
-                        else -> throw AssemblyError("invalid target register ${reg.registerOrPair}")
-                    }
-                } else {
-                    when (reg.registerOrPair) {
-                        RegisterOrPair.A -> out("  pla")
-                        RegisterOrPair.X -> {
-                            if(shouldKeepA)
-                                out("  sta  P8ZP_SCRATCH_REG |  pla |  tax |  lda  P8ZP_SCRATCH_REG")
-                            else
-                                out("  pla |  tax")
-                        }
-                        RegisterOrPair.Y -> {
-                            if(shouldKeepA)
-                                out("  sta  P8ZP_SCRATCH_REG |  pla |  tay |  lda  P8ZP_SCRATCH_REG")
-                            else
-                                out("  pla |  tay")
-                        }
-                        in Cx16VirtualRegisters -> out("  pla |  sta  cx16.${reg.registerOrPair!!.name.lowercase()}")
-                        else -> throw AssemblyError("invalid target register ${reg.registerOrPair}")
-                    }
-                }
-            } else {
-                // word pop
-                if (isTargetCpu(CpuType.CPU65c02))
-                    when (reg.registerOrPair) {
-                        RegisterOrPair.AX -> out("  plx |  pla")
-                        RegisterOrPair.AY -> out("  ply |  pla")
-                        RegisterOrPair.XY -> out("  ply |  plx")
-                        in Cx16VirtualRegisters -> {
-                            val regname = reg.registerOrPair!!.name.lowercase()
-                            out("  pla |  sta  cx16.$regname+1 |  pla |  sta  cx16.$regname")
-                        }
-                        else -> throw AssemblyError("invalid target register ${reg.registerOrPair}")
-                    }
-                else {
-                    when (reg.registerOrPair) {
-                        RegisterOrPair.AX -> out("  pla |  tax |  pla")
-                        RegisterOrPair.AY -> out("  pla |  tay |  pla")
-                        RegisterOrPair.XY -> out("  pla |  tay |  pla |  tax")
-                        in Cx16VirtualRegisters -> {
-                            val regname = reg.registerOrPair!!.name.lowercase()
-                            out("  pla |  sta  cx16.$regname+1 |  pla |  sta  cx16.$regname")
-                        }
-                        else -> throw AssemblyError("invalid target register ${reg.registerOrPair}")
-                    }
-                }
-            }
-        }
-    }
-
-    internal fun popCpuStack(dt: DataType) {
-        if (dt in ByteDatatypesWithBoolean) {
-            out("  pla")
-        } else if (dt in WordDatatypes) {
-            if (isTargetCpu(CpuType.CPU65c02))
-                out("  ply |  pla")
-            else
-                out("  pla |  tay |  pla")
-        } else {
-            throw AssemblyError("can't pop type $dt")
-        }
-    }
-
     internal fun pushCpuStack(dt: DataType, value: PtExpression) {
         val signed = value.type.oneOf(DataType.BYTE, DataType.WORD)
         if(dt in ByteDatatypesWithBoolean) {

codeGenCpu6502/src/prog8/codegen/cpu6502/AsmOptimizer.kt

@@ -50,6 +50,13 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
         numberOfOptimizations++
     }
 
+    mods = optimizeTSBtoRegularOr(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
+        linesByFour = getLinesBy(lines, 4)
+        numberOfOptimizations++
+    }
+
     var linesByFourteen = getLinesBy(lines, 14)
     mods = optimizeSameAssignments(linesByFourteen, machine, symbolTable)
     if(mods.isNotEmpty()) {
@@ -384,6 +391,7 @@ private fun optimizeStoreLoadSame(
     for (lines in linesByFour) {
         val first = lines[1].value.trimStart()
         val second = lines[2].value.trimStart()
+        val third = lines[3].value.trimStart()
 
         // sta X + lda X,  sty X + ldy X,   stx X + ldx X  -> the second instruction can OFTEN be eliminated
         if ((first.startsWith("sta ") && second.startsWith("lda ")) ||
@@ -393,7 +401,6 @@ private fun optimizeStoreLoadSame(
                 (first.startsWith("ldy ") && second.startsWith("ldy ")) ||
                 (first.startsWith("ldx ") && second.startsWith("ldx "))
         ) {
-            val third = lines[3].value.trimStart()
             val attemptRemove =
                 if(third.isBranch()) {
                     // a branch instruction follows, we can only remove the load instruction if
@@ -508,6 +515,7 @@ private fun optimizeJsrRtsAndOtherCombinations(linesByFour: Sequence<List<Indexe
     for (lines in linesByFour) {
         val first = lines[0].value
         val second = lines[1].value
+        val third = lines[2].value
         if ((" jsr" in first || "\tjsr" in first ) && (" rts" in second || "\trts" in second)) {
             mods += Modification(lines[0].index, false, lines[0].value.replace("jsr", "jmp"))
             mods += Modification(lines[1].index, true, null)
@@ -577,6 +585,58 @@ private fun optimizeJsrRtsAndOtherCombinations(linesByFour: Sequence<List<Indexe
                 mods += Modification(lines[3].index, true, null)
             }
         }
+
+
+        fun sameLabel(branchInstr: String, jumpInstr: String, labelInstr: String): Boolean {
+            if('(' in jumpInstr) return false       // indirect jump cannot be replaced
+            val label = labelInstr.trimEnd().substringBefore(':').substringBefore(' ').substringBefore('\t')
+            val branchLabel = branchInstr.trimStart().substring(3).trim()
+            return label==branchLabel
+        }
+
+        // beq Label + jmp Addr + Label  -> bne Addr
+        if((" jmp" in second || "\tjmp " in second) && haslabel(third)) {
+            if((" beq " in first || "\tbeq " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bne")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bne " in first || "\tbne " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "beq")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bcc " in first || "\tbcc " in first) && sameLabel(first, second, third)){
+                val branch = second.replace("jmp", "bcs")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bcs " in first || "\tbcs " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bcc")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bpl " in first || "\tbpl " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bmi")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bmi " in first || "\tbmi " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bpl")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bvc " in first || "\tbvc " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bvs")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bvs " in first || "\tbvs " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bvc")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+        }
     }
     return mods
 }
@@ -614,6 +674,52 @@ private fun optimizeUselessPushPopStack(linesByFour: Sequence<List<IndexedValue<
         optimize('a', lines)
         optimize('x', lines)
         optimize('y', lines)
+
+        val first = lines[1].value.trimStart()
+        val second = lines[2].value.trimStart()
+        val third = lines[3].value.trimStart()
+
+        // phy + ldy + pla -> tya + ldy
+        // phx + ldx + pla -> txa + ldx
+        // pha + lda + pla -> nop
+        if(first=="phy" && second.startsWith("ldy ") && third=="pla") {
+            mods.add(Modification(lines[3].index, true, null))
+            mods.add(Modification(lines[1].index, false, "  tya"))
+        }
+        else if(first=="phx" && second.startsWith("ldx ") && third=="pla") {
+            mods.add(Modification(lines[3].index, true, null))
+            mods.add(Modification(lines[1].index, false, "  txa"))
+        }
+        else if(first=="pha" && second.startsWith("lda ") && third=="pla") {
+            mods.add(Modification(lines[1].index, true, null))
+            mods.add(Modification(lines[2].index, true, null))
+            mods.add(Modification(lines[3].index, true, null))
+        }
+    }
+
+
+    return mods
+}
+
+
+private fun optimizeTSBtoRegularOr(linesByFour: Sequence<List<IndexedValue<String>>>): List<Modification> {
+    // Asm peephole:   lda var2 / tsb var1 / lda var1  Replace this with this to save 1 cycle:   lda var1 / ora var2 / sta var1
+    val mods = mutableListOf<Modification>()
+
+    for(lines in linesByFour) {
+        val first = lines[0].value.trimStart()
+        val second = lines[1].value.trimStart()
+        val third = lines[2].value.trimStart()
+        if(first.startsWith("lda") && second.startsWith("tsb") && third.startsWith("lda")) {
+            val operand1 = first.substring(3)
+            val operand2 = second.substring(3)
+            val operand3 = third.substring(3)
+            if(operand1!=operand2 && operand2==operand3) {
+                mods.add(Modification(lines[0].index, false, "  lda  $operand2"))
+                mods.add(Modification(lines[1].index, false, "  ora  $operand1"))
+                mods.add(Modification(lines[2].index, false, "  sta  $operand2"))
+            }
+        }
     }
     return mods
 }

codeGenCpu6502/src/prog8/codegen/cpu6502/AssemblyProgram.kt

@@ -28,7 +28,7 @@ internal class AssemblyProgram(
                 // add "-Wlong-branch"  to see warnings about conversion of branch instructions to jumps (default = do this silently)
                 val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
                     "-Wall", // "-Wno-strict-bool", "-Werror",
-                    "--dump-labels", "--vice-labels", "--labels=$viceMonListFile", "--no-monitor"
+                    "--dump-labels", "--vice-labels", "--labels=$viceMonListFile"
                 )
 
                 if(options.warnSymbolShadowing)
@@ -39,8 +39,9 @@ internal class AssemblyProgram(
                 if(options.asmQuiet)
                     command.add("--quiet")
 
-                if(options.asmListfile)
-                    command.add("--list=$listFile")
+                if(options.asmListfile) {
+                    command.addAll(listOf("--list=$listFile", "--no-monitor"))
+                }
 
                 val outFile = when (options.output) {
                     OutputType.PRG -> {

codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt

@@ -33,7 +33,6 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "min__byte", "min__ubyte", "min__word", "min__uword" -> funcMin(fcall, resultRegister)
             "max__byte", "max__ubyte", "max__word", "max__uword" -> funcMax(fcall, resultRegister)
             "abs__byte", "abs__word", "abs__float" -> funcAbs(fcall, resultRegister, sscope)
-            "any", "all" -> funcAnyAll(fcall, resultRegister, sscope)
             "sgn" -> funcSgn(fcall, resultRegister, sscope)
             "sqrt__ubyte", "sqrt__uword", "sqrt__float" -> funcSqrt(fcall, resultRegister, sscope)
             "divmod__ubyte" -> funcDivmod(fcall)
@@ -44,8 +43,6 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "ror2" -> funcRor2(fcall)
             "setlsb" -> funcSetLsbMsb(fcall, false)
             "setmsb" -> funcSetLsbMsb(fcall, true)
-            "sort" -> funcSort(fcall)
-            "reverse" -> funcReverse(fcall)
             "memory" -> funcMemory(fcall, discardResult, resultRegister)
             "peekw" -> funcPeekW(fcall, resultRegister)
             "peekf" -> funcPeekF(fcall, resultRegister)
@@ -68,6 +65,8 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "cmp" -> funcCmp(fcall)
             "callfar" -> funcCallFar(fcall, resultRegister)
             "call" -> funcCall(fcall)
+            "prog8_ifelse_bittest_set" -> throw AssemblyError("prog8_ifelse_bittest_set() should have been translated as part of an ifElse statement")
+            "prog8_ifelse_bittest_notset" -> throw AssemblyError("prog8_ifelse_bittest_notset() should have been translated as part of an ifElse statement")
             "prog8_lib_stringcompare" -> funcStringCompare(fcall, resultRegister)
             "prog8_lib_square_byte" -> funcSquare(fcall, DataType.UBYTE, resultRegister)
             "prog8_lib_square_word" -> funcSquare(fcall, DataType.UWORD, resultRegister)
@@ -82,8 +81,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         val source = fcall.args[0] as PtIdentifier
         val target = fcall.args[1] as PtIdentifier
 
-        val sourceSymbol = asmgen.symbolTable.lookup(source.name)
-        val numElements = when(sourceSymbol) {
+        val numElements = when(val sourceSymbol = asmgen.symbolTable.lookup(source.name)) {
             is StStaticVariable -> sourceSymbol.length!!
             is StMemVar -> sourceSymbol.length!!
             else -> 0
@@ -404,115 +402,6 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         }
     }
 
-    private fun funcReverse(fcall: PtBuiltinFunctionCall) {
-        val variable = fcall.args.single() as PtIdentifier
-        val symbol = asmgen.symbolTable.lookup(variable.name)
-        val (dt, numElements) = when(symbol) {
-            is StStaticVariable  -> symbol.dt to symbol.length!!
-            is StMemVar -> symbol.dt to symbol.length!!
-            else -> DataType.UNDEFINED to 0
-        }
-        val varName = asmgen.asmVariableName(variable)
-        when (dt) {
-            DataType.ARRAY_UB, DataType.ARRAY_B -> {
-                asmgen.out("""
-                    lda  #<$varName
-                    ldy  #>$varName
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #$numElements
-                    jsr  prog8_lib.func_reverse_b""")
-            }
-            DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                asmgen.out("""
-                    lda  #<$varName
-                    ldy  #>$varName
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #$numElements
-                    jsr  prog8_lib.func_reverse_w""")
-            }
-            DataType.STR -> {
-                asmgen.out("""
-                    lda  #<$varName
-                    ldy  #>$varName
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #${numElements-1}
-                    jsr  prog8_lib.func_reverse_b""")
-            }
-            DataType.ARRAY_F -> {
-                asmgen.out("""
-                    lda  #<$varName
-                    ldy  #>$varName
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #$numElements
-                    jsr  floats.func_reverse_f""")
-            }
-            in SplitWordArrayTypes -> {
-                // reverse the lsb and msb arrays both, independently
-                asmgen.out("""
-                    lda  #<${varName}_lsb
-                    ldy  #>${varName}_lsb
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #$numElements
-                    jsr  prog8_lib.func_reverse_b
-                    lda  #<${varName}_msb
-                    ldy  #>${varName}_msb
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #$numElements
-                    jsr  prog8_lib.func_reverse_b""")
-            }
-            else -> throw AssemblyError("weird type")
-        }
-    }
-
-    private fun funcSort(fcall: PtBuiltinFunctionCall) {
-        val variable = fcall.args.single() as PtIdentifier
-        val symbol = asmgen.symbolTable.lookup(variable.name)
-        val varName = asmgen.asmVariableName(variable)
-        val (dt, numElements) = when(symbol) {
-            is StStaticVariable  -> symbol.dt to symbol.length!!
-            is StMemVar -> symbol.dt to symbol.length!!
-            else -> DataType.UNDEFINED to 0
-        }
-        when (dt) {
-            DataType.ARRAY_UB, DataType.ARRAY_B -> {
-                asmgen.out("""
-                    lda  #<$varName
-                    ldy  #>$varName
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #$numElements""")
-                asmgen.out(if (dt == DataType.ARRAY_UB) "  jsr  prog8_lib.func_sort_ub" else "  jsr  prog8_lib.func_sort_b")
-            }
-            DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                asmgen.out("""
-                    lda  #<$varName
-                    ldy  #>$varName
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #$numElements""")
-                asmgen.out(if (dt == DataType.ARRAY_UW) "  jsr  prog8_lib.func_sort_uw" else "  jsr  prog8_lib.func_sort_w")
-            }
-            DataType.STR -> {
-                asmgen.out("""
-                    lda  #<$varName
-                    ldy  #>$varName
-                    sta  P8ZP_SCRATCH_W1
-                    sty  P8ZP_SCRATCH_W1+1
-                    lda  #${numElements-1}
-                    jsr  prog8_lib.func_sort_ub""")
-            }
-            DataType.ARRAY_F -> throw AssemblyError("sorting of floating point array is not supported")
-            in SplitWordArrayTypes -> TODO("split words sort")
-            else -> throw AssemblyError("weird type")
-        }
-    }
-
     private fun funcRor2(fcall: PtBuiltinFunctionCall) {
         val what = fcall.args.single()
         when (what.type) {
@@ -827,8 +716,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
 
     private fun funcSgn(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
         translateArguments(fcall, scope)
-        val dt = fcall.args.single().type
-        when (dt) {
+        when (val dt = fcall.args.single().type) {
             DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.func_sign_ub_into_A")
             DataType.BYTE -> asmgen.out("  jsr  prog8_lib.func_sign_b_into_A")
             DataType.UWORD -> asmgen.out("  jsr  prog8_lib.func_sign_uw_into_A")
@@ -839,63 +727,6 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, true, true)
     }
 
-    private fun funcAnyAll(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
-        val dt = fcall.args.single().type
-        val array = fcall.args[0] as PtIdentifier
-        when (dt) {
-            DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> {
-                outputAddressAndLengthOfArray(array)
-                asmgen.out("  jsr  prog8_lib.func_${fcall.name}_b_into_A")
-            }
-            DataType.ARRAY_UW, DataType.ARRAY_W -> {
-                outputAddressAndLengthOfArray(array)
-                asmgen.out("  jsr  prog8_lib.func_${fcall.name}_w_into_A")
-            }
-            DataType.ARRAY_F -> {
-                outputAddressAndLengthOfArray(array)
-                asmgen.out("  jsr  floats.func_${fcall.name}_f_into_A")
-            }
-            in SplitWordArrayTypes -> {
-                val numElements = (asmgen.symbolTable.lookup(array.name) as StStaticVariable).length
-                when(fcall.name) {
-                    "any" -> {
-                        // any(lsb-array) or any(msb-array)
-                        val arrayName = asmgen.asmVariableName(array)
-                        asmgen.out("""
-                            lda  #<${arrayName}_lsb
-                            ldy  #>${arrayName}_lsb
-                            sta  P8ZP_SCRATCH_W1
-                            sty  P8ZP_SCRATCH_W1+1
-                            lda  #$numElements
-                        """)
-                        asmgen.out("  jsr  prog8_lib.func_${fcall.name}_b_into_A")
-                        asmgen.out("  bne  +")      // shortcircuit
-                        asmgen.out("""
-                            pha
-                            lda  #<${arrayName}_msb
-                            ldy  #>${arrayName}_msb
-                            sta  P8ZP_SCRATCH_W1
-                            sty  P8ZP_SCRATCH_W1+1
-                            lda  #$numElements
-                        """)
-                        asmgen.out("  jsr  prog8_lib.func_${fcall.name}_b_into_A")
-                        asmgen.out("""
-                            sta  P8ZP_SCRATCH_REG
-                            pla
-                            ora  P8ZP_SCRATCH_REG
-+""")
-                    }
-                    "all" -> {
-                        TODO("split words all")
-                    }
-                    else -> throw AssemblyError("weird call")
-                }
-            }
-            else -> throw AssemblyError("weird type $dt")
-        }
-        assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, dt in SignedDatatypes, true)
-    }
-
     private fun funcAbs(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
         translateArguments(fcall, scope)
         val dt = fcall.args.single().type
@@ -1398,8 +1229,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
 
     private fun outputAddressAndLengthOfArray(arg: PtIdentifier) {
         // address goes in P8ZP_SCRATCH_W1,  number of elements in A
-        val symbol = asmgen.symbolTable.lookup(arg.name)
-        val numElements = when(symbol) {
+        val numElements = when(val symbol = asmgen.symbolTable.lookup(arg.name)) {
             is StStaticVariable -> symbol.length!!
             is StMemVar -> symbol.length!!
             else -> 0

codeGenCpu6502/src/prog8/codegen/cpu6502/ForLoopsAsmGen.kt

@@ -335,8 +335,7 @@ $endLabel""")
         val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.push(endLabel)
         val iterableName = asmgen.asmVariableName(ident)
-        val symbol = asmgen.symbolTable.lookup(ident.name)
-        val numElements = when(symbol) {
+        val numElements = when(val symbol = asmgen.symbolTable.lookup(ident.name)) {
             is StStaticVariable -> symbol.length!!
             is StMemVar -> symbol.length!!
             else -> 0

codeGenCpu6502/src/prog8/codegen/cpu6502/FunctionCallAsmGen.kt

@@ -82,7 +82,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
             is PtAddressOf -> false
             is PtIdentifier -> false
             is PtIrRegister -> false
-            is PtMemoryByte -> return usesOtherRegistersWhileEvaluating(arg.address)
+            is PtMemoryByte -> true     // TODO might not actually need extra registers if the value has to end up in A
             is PtNumber -> false
             is PtBool -> false
             else -> true
@@ -90,7 +90,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
     }
 
     private fun argumentsViaRegisters(sub: PtAsmSub, call: PtFunctionCall) {
-        val registersUsed = mutableListOf<RegisterOrStatusflag>();
+        val registersUsed = mutableListOf<RegisterOrStatusflag>()
 
         fun usedA() = registersUsed.any {it.registerOrPair==RegisterOrPair.A || it.registerOrPair==RegisterOrPair.AX || it.registerOrPair==RegisterOrPair.AY}
         fun usedX() = registersUsed.any {it.registerOrPair==RegisterOrPair.X || it.registerOrPair==RegisterOrPair.AX || it.registerOrPair==RegisterOrPair.XY}
@@ -110,9 +110,9 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                         throw AssemblyError("call argument evaluation problem: can't save cpu statusregister parameter ${call.position}")
                     }
                     else {
-                        if(usedX()) asmgen.saveRegisterStack(CpuRegister.X, false)
-                        if(usedY()) asmgen.saveRegisterStack(CpuRegister.Y, false)
-                        if(usedA()) asmgen.saveRegisterStack(CpuRegister.A, false)
+                        if(usedX()) asmgen.saveRegisterStack(CpuRegister.X, usedA())
+                        if(usedY()) asmgen.saveRegisterStack(CpuRegister.Y, usedA())
+                        if(usedA()) asmgen.saveRegisterStack(CpuRegister.A, usedA())
                         val used = argumentViaRegister(sub, IndexedValue(it, param.second), arg)
                         if(usedA()) asmgen.restoreRegisterStack(CpuRegister.A, false)
                         if(usedY()) asmgen.restoreRegisterStack(CpuRegister.Y, true)

codeGenCpu6502/src/prog8/codegen/cpu6502/IfElseAsmGen.kt

@@ -83,9 +83,80 @@ internal class IfElseAsmGen(private val program: PtProgram,
     }
 
     private fun fallbackTranslateForSimpleCondition(ifElse: PtIfElse) {
+        val bittest = ifElse.condition as? PtBuiltinFunctionCall
+        val jumpAfterIf = ifElse.ifScope.children.singleOrNull() as? PtJump
+
+        if(bittest!=null && bittest.name.startsWith("prog8_ifelse_bittest_")) {
+            val variable = bittest.args[0] as PtIdentifier
+            val bitnumber = (bittest.args[1] as PtNumber).number.toInt()
+            val testForBitSet = bittest.name.endsWith("_set")
+            when (bitnumber) {
+                7 -> {
+                    // test via bit + N flag
+                    asmgen.out("  bit  ${variable.name}")
+                    if(testForBitSet) {
+                        if(jumpAfterIf!=null) {
+                            val (asmLabel, indirect) = asmgen.getJumpTarget(jumpAfterIf)
+                            if(indirect)
+                                throw AssemblyError("cannot BIT to indirect label ${ifElse.position}")
+                            if(ifElse.hasElse())
+                                throw AssemblyError("didn't expect else part here ${ifElse.position}")
+                            else
+                                asmgen.out("  bmi  $asmLabel")
+                        }
+                        else
+                            translateIfElseBodies("bpl", ifElse)
+                    } else {
+                        if(jumpAfterIf!=null) {
+                            val (asmLabel, indirect) = asmgen.getJumpTarget(jumpAfterIf)
+                            if(indirect)
+                                throw AssemblyError("cannot BIT to indirect label ${ifElse.position}")
+                            if(ifElse.hasElse())
+                                throw AssemblyError("didn't expect else part here ${ifElse.position}")
+                            else
+                                asmgen.out("  bpl  $asmLabel")
+                        }
+                        else
+                            translateIfElseBodies("bmi", ifElse)
+                    }
+                    return
+                }
+                6 -> {
+                    // test via bit + V flag
+                    asmgen.out("  bit  ${variable.name}")
+                    if(testForBitSet) {
+                        if(jumpAfterIf!=null) {
+                            val (asmLabel, indirect) = asmgen.getJumpTarget(jumpAfterIf)
+                            if(indirect)
+                                throw AssemblyError("cannot BIT to indirect label ${ifElse.position}")
+                            if(ifElse.hasElse())
+                                throw AssemblyError("didn't expect else part here ${ifElse.position}")
+                            else
+                                asmgen.out("  bvs  $asmLabel")
+                        }
+                        else
+                            translateIfElseBodies("bvc", ifElse)
+                    } else {
+                        if(jumpAfterIf!=null) {
+                            val (asmLabel, indirect) = asmgen.getJumpTarget(jumpAfterIf)
+                            if(indirect)
+                                throw AssemblyError("cannot BIT to indirect label ${ifElse.position}")
+                            if(ifElse.hasElse())
+                                throw AssemblyError("didn't expect else part here ${ifElse.position}")
+                            else
+                                asmgen.out("  bvc  $asmLabel")
+                        }
+                        else
+                            translateIfElseBodies("bvs", ifElse)
+                    }
+                    return
+                }
+                else -> throw AssemblyError("prog8_ifelse_bittest can only work on bits 7 and 6")
+            }
+        }
+
         // the condition is "simple" enough to just assign its 0/1 value to a register and branch on that
         assignConditionValueToRegisterAndTest(ifElse.condition)
-        val jumpAfterIf = ifElse.ifScope.children.singleOrNull() as? PtJump
         if(jumpAfterIf!=null)
             translateJumpElseBodies("bne", "beq", jumpAfterIf, ifElse.elseScope)
         else
@@ -405,14 +476,14 @@ internal class IfElseAsmGen(private val program: PtProgram,
         val condition = stmt.condition as PtBinaryExpression
         if(signed) {
             // X>Y --> Y<X
-            asmgen.assignExpressionToRegister(condition.right, RegisterOrPair.A, signed)
+            asmgen.assignExpressionToRegister(condition.right, RegisterOrPair.A, true)
             cmpAwithByteValue(condition.left, true)
             if (jumpAfterIf != null)
                 translateJumpElseBodies("bmi", "bpl", jumpAfterIf, stmt.elseScope)
             else
                 translateIfElseBodies("bpl", stmt)
         } else {
-            asmgen.assignExpressionToRegister(condition.left, RegisterOrPair.A, signed)
+            asmgen.assignExpressionToRegister(condition.left, RegisterOrPair.A, false)
             cmpAwithByteValue(condition.right, false)
             if(jumpAfterIf!=null) {
                 val (asmLabel, indirect) = asmgen.getJumpTarget(jumpAfterIf)
@@ -616,7 +687,7 @@ _jump                       jmp  ($asmLabel)
         if(right is PtIdentifier) {
             asmgen.assignExpressionToRegister(left, RegisterOrPair.AY, signed)
             val variable = asmgen.asmVariableName(right)
-            return code(variable, variable+"+1")
+            return code(variable, "$variable+1")
         }
 
         // TODO optimize for simple array value
@@ -737,7 +808,7 @@ _jump                       jmp  ($asmLabel)
         if(right is PtIdentifier) {
             asmgen.assignExpressionToRegister(left, RegisterOrPair.AY, signed)
             val variable = asmgen.asmVariableName(right)
-            return code(variable, variable+"+1")
+            return code(variable, "$variable+1")
         }
 
         // TODO optimize for simple array value
@@ -848,10 +919,10 @@ _jump                       jmp  ($asmLabel)
                     }
                 } else {
                     asmgen.loadScaledArrayIndexIntoRegister(value, CpuRegister.Y)
-                    if(value.splitWords) {
-                        return compareLsbMsb("${varname}_lsb,y", "${varname}_msb,y")
+                    return if(value.splitWords) {
+                        compareLsbMsb("${varname}_lsb,y", "${varname}_msb,y")
                     } else {
-                        return compareLsbMsb("$varname,y", "$varname+1,y")
+                        compareLsbMsb("$varname,y", "$varname+1,y")
                     }
                 }
             }
@@ -985,10 +1056,10 @@ _jump                       jmp  ($asmLabel)
                     }
                 } else {
                     asmgen.loadScaledArrayIndexIntoRegister(value, CpuRegister.Y)
-                    if(value.splitWords) {
-                        return compareLsbMsb("${varname}_lsb,y", "${varname}_msb,y")
+                    return if(value.splitWords) {
+                        compareLsbMsb("${varname}_lsb,y", "${varname}_msb,y")
                     } else {
-                        return compareLsbMsb("$varname,y", "$varname+1,y")
+                        compareLsbMsb("$varname,y", "$varname+1,y")
                     }
                 }
             }
@@ -1514,7 +1585,7 @@ _jump                       jmp  ($asmLabel)
                         else -> {
                             asmgen.assignExpressionToRegister(right, RegisterOrPair.AY, signed)
                             val varname = asmgen.asmVariableName(left)
-                            translateAYNotEquals(varname, varname + "+1")
+                            translateAYNotEquals(varname, "$varname+1")
                         }
                     }
                 }
@@ -1562,7 +1633,7 @@ _jump                       jmp  ($asmLabel)
                         else -> {
                             asmgen.assignExpressionToRegister(right, RegisterOrPair.AY, signed)
                             val varname = asmgen.asmVariableName(left)
-                            translateAYEquals(varname, varname+"+1")
+                            translateAYEquals(varname, "$varname+1")
                         }
                     }
                 }

codeGenCpu6502/src/prog8/codegen/cpu6502/VariableAllocator.kt

@@ -48,9 +48,9 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
         val numberOfAllocatableVariables = allVariables.size
         val varsRequiringZp = allVariables.filter { it.zpwish == ZeropageWish.REQUIRE_ZEROPAGE }
         val varsPreferringZp = allVariables.filter { it.zpwish == ZeropageWish.PREFER_ZEROPAGE }
+        val varsNotZp = allVariables.filter { it.zpwish == ZeropageWish.NOT_IN_ZEROPAGE }
         val varsDontCare = allVariables.filter { it.zpwish == ZeropageWish.DONTCARE }
-        val numberOfExplicitNonZpVariables = allVariables.count { it.zpwish == ZeropageWish.NOT_IN_ZEROPAGE }
-        require(varsDontCare.size + varsRequiringZp.size + varsPreferringZp.size + numberOfExplicitNonZpVariables == numberOfAllocatableVariables)
+        require(varsDontCare.size + varsRequiringZp.size + varsPreferringZp.size + varsNotZp.size == numberOfAllocatableVariables)
 
         var numVariablesAllocatedInZP = 0
         var numberOfNonIntegerVariables = 0
@@ -86,7 +86,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
                 //  no need to check for allocation error, if there is one, just allocate in normal system ram.
             }
 
-            // try to allocate any other interger variables into the zeropage until it is full.
+            // try to allocate the "don't care" interger variables into the zeropage until it is full.
             // TODO some form of intelligent priorization? most often used variables first? loopcounter vars first? ...?
             if(errors.noErrors()) {
                 val sortedList = varsDontCare.sortedByDescending { it.scopedName }
@@ -110,9 +110,7 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
             }
         }
 
-//        println("  number of allocated vars: $numberOfAllocatableVariables")
-//        println("  put into zeropage: $numVariablesAllocatedInZP,  non-zp allocatable: ${numberOfNonIntegerVariables+numberOfExplicitNonZpVariables}")
-//        println("  zeropage free space: ${zeropage.free.size} bytes")
+        // note: no zeropage allocation is done at all for the @nozp variables. This means they will always end up outside the zeropage.
     }
 
     private fun collectAllVariables(st: SymbolTable): Collection<StStaticVariable> {

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt

@@ -284,12 +284,6 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                 }
             }
             SourceStorageKind.MEMORY -> {
-                fun assignViaExprEval(expression: PtExpression) {
-                    assignExpressionToVariable(expression, "P8ZP_SCRATCH_W2", DataType.UWORD)
-                    asmgen.loadAFromZpPointerVar("P8ZP_SCRATCH_W2", false)
-                    assignRegisterByte(assign.target, CpuRegister.A, false, true)
-                }
-
                 val value = assign.source.memory!!
                 when (value.address) {
                     is PtNumber -> {
@@ -304,10 +298,10 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         if(asmgen.tryOptimizedPointerAccessWithA(addrExpr, false)) {
                             assignRegisterByte(assign.target, CpuRegister.A, false, true)
                         } else {
-                            assignViaExprEval(value.address)
+                            assignByteFromAddressExpression(value.address, assign.target)
                         }
                     }
-                    else -> assignViaExprEval(value.address)
+                    else -> assignByteFromAddressExpression(value.address, assign.target)
                 }
             }
             SourceStorageKind.EXPRESSION -> {
@@ -319,6 +313,106 @@ internal class AssignmentAsmGen(private val program: PtProgram,
         }
     }
 
+    private fun assignByteFromAddressExpression(address: PtExpression, target: AsmAssignTarget) {
+        if(address is PtBinaryExpression) {
+            if(address.operator=="+" && address.right.type==DataType.UWORD) {
+                if (address.left is PtIdentifier) {
+                    // use (zp),Y instead of explicitly calculating the full zp pointer value
+                    val pointer = (address.left as PtIdentifier).name
+                    when(val index=address.right) {
+                        is PtIdentifier -> {
+                            val indexName = index.name
+                            asmgen.out("""
+                                lda  $pointer
+                                sta  P8ZP_SCRATCH_W2
+                                lda  $pointer+1
+                                clc
+                                adc  $indexName+1
+                                sta  P8ZP_SCRATCH_W2+1
+                                ldy  $indexName
+                                lda  (P8ZP_SCRATCH_W2),y""")
+                            assignRegisterByte(target, CpuRegister.A, false, true)
+                            return
+                        }
+                        is PtNumber -> {
+                            val indexValue = index.number.toString()
+                            asmgen.out("""
+                                lda  $pointer
+                                sta  P8ZP_SCRATCH_W2
+                                lda  $pointer+1
+                                clc
+                                adc  #>$indexValue
+                                sta  P8ZP_SCRATCH_W2+1
+                                ldy  #<$indexValue
+                                lda  (P8ZP_SCRATCH_W2),y""")
+                            assignRegisterByte(target, CpuRegister.A, false, true)
+                            return
+                        }
+                        else -> {}
+                    }
+                }
+            }
+//          else if(address.operator=="-") {
+//              // does this ever occur? we could optimize it too, but it seems like a pathological case
+//          }
+        }
+        assignExpressionToVariable(address, "P8ZP_SCRATCH_W2", DataType.UWORD)
+        asmgen.loadAFromZpPointerVar("P8ZP_SCRATCH_W2", false)
+        assignRegisterByte(target, CpuRegister.A, false, true)
+    }
+
+    private fun storeByteInAToAddressExpression(address: PtExpression, saveA: Boolean) {
+        if(address is PtBinaryExpression) {
+            if(address.operator=="+") {
+                if (address.left is PtIdentifier && address.right.type==DataType.UWORD) {
+                    // use (zp),Y instead of explicitly calculating the full zp pointer value
+                    val pointer = (address.left as PtIdentifier).name
+                    when(val index=address.right) {
+                        is PtIdentifier -> {
+                            val indexName = index.name
+                            asmgen.out("""
+                                tax
+                                lda  $pointer
+                                sta  P8ZP_SCRATCH_W2
+                                lda  $pointer+1
+                                clc
+                                adc  $indexName+1
+                                sta  P8ZP_SCRATCH_W2+1
+                                ldy  $indexName
+                                txa
+                                sta  (P8ZP_SCRATCH_W2),y""")
+                            return
+                        }
+                        is PtNumber -> {
+                            val indexValue = index.number.toString()
+                            asmgen.out("""
+                                tax
+                                lda  $pointer
+                                sta  P8ZP_SCRATCH_W2
+                                lda  $pointer+1
+                                clc
+                                adc  #>$indexValue
+                                sta  P8ZP_SCRATCH_W2+1
+                                ldy  #<$indexValue
+                                txa
+                                sta  (P8ZP_SCRATCH_W2),y""")
+                            return
+                        }
+                        else -> {}
+                    }
+                }
+            }
+//          else if(address.operator=="-") {
+//              // does this ever occur? we could optimize it too, but it seems like a pathological case
+//          }
+        }
+        if(saveA) asmgen.out("  pha")
+        assignExpressionToVariable(address, "P8ZP_SCRATCH_W2", DataType.UWORD)
+        if(saveA) asmgen.out("  pla")
+        asmgen.storeAIntoZpPointerVar("P8ZP_SCRATCH_W2", false)
+    }
+
+
     private fun assignExpression(assign: AsmAssignment, scope: IPtSubroutine?) {
         when(val value = assign.source.expression!!) {
             is PtAddressOf -> {
@@ -703,8 +797,8 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                 RegisterOrPair.Y -> "y"
                 else -> TODO("comparison to word register")
             }
-            val assignTrue = PtInlineAssembly("  ld${reg}  #1", false, assign.target.position)
-            val assignFalse = PtInlineAssembly("  ld${reg}  #0", false, assign.target.position)
+            val assignTrue = PtInlineAssembly("\tld${reg}  #1", false, assign.target.position)
+            val assignFalse = PtInlineAssembly("\tld${reg}  #0", false, assign.target.position)
             ifPart.add(assignTrue)
             elsePart.add(assignFalse)
             val ifelse = PtIfElse(assign.position)
@@ -754,7 +848,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
   sta  ${assign.target.asmVarname}+1""", false, assign.target.position)
                         }
                     } else {
-                        assignTrue = PtInlineAssembly("  lda  #1\n  sta  ${assign.target.asmVarname}", false, assign.target.position)
+                        assignTrue = PtInlineAssembly("\tlda  #1\n  sta  ${assign.target.asmVarname}", false, assign.target.position)
                     }
                 }
                 TargetStorageKind.MEMORY -> {
@@ -839,6 +933,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
     }
 
     private fun optimizedDivideExpr(expr: PtBinaryExpression, target: AsmAssignTarget): Boolean {
+        // replacing division by shifting is done in an optimizer step.
         when(expr.type) {
             DataType.UBYTE -> {
                 assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
@@ -1010,7 +1105,10 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                             }
                         } else {
                             if (signed && shifts > 0) {
-                                asmgen.out("  ldy  #$shifts |  jsr  math.lsr_byte_A")
+                                if(shifts==1)
+                                    asmgen.out("  cmp  #$80 |  ror  a")
+                                else
+                                    asmgen.out("  ldy  #$shifts |  jsr  math.lsr_byte_A")
                             } else {
                                 repeat(shifts) {
                                     asmgen.out("  lsr  a")
@@ -1044,7 +1142,18 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                             }
                         } else {
                             if(signed && shifts>0) {
-                                asmgen.out("  ldx  #$shifts |  jsr  math.lsr_word_AY")
+                                if(shifts==1) {
+                                    asmgen.out("""
+                                        pha
+                                        tya
+                                        cmp  #$80
+                                        ror  a
+                                        tay
+                                        pla
+                                        ror  a""")
+                                }
+                                else
+                                    asmgen.out("  ldx  #$shifts |  jsr  math.lsr_word_AY")
                             } else {
                                 if(shifts>0) {
                                     asmgen.out("  sty  P8ZP_SCRATCH_B1")
@@ -1108,10 +1217,17 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                 }
                 is PtNumber -> {
                     assignExpressionToRegister(left, RegisterOrPair.A, dt==DataType.BYTE)
-                    if(expr.operator=="+")
-                        asmgen.out("  clc |  adc  #${right.number.toHex()}")
-                    else
-                        asmgen.out("  sec |  sbc  #${right.number.toHex()}")
+                    if(right.number==1.0 && asmgen.isTargetCpu(CpuType.CPU65c02)) {
+                        if (expr.operator == "+")
+                            asmgen.out("  inc  a")
+                        else
+                            asmgen.out("  dec  a")
+                    } else {
+                        if (expr.operator == "+")
+                            asmgen.out("  clc |  adc  #${right.number.toHex()}")
+                        else
+                            asmgen.out("  sec |  sbc  #${right.number.toHex()}")
+                    }
                     assignRegisterByte(target, CpuRegister.A, dt in SignedDatatypes, true)
                     return true
                 }
@@ -1246,8 +1362,39 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                 }
                 is PtNumber -> {
                     assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
-                    if(expr.operator=="+") {
-                        asmgen.out("""
+                    if(right.number==1.0 && asmgen.isTargetCpu(CpuType.CPU65c02)) {
+                        if(expr.operator=="+") {
+                            asmgen.out("""
+                                inc  a
+                                bne  +
+                                iny
++""")
+                        } else {
+                            asmgen.out("""
+                                dec  a
+                                cmp  #255
+                                bne  +
+                                dey
++""")
+                        }
+                    } else if(dt!=DataType.WORD && right.number.toInt() in 0..255) {
+                        if(expr.operator=="+") {
+                            asmgen.out("""
+                                clc
+                                adc  #${right.number.toHex()}
+                                bcc  +
+                                iny
++""")                   } else if(expr.operator=="-") {
+                            asmgen.out("""
+                                sec
+                                sbc  #${right.number.toHex()}
+                                bcs  +
+                                dey
++""")
+                        }
+                    } else {
+                        if(expr.operator=="+") {
+                            asmgen.out("""
                                 clc
                                 adc  #<${right.number.toHex()}
                                 tax
@@ -1255,8 +1402,8 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                                 adc  #>${right.number.toHex()}
                                 tay
                                 txa""")
-                    } else if(expr.operator=="-") {
-                        asmgen.out("""
+                        } else if(expr.operator=="-") {
+                            asmgen.out("""
                                 sec
                                 sbc  #<${right.number.toHex()}
                                 tax
@@ -1264,6 +1411,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                                 sbc  #>${right.number.toHex()}
                                 tay
                                 txa""")
+                        }
                     }
                     assignRegisterpairWord(target, RegisterOrPair.AY)
                     return true
@@ -2323,7 +2471,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         asmgen.out("""
                             clc
                             adc  #$constIndex
-                            bne  +
+                            bcc  +
                             iny
 +""")
                 }
@@ -2348,7 +2496,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     asmgen.out("""
                         clc
                         adc  P8ZP_SCRATCH_REG
-                        bne  +
+                        bcc  +
                         iny                            
 +""")
                 }
@@ -2358,7 +2506,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         ldy  #>$sourceName
                         clc
                         adc  #<$sourceName
-                        bne  +
+                        bcc  +
                         iny
 +""")
                 }
@@ -3143,11 +3291,20 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     }
                     else {
                         if (regs !in Cx16VirtualRegisters) {
-                            when (regs) {
-                                RegisterOrPair.AX -> asmgen.out("  pha |  txa |  pha")
-                                RegisterOrPair.AY -> asmgen.out("  pha |  tya |  pha")
-                                RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
-                                else -> throw AssemblyError("expected reg pair")
+                            if (asmgen.isTargetCpu(CpuType.CPU65c02)) {
+                                when (regs) {
+                                    RegisterOrPair.AX -> asmgen.out("  pha |  phx")
+                                    RegisterOrPair.AY -> asmgen.out("  pha |  phy")
+                                    RegisterOrPair.XY -> asmgen.out("  phx |  phy")
+                                    else -> throw AssemblyError("expected reg pair")
+                                }
+                            } else {
+                                when (regs) {
+                                    RegisterOrPair.AX -> asmgen.out("  pha |  txa |  pha")
+                                    RegisterOrPair.AY -> asmgen.out("  pha |  tya |  pha")
+                                    RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
+                                    else -> throw AssemblyError("expected reg pair")
+                                }
                             }
                             asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.out("""
@@ -3186,11 +3343,20 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     }
                     else {
                         if (regs !in Cx16VirtualRegisters) {
-                            when (regs) {
-                                RegisterOrPair.AX -> asmgen.out("  pha |  txa |  pha")
-                                RegisterOrPair.AY -> asmgen.out("  pha |  tya |  pha")
-                                RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
-                                else -> throw AssemblyError("expected reg pair")
+                            if (asmgen.isTargetCpu(CpuType.CPU65c02)) {
+                                when (regs) {
+                                    RegisterOrPair.AX -> asmgen.out("  pha |  phx")
+                                    RegisterOrPair.AY -> asmgen.out("  pha |  phy")
+                                    RegisterOrPair.XY -> asmgen.out("  phx |  phy")
+                                    else -> throw AssemblyError("expected reg pair")
+                                }
+                            } else {
+                                when (regs) {
+                                    RegisterOrPair.AX -> asmgen.out("  pha |  txa |  pha")
+                                    RegisterOrPair.AY -> asmgen.out("  pha |  tya |  pha")
+                                    RegisterOrPair.XY -> asmgen.out("  txa |  pha |  tya |  pha")
+                                    else -> throw AssemblyError("expected reg pair")
+                                }
                             }
                             asmgen.loadScaledArrayIndexIntoRegister(target.array, CpuRegister.Y)
                             asmgen.out("""
@@ -3689,17 +3855,8 @@ internal class AssignmentAsmGen(private val program: PtProgram,
 
         fun storeViaExprEval() {
             when(addressExpr) {
-                is PtNumber, is PtIdentifier -> {
-                    assignExpressionToVariable(addressExpr, "P8ZP_SCRATCH_W2", DataType.UWORD)
-                    asmgen.storeAIntoZpPointerVar("P8ZP_SCRATCH_W2", false)
-                }
-                else -> {
-                    // same as above but we need to save the A register
-                    asmgen.out("  pha")
-                    assignExpressionToVariable(addressExpr, "P8ZP_SCRATCH_W2", DataType.UWORD)
-                    asmgen.out("  pla")
-                    asmgen.storeAIntoZpPointerVar("P8ZP_SCRATCH_W2", false)
-                }
+                is PtNumber, is PtIdentifier -> storeByteInAToAddressExpression(addressExpr, false)
+                else -> storeByteInAToAddressExpression(addressExpr, true)
             }
         }
 

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AugmentableAssignmentAsmGen.kt

@@ -1086,6 +1086,21 @@ $shortcutLabel:""")
             }
         }
 
+        if(asmgen.isTargetCpu(CpuType.CPU65c02)) {
+            if(operator=="&" && value is PtPrefix && value.operator=="~") {
+                // M &= ~A  -->  use TRB 65c02 instruction for that
+                asmgen.assignExpressionToRegister(value.value, RegisterOrPair.A, dt in SignedDatatypes)
+                asmgen.out("  trb  $name")
+                return
+            }
+            else if(operator=="|") {
+                // M |= A --> use TSB 65c02 instruction for that
+                asmgen.assignExpressionToRegister(value, RegisterOrPair.A, dt in SignedDatatypes)
+                asmgen.out("  tsb  $name")
+                return
+            }
+        }
+
         // normal evaluation
         asmgen.assignExpressionToRegister(value, RegisterOrPair.A, dt in SignedDatatypes)
         inplacemodificationRegisterAwithVariableWithSwappedOperands(operator, name, dt in SignedDatatypes)
@@ -1094,6 +1109,15 @@ $shortcutLabel:""")
 
     private fun inplacemodificationByteVariableWithVariable(name: String, dt: DataType, operator: String, otherName: String) {
         // note: no logical and/or shortcut here, not worth it due to simple right operand
+
+        if(asmgen.isTargetCpu(CpuType.CPU65c02)) {
+            if(operator=="|") {
+                // M |= A  -->  use TSB 65c02 instruction for that
+                asmgen.out("  lda  $otherName |  tsb  $name")
+                return
+            }
+        }
+
         asmgen.out("  lda  $name")
         inplacemodificationRegisterAwithVariable(operator, otherName, dt in SignedDatatypes)
         asmgen.out("  sta  $name")
@@ -1459,6 +1483,7 @@ $shortcutLabel:""")
                     asmgen.out("  lda  $name |  ldy  #$value |  jsr  math.multiply_bytes |  sta  $name")
             }
             "/" -> {
+                // replacing division by shifting is done in an optimizer step.
                 if (dt == DataType.UBYTE)
                     asmgen.out("  lda  $name |  ldy  #$value |  jsr  math.divmod_ub_asm |  sty  $name")
                 else
@@ -1642,7 +1667,7 @@ $shortcutLabel:""")
     }
 
     private fun immediateOrInplace(name: String, value: Int) {
-        if(asmgen.isTargetCpu(CpuType.CPU65c02) && ((value and (value-1))==0)) {
+        if(asmgen.isTargetCpu(CpuType.CPU65c02)) {
             asmgen.out(" lda  #$value |  tsb  $name")       // set bit
         } else  {
             asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
@@ -1703,7 +1728,7 @@ $shortcutLabel:""")
 
     private fun inplacemodificationWordWithLiteralval(name: String, dt: DataType, operator: String, value: Int, block: PtBlock?) {
         // note: this contains special optimized cases because we know the exact value. Don't replace this with another routine.
-        inplacemodificationSomeWordWithLiteralval(name, name + "+1", dt, operator, value, block)
+        inplacemodificationSomeWordWithLiteralval(name, "$name+1", dt, operator, value, block)
     }
     
     private fun inplacemodificationSomeWordWithLiteralval(lsb: String, msb: String, dt: DataType, operator: String, value: Int, block: PtBlock?) {
@@ -1807,33 +1832,36 @@ $shortcutLabel:""")
                 }
             }
             "/" -> {
-                if(value==0)
+                // replacing division by shifting is done in an optimizer step.
+                if(value==0) {
                     throw AssemblyError("division by zero")
-                if(dt==DataType.WORD) {
-                    asmgen.out("""
-                        lda  $lsb
-                        ldy  $msb
-                        sta  P8ZP_SCRATCH_W1
-                        sty  P8ZP_SCRATCH_W1+1
-                        lda  #<$value
-                        ldy  #>$value
-                        jsr  math.divmod_w_asm
-                        sta  $lsb
-                        sty  $msb
-                    """)
-                }
-                else {
-                    asmgen.out("""
-                        lda  $lsb
-                        ldy  $msb
-                        sta  P8ZP_SCRATCH_W1
-                        sty  P8ZP_SCRATCH_W1+1
-                        lda  #<$value
-                        ldy  #>$value
-                        jsr  math.divmod_uw_asm
-                        sta  $lsb
-                        sty  $msb
-                    """)
+                } else {
+                    if(dt==DataType.WORD) {
+                        asmgen.out("""
+                            lda  $lsb
+                            ldy  $msb
+                            sta  P8ZP_SCRATCH_W1
+                            sty  P8ZP_SCRATCH_W1+1
+                            lda  #<$value
+                            ldy  #>$value
+                            jsr  math.divmod_w_asm
+                            sta  $lsb
+                            sty  $msb
+                        """)
+                    }
+                    else {
+                        asmgen.out("""
+                            lda  $lsb
+                            ldy  $msb
+                            sta  P8ZP_SCRATCH_W1
+                            sty  P8ZP_SCRATCH_W1+1
+                            lda  #<$value
+                            ldy  #>$value
+                            jsr  math.divmod_uw_asm
+                            sta  $lsb
+                            sty  $msb
+                        """)
+                    }
                 }
             }
             "%" -> {

codeGenExperimental/build.gradle

@@ -6,9 +6,8 @@ plugins {
 }
 
 java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(javaVersion)
-    }
+    targetCompatibility = JavaLanguageVersion.of(javaVersion)
+    sourceCompatibility = JavaLanguageVersion.of(javaVersion)
 }
 
 compileKotlin {
@@ -29,7 +28,7 @@ dependencies {
     implementation project(':codeGenIntermediate')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.20"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.0"
 
 }
 

codeGenIntermediate/build.gradle

@@ -6,9 +6,8 @@ plugins {
 }
 
 java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(javaVersion)
-    }
+    targetCompatibility = JavaLanguageVersion.of(javaVersion)
+    sourceCompatibility = JavaLanguageVersion.of(javaVersion)
 }
 
 compileKotlin {
@@ -28,9 +27,9 @@ dependencies {
     implementation project(':intermediate')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.20"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.0"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.9.1'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 

codeGenIntermediate/src/prog8/codegen/intermediate/AssignmentGen.kt

@@ -76,7 +76,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
 
     internal fun translate(augAssign: PtAugmentedAssign): IRCodeChunks {
         // augmented assignment always has just a single target
-        if(augAssign.target.children.single() is PtIrRegister)
+        if (augAssign.target.children.single() is PtIrRegister)
             throw AssemblyError("assigning to a register should be done by just evaluating the expression into resultregister")
 
         val target = augAssign.target
@@ -87,7 +87,8 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         val array = target.array
         val value = augAssign.value
         val signed = target.type in SignedDatatypes
-        val result = when(augAssign.operator) {
+
+        val chunks = when (augAssign.operator) {
             "+=" -> operatorPlusInplace(symbol, array, constAddress, memTarget, targetDt, value)
             "-=" -> operatorMinusInplace(symbol, array, constAddress, memTarget, targetDt, value)
             "*=" -> operatorMultiplyInplace(symbol, array, constAddress, memTarget, targetDt, value)
@@ -109,9 +110,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             in PrefixOperators -> inplacePrefix(augAssign.operator, symbol, array, constAddress, memTarget, targetDt)
 
             else -> throw AssemblyError("invalid augmented assign operator ${augAssign.operator}")
-        }
-
-        val chunks = if(result!=null) result else fallbackAssign(augAssign)
+        } ?: fallbackAssign(augAssign)
         chunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(augAssign.position)
         return chunks
     }
@@ -140,7 +139,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         return translateRegularAssign(normalAssign)
     }
 
-    private fun inplacePrefix(operator: String, symbol: String?, array: PtArrayIndexer?, constAddress: Int?, memory: PtMemoryByte?, vmDt: IRDataType): IRCodeChunks? {
+    private fun inplacePrefix(operator: String, symbol: String?, array: PtArrayIndexer?, constAddress: Int?, memory: PtMemoryByte?, vmDt: IRDataType): IRCodeChunks {
         if(operator=="+")
             return emptyList()
 
@@ -503,9 +502,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             addToResult(result, tr, tr.resultReg, -1)
             return Pair(result, tr.resultReg)
         }
-
-        val mult: PtExpression
-        mult = PtBinaryExpression("*", DataType.UBYTE, array.position)
+        val mult: PtExpression = PtBinaryExpression("*", DataType.UBYTE, array.position)
         mult.children += array.index
         mult.children += PtNumber(DataType.UBYTE, itemsize.toDouble(), array.position)
         val tr = expressionEval.translateExpression(mult)
@@ -1393,9 +1390,9 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                 val valueReg = codeGen.registers.nextFree()
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, vmDt, reg1=valueReg, labelSymbol = array.variable.name, symbolOffset = constIndex*eltSize)
-                    when(comparisonOperator) {
-                        "==" -> it += IRInstruction(Opcode.SZ, vmDt, reg1=cmpResultReg, reg2=valueReg)
-                        "!=" -> it += IRInstruction(Opcode.SNZ, vmDt, reg1=cmpResultReg, reg2=valueReg)
+                    it += when(comparisonOperator) {
+                        "==" -> IRInstruction(Opcode.SZ, vmDt, reg1=cmpResultReg, reg2=valueReg)
+                        "!=" -> IRInstruction(Opcode.SNZ, vmDt, reg1=cmpResultReg, reg2=valueReg)
                         "<" -> return null  // TODO("array <0 inplace")) // TODO?
                         "<=" -> return null  // TODO("array <=0 inplace")) // TODO?
                         ">" -> return null  // TODO("array >0 inplace")) // TODO?
@@ -1416,9 +1413,9 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                 addToResult(result, indexTr, indexTr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADX, vmDt, reg1=valueReg, reg2=indexTr.resultReg, labelSymbol = array.variable.name)
-                    when(comparisonOperator) {
-                        "==" -> it += IRInstruction(Opcode.SZ, vmDt, reg1=cmpResultReg, reg2=valueReg)
-                        "!=" -> it += IRInstruction(Opcode.SNZ, vmDt, reg1=cmpResultReg, reg2=valueReg)
+                    it += when(comparisonOperator) {
+                        "==" -> IRInstruction(Opcode.SZ, vmDt, reg1=cmpResultReg, reg2=valueReg)
+                        "!=" -> IRInstruction(Opcode.SNZ, vmDt, reg1=cmpResultReg, reg2=valueReg)
                         "<" -> return null  // TODO("array <0 inplace")) // TODO?
                         "<=" -> return null  // TODO("array <=0 inplace")) // TODO?
                         ">" -> return null  // TODO("array >0 inplace")) // TODO?

codeGenIntermediate/src/prog8/codegen/intermediate/BuiltinFuncGen.kt

@@ -9,8 +9,6 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
     fun translate(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         return when(call.name) {
-            "any" -> funcAny(call)
-            "all" -> funcAll(call)
             "abs__byte", "abs__word", "abs__float" -> funcAbs(call)
             "cmp" -> funcCmp(call)
             "sgn" -> funcSgn(call)
@@ -34,14 +32,14 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             "clamp__byte", "clamp__ubyte", "clamp__word", "clamp__uword" -> funcClamp(call)
             "min__byte", "min__ubyte", "min__word", "min__uword" -> funcMin(call)
             "max__byte", "max__ubyte", "max__word", "max__uword" -> funcMax(call)
-            "sort" -> funcSort(call)
-            "reverse" -> funcReverse(call)
             "setlsb" -> funcSetLsbMsb(call, false)
             "setmsb" -> funcSetLsbMsb(call, true)
             "rol" -> funcRolRor(call)
             "ror" -> funcRolRor(call)
             "rol2" -> funcRolRor(call)
             "ror2" -> funcRolRor(call)
+            "prog8_ifelse_bittest_set" -> throw AssemblyError("prog8_ifelse_bittest_set() should have been translated as part of an ifElse statement")
+            "prog8_ifelse_bittest_notset" -> throw AssemblyError("prog8_ifelse_bittest_notset() should have been translated as part of an ifElse statement")
             "prog8_lib_stringcompare" -> funcStringCompare(call)
             "prog8_lib_square_byte" -> funcSquare(call, IRDataType.BYTE)
             "prog8_lib_square_word" -> funcSquare(call, IRDataType.WORD)
@@ -132,10 +130,10 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         val addressTr = exprGen.translateExpression(call.args[0])
         addToResult(result, addressTr, addressTr.resultReg, -1)
         addInstr(result, IRInstruction(Opcode.CALLI, reg1 = addressTr.resultReg), null)
-        if(call.void)
-            return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+        return if(call.void)
+            ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
         else
-            return ExpressionCodeResult(result, IRDataType.WORD, codeGen.registers.nextFree(), -1)      // TODO actually the result is returned in CPU registers AY...
+            ExpressionCodeResult(result, IRDataType.WORD, codeGen.registers.nextFree(), -1)      // TODO actually the result is returned in CPU registers AY...
     }
 
     private fun funcCallfar(call: PtBuiltinFunctionCall): ExpressionCodeResult {
@@ -204,79 +202,6 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, dt, leftTr.resultReg, -1)
     }
 
-    private fun funcAny(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val arrayName = call.args[0] as PtIdentifier
-        val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
-        val result = mutableListOf<IRCodeChunkBase>()
-        val lengthReg = codeGen.registers.nextFree()
-
-        if(arrayName.type in SplitWordArrayTypes) {
-            // any(lsb-array) or any(msb-array)
-            addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
-            val trLsb = exprGen.translateExpression(PtIdentifier(arrayName.name+"_lsb", DataType.ARRAY_UB, call.position))
-            addToResult(result, trLsb, trLsb.resultReg, -1)
-            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = arrayLength), null)
-            result += codeGen.makeSyscall(IMSyscall.ANY_BYTE, listOf(IRDataType.WORD to trLsb.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to trLsb.resultReg)
-            val shortcircuitLabel = codeGen.createLabelName()
-            result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1 = trLsb.resultReg, immediate = 0)
-                it += IRInstruction(Opcode.BSTNE, labelSymbol = shortcircuitLabel)
-                it += IRInstruction(Opcode.PREPARECALL, immediate = 2)
-            }
-            val trMsb = exprGen.translateExpression(PtIdentifier(arrayName.name+"_msb", DataType.ARRAY_UB, call.position))
-            addToResult(result, trMsb, trMsb.resultReg, -1)
-            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = arrayLength), null)
-            result += codeGen.makeSyscall(IMSyscall.ANY_BYTE, listOf(IRDataType.WORD to trMsb.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to trMsb.resultReg)
-            addInstr(result, IRInstruction(Opcode.ORR, IRDataType.BYTE, reg1=trLsb.resultReg, reg2=trMsb.resultReg), null)
-            result += IRCodeChunk(shortcircuitLabel, null)
-            return ExpressionCodeResult(result, IRDataType.BYTE, trLsb.resultReg, -1)
-        }
-
-        val syscall =
-            when (arrayName.type) {
-                DataType.ARRAY_UB,
-                DataType.ARRAY_B -> IMSyscall.ANY_BYTE
-                DataType.ARRAY_UW,
-                DataType.ARRAY_W -> IMSyscall.ANY_WORD
-                DataType.ARRAY_F -> IMSyscall.ANY_FLOAT
-                else -> throw IllegalArgumentException("weird type")
-            }
-        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
-        val tr = exprGen.translateExpression(arrayName)
-        addToResult(result, tr, tr.resultReg, -1)
-        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = arrayLength!! and 255), null)
-        result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to tr.resultReg)
-        return ExpressionCodeResult(result, IRDataType.BYTE, tr.resultReg, -1)
-    }
-
-    private fun funcAll(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val arrayName = call.args[0] as PtIdentifier
-        val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
-
-        if(arrayName.type in SplitWordArrayTypes) {
-            // this is a bit complicated to calculate.... have to check all recombined (lsb,msb) words for $0000
-            TODO("all(split words $arrayName)")
-        }
-
-        val syscall =
-            when(arrayName.type) {
-                DataType.ARRAY_UB,
-                DataType.ARRAY_B -> IMSyscall.ALL_BYTE
-                DataType.ARRAY_UW,
-                DataType.ARRAY_W -> IMSyscall.ALL_WORD
-                DataType.ARRAY_F -> IMSyscall.ALL_FLOAT
-                else -> throw IllegalArgumentException("weird type")
-            }
-        val result = mutableListOf<IRCodeChunkBase>()
-        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
-        val tr = exprGen.translateExpression(arrayName)
-        addToResult(result, tr, tr.resultReg, -1)
-        val lengthReg = codeGen.registers.nextFree()
-        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = arrayLength!! and 255), null)
-        result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to tr.resultReg)
-        return ExpressionCodeResult(result, IRDataType.BYTE, tr.resultReg, -1)
-    }
-
     private fun funcAbs(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val sourceDt = call.args.single().type
         val result = mutableListOf<IRCodeChunkBase>()
@@ -369,65 +294,6 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         }
     }
 
-    private fun funcReverse(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val arrayName = call.args[0] as PtIdentifier
-        val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
-        val lengthReg = codeGen.registers.nextFree()
-        val result = mutableListOf<IRCodeChunkBase>()
-
-        if(arrayName.type in SplitWordArrayTypes) {
-            // reverse the lsb and msb arrays both, independently
-            addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
-            val trLsb = exprGen.translateExpression(PtIdentifier(arrayName.name+"_lsb", DataType.ARRAY_UB, call.position))
-            addToResult(result, trLsb, trLsb.resultReg, -1)
-            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(arrayName.type==DataType.STR) arrayLength!!-1 else arrayLength), null)
-            result += codeGen.makeSyscall(IMSyscall.REVERSE_BYTES, listOf(IRDataType.WORD to trLsb.resultReg, IRDataType.BYTE to lengthReg), null)
-            val trMsb = exprGen.translateExpression(PtIdentifier(arrayName.name+"_msb", DataType.ARRAY_UB, call.position))
-            addToResult(result, trMsb, trMsb.resultReg, -1)
-            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(arrayName.type==DataType.STR) arrayLength!!-1 else arrayLength), null)
-            result += codeGen.makeSyscall(IMSyscall.REVERSE_BYTES, listOf(IRDataType.WORD to trMsb.resultReg, IRDataType.BYTE to lengthReg), null)
-            return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
-        }
-
-        val syscall =
-            when(arrayName.type) {
-                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.STR -> IMSyscall.REVERSE_BYTES
-                DataType.ARRAY_UW, DataType.ARRAY_W -> IMSyscall.REVERSE_WORDS
-                DataType.ARRAY_F -> IMSyscall.REVERSE_FLOATS
-                else -> throw IllegalArgumentException("weird type to reverse")
-            }
-        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
-        val tr = exprGen.translateExpression(arrayName)
-        addToResult(result, tr, tr.resultReg, -1)
-        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(arrayName.type==DataType.STR) arrayLength!!-1 else arrayLength), null)
-        result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), null)
-        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
-    }
-
-    private fun funcSort(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val arrayName = call.args[0] as PtIdentifier
-        val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
-        val syscall =
-            when(arrayName.type) {
-                DataType.ARRAY_UB -> IMSyscall.SORT_UBYTE
-                DataType.ARRAY_B -> IMSyscall.SORT_BYTE
-                DataType.ARRAY_UW -> IMSyscall.SORT_UWORD
-                DataType.ARRAY_W -> IMSyscall.SORT_WORD
-                DataType.STR -> IMSyscall.SORT_UBYTE
-                DataType.ARRAY_F -> throw IllegalArgumentException("sorting a floating point array is not supported")
-                in SplitWordArrayTypes -> TODO("split word sort")
-                else -> throw IllegalArgumentException("weird type to sort")
-            }
-        val result = mutableListOf<IRCodeChunkBase>()
-        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
-        val tr = exprGen.translateExpression(arrayName)
-        addToResult(result, tr, tr.resultReg, -1)
-        val lengthReg = codeGen.registers.nextFree()
-        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(arrayName.type==DataType.STR) arrayLength!!-1 else arrayLength), null)
-        result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), null)
-        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
-    }
-
     private fun funcMkword(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val resultReg = codeGen.registers.nextFree()

codeGenIntermediate/src/prog8/codegen/intermediate/ExpressionGen.kt

@@ -1,5 +1,6 @@
 package prog8.codegen.intermediate
 
+import prog8.code.StNode
 import prog8.code.StRomSub
 import prog8.code.StSub
 import prog8.code.ast.*
@@ -451,7 +452,36 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
     }
 
     fun translate(fcall: PtFunctionCall): ExpressionCodeResult {
-        when (val callTarget = codeGen.symbolTable.flat.getValue(fcall.name)) {
+        val callTarget = codeGen.symbolTable.flat.getValue(fcall.name)
+
+        if(callTarget.scopedName in listOf("sys.push", "sys.pushw", "sys.pop", "sys.popw")) {
+            // special case, these should be inlined, or even use specialized instructions. Instead of doing a normal subroutine call.
+            return translateStackFunctions(fcall, callTarget)
+        }
+        when(callTarget.scopedName) {
+            "sys.clear_carry" -> {
+                val chunk = mutableListOf<IRCodeChunkBase>()
+                addInstr(chunk, IRInstruction(Opcode.CLC), null)
+                return ExpressionCodeResult(chunk, IRDataType.BYTE, -1, -1)
+            }
+            "sys.set_carry" -> {
+                val chunk = mutableListOf<IRCodeChunkBase>()
+                addInstr(chunk, IRInstruction(Opcode.SEC), null)
+                return ExpressionCodeResult(chunk, IRDataType.BYTE, -1, -1)
+            }
+            "sys.clear_irqd" -> {
+                val chunk = mutableListOf<IRCodeChunkBase>()
+                addInstr(chunk, IRInstruction(Opcode.CLI), null)
+                return ExpressionCodeResult(chunk, IRDataType.BYTE, -1, -1)
+            }
+            "sys.set_irqd" -> {
+                val chunk = mutableListOf<IRCodeChunkBase>()
+                addInstr(chunk, IRInstruction(Opcode.SEI), null)
+                return ExpressionCodeResult(chunk, IRDataType.BYTE, -1, -1)
+            }
+        }
+
+        when (callTarget) {
             is StSub -> {
                 val result = mutableListOf<IRCodeChunkBase>()
                 addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = callTarget.parameters.size), null)
@@ -590,6 +620,39 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         }
     }
 
+    private fun translateStackFunctions(fcall: PtFunctionCall, callTarget: StNode): ExpressionCodeResult {
+        val chunk = mutableListOf<IRCodeChunkBase>()
+        when(callTarget.scopedName) {
+            "sys.push" -> {
+                // push byte
+                val tr = translateExpression(fcall.args.single())
+                chunk += tr.chunks
+                addInstr(chunk, IRInstruction(Opcode.PUSH, IRDataType.BYTE, reg1=tr.resultReg), null)
+                return ExpressionCodeResult(chunk, IRDataType.BYTE, -1, -1)
+            }
+            "sys.pushw" -> {
+                // push word
+                val tr = translateExpression(fcall.args.single())
+                chunk += tr.chunks
+                addInstr(chunk, IRInstruction(Opcode.PUSH, IRDataType.WORD, reg1=tr.resultReg), null)
+                return ExpressionCodeResult(chunk, IRDataType.WORD, -1, -1)
+            }
+            "sys.pop" -> {
+                // pop byte
+                val popReg = codeGen.registers.nextFree()
+                addInstr(chunk, IRInstruction(Opcode.POP, IRDataType.BYTE, reg1=popReg), null)
+                return ExpressionCodeResult(chunk, IRDataType.BYTE, popReg, -1)
+            }
+            "sys.popw" -> {
+                // pop word
+                val popReg = codeGen.registers.nextFree()
+                addInstr(chunk, IRInstruction(Opcode.POP, IRDataType.WORD, reg1=popReg), null)
+                return ExpressionCodeResult(chunk, IRDataType.WORD, popReg, -1)
+            }
+            else -> throw AssemblyError("unknown stack subroutine called")
+        }
+    }
+
     private fun callRomSubWithMultipleReturnValues(
         callTarget: StRomSub,
         fcall: PtFunctionCall,
@@ -786,17 +849,21 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val result = mutableListOf<IRCodeChunkBase>()
         val tr = translateExpression(binExpr.left)
         addToResult(result, tr, tr.resultReg, -1)
-        return if(binExpr.right is PtNumber) {
-            addInstr(result, IRInstruction(Opcode.XOR, vmDt, reg1 = tr.resultReg, immediate = (binExpr.right as PtNumber).number.toInt()), null)
-            ExpressionCodeResult(result, vmDt, tr.resultReg, -1)
-        } else if(binExpr.right is PtBool) {
-            addInstr(result, IRInstruction(Opcode.XOR, vmDt, reg1 = tr.resultReg, immediate = (binExpr.right as PtBool).asInt()), null)
-            ExpressionCodeResult(result, vmDt, tr.resultReg, -1)
-        } else {
-            val rightTr = translateExpression(binExpr.right)
-            addToResult(result, rightTr, rightTr.resultReg, -1)
-            addInstr(result, IRInstruction(Opcode.XORR, vmDt, reg1 = tr.resultReg, reg2 = rightTr.resultReg), null)
-            ExpressionCodeResult(result, vmDt, tr.resultReg, -1)
+        return when (binExpr.right) {
+            is PtNumber -> {
+                addInstr(result, IRInstruction(Opcode.XOR, vmDt, reg1 = tr.resultReg, immediate = (binExpr.right as PtNumber).number.toInt()), null)
+                ExpressionCodeResult(result, vmDt, tr.resultReg, -1)
+            }
+            is PtBool -> {
+                addInstr(result, IRInstruction(Opcode.XOR, vmDt, reg1 = tr.resultReg, immediate = (binExpr.right as PtBool).asInt()), null)
+                ExpressionCodeResult(result, vmDt, tr.resultReg, -1)
+            }
+            else -> {
+                val rightTr = translateExpression(binExpr.right)
+                addToResult(result, rightTr, rightTr.resultReg, -1)
+                addInstr(result, IRInstruction(Opcode.XORR, vmDt, reg1 = tr.resultReg, reg2 = rightTr.resultReg), null)
+                ExpressionCodeResult(result, vmDt, tr.resultReg, -1)
+            }
         }
     }
 

codeGenIntermediate/src/prog8/codegen/intermediate/IRCodeGen.kt

@@ -5,7 +5,6 @@ import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.intermediate.*
 import kotlin.io.path.readBytes
-import kotlin.math.pow
 
 
 class IRCodeGen(
@@ -52,9 +51,6 @@ class IRCodeGen(
         optimizer.optimize(options.optimize, errors)
         irProg.validate()
 
-        val regOptimizer = IRRegisterOptimizer(irProg)
-        regOptimizer.optimize()
-
         return irProg
     }
 
@@ -394,10 +390,10 @@ class IRCodeGen(
         val result = mutableListOf<IRCodeChunkBase>()
         when(iterable) {
             is PtRange -> {
-                if(iterable.from is PtNumber && iterable.to is PtNumber)
-                    result += translateForInConstantRange(forLoop, loopvar)
+                result += if(iterable.from is PtNumber && iterable.to is PtNumber)
+                    translateForInConstantRange(forLoop, loopvar)
                 else
-                    result += translateForInNonConstantRange(forLoop, loopvar)
+                    translateForInNonConstantRange(forLoop, loopvar)
             }
             is PtIdentifier -> {
                 require(forLoop.variable.name == loopvar.scopedName)
@@ -685,13 +681,11 @@ class IRCodeGen(
         return code
     }
 
-    internal val powersOfTwo = (0..16).map { 2.0.pow(it.toDouble()).toInt() }
-
     internal fun multiplyByConst(dt: IRDataType, reg: Int, factor: Int): IRCodeChunk {
         val code = IRCodeChunk(null, null)
         if(factor==1)
             return code
-        val pow2 = powersOfTwo.indexOf(factor)
+        val pow2 = powersOfTwoInt.indexOf(factor)
         if(pow2==1) {
             // just shift 1 bit
             code += IRInstruction(Opcode.LSL, dt, reg1=reg)
@@ -715,7 +709,7 @@ class IRCodeGen(
         val code = IRCodeChunk(null, null)
         if(factor==1)
             return code
-        val pow2 = powersOfTwo.indexOf(factor)
+        val pow2 = powersOfTwoInt.indexOf(factor)
         if(pow2==1) {
             // just shift 1 bit
             code += if(knownAddress!=null)
@@ -788,19 +782,32 @@ class IRCodeGen(
         val code = IRCodeChunk(null, null)
         if(factor==1)
             return code
-        val pow2 = powersOfTwo.indexOf(factor)
-        if(pow2==1 && !signed) {
-            code += IRInstruction(Opcode.LSR, dt, reg1=reg)     // simple single bit shift
-        }
-        else if(pow2>=1 &&!signed) {
-            // just shift multiple bits
-            val pow2reg = registers.nextFree()
-            code += IRInstruction(Opcode.LOAD, dt, reg1=pow2reg, immediate = pow2)
-            code += if(signed)
-                IRInstruction(Opcode.ASRN, dt, reg1=reg, reg2=pow2reg)
-            else
-                IRInstruction(Opcode.LSRN, dt, reg1=reg, reg2=pow2reg)
+        val pow2 = powersOfTwoInt.indexOf(factor)
+        if(pow2>=0) {
+            if(signed) {
+                if(pow2==1) {
+                    // simple single bit shift (signed)
+                    code += IRInstruction(Opcode.ASR, dt, reg1=reg)
+                } else {
+                    // just shift multiple bits (signed)
+                    val pow2reg = registers.nextFree()
+                    code += IRInstruction(Opcode.LOAD, dt, reg1=pow2reg, immediate = pow2)
+                    code += IRInstruction(Opcode.ASRN, dt, reg1=reg, reg2=pow2reg)
+                }
+            } else {
+                if(pow2==1) {
+                    // simple single bit shift (unsigned)
+                    code += IRInstruction(Opcode.LSR, dt, reg1=reg)
+                } else {
+                    // just shift multiple bits (unsigned)
+                    val pow2reg = registers.nextFree()
+                    code += IRInstruction(Opcode.LOAD, dt, reg1 = pow2reg, immediate = pow2)
+                    code += IRInstruction(Opcode.LSRN, dt, reg1 = reg, reg2 = pow2reg)
+                }
+            }
+            return code
         } else {
+            // regular div
             code += if (factor == 0) {
                 IRInstruction(Opcode.LOAD, dt, reg1=reg, immediate = 0xffff)
             } else {
@@ -809,39 +816,56 @@ class IRCodeGen(
                 else
                     IRInstruction(Opcode.DIV, dt, reg1=reg, immediate = factor)
             }
+            return code
         }
-        return code
     }
 
     internal fun divideByConstInplace(dt: IRDataType, knownAddress: Int?, symbol: String?, factor: Int, signed: Boolean): IRCodeChunk {
         val code = IRCodeChunk(null, null)
         if(factor==1)
             return code
-        val pow2 = powersOfTwo.indexOf(factor)
-        if(pow2==1 && !signed) {
-            // just simple bit shift
-            code += if(knownAddress!=null)
-                IRInstruction(Opcode.LSRM, dt, address = knownAddress)
-            else
-                IRInstruction(Opcode.LSRM, dt, labelSymbol = symbol)
+        val pow2 = powersOfTwoInt.indexOf(factor)
+        if(pow2>=0) {
+            // can do bit shift instead of division
+            if(signed) {
+                if(pow2==1) {
+                    // just simple bit shift (signed)
+                    code += if (knownAddress != null)
+                        IRInstruction(Opcode.ASRM, dt, address = knownAddress)
+                    else
+                        IRInstruction(Opcode.ASRM, dt, labelSymbol = symbol)
+                } else {
+                    // just shift multiple bits (signed)
+                    val pow2reg = registers.nextFree()
+                    code += IRInstruction(Opcode.LOAD, dt, reg1 = pow2reg, immediate = pow2)
+                    code += if (knownAddress != null)
+                                IRInstruction(Opcode.ASRNM, dt, reg1 = pow2reg, address = knownAddress)
+                            else
+                                IRInstruction(Opcode.ASRNM, dt, reg1 = pow2reg, labelSymbol = symbol)
+                }
+            } else {
+                if(pow2==1) {
+                    // just simple bit shift (unsigned)
+                    code += if(knownAddress!=null)
+                        IRInstruction(Opcode.LSRM, dt, address = knownAddress)
+                    else
+                        IRInstruction(Opcode.LSRM, dt, labelSymbol = symbol)
+                }
+                else {
+                    // just shift multiple bits (unsigned)
+                    val pow2reg = registers.nextFree()
+                    code += IRInstruction(Opcode.LOAD, dt, reg1=pow2reg, immediate = pow2)
+                    code += if(knownAddress!=null)
+                                IRInstruction(Opcode.LSRNM, dt, reg1 = pow2reg, address = knownAddress)
+                            else
+                                IRInstruction(Opcode.LSRNM, dt, reg1 = pow2reg, labelSymbol = symbol)
+                }
+            }
+            return code
         }
-        else if(pow2>=1 && !signed) {
-            // just shift multiple bits
-            val pow2reg = registers.nextFree()
-            code += IRInstruction(Opcode.LOAD, dt, reg1=pow2reg, immediate = pow2)
-            code += if(signed) {
-                if(knownAddress!=null)
-                    IRInstruction(Opcode.ASRNM, dt, reg1 = pow2reg, address = knownAddress)
-                else
-                    IRInstruction(Opcode.ASRNM, dt, reg1 = pow2reg, labelSymbol = symbol)
-            }
-            else {
-                if(knownAddress!=null)
-                    IRInstruction(Opcode.LSRNM, dt, reg1 = pow2reg, address = knownAddress)
-                else
-                    IRInstruction(Opcode.LSRNM, dt, reg1 = pow2reg, labelSymbol = symbol)
-            }
-        } else {
+        else
+        {
+            // regular div
             if (factor == 0) {
                 val reg = registers.nextFree()
                 code += IRInstruction(Opcode.LOAD, dt, reg1=reg, immediate = 0xffff)
@@ -866,8 +890,8 @@ class IRCodeGen(
                         IRInstruction(Opcode.DIVM, dt, reg1 = factorReg, labelSymbol = symbol)
                 }
             }
+            return code
         }
-        return code
     }
 
     private fun translate(ifElse: PtIfElse): IRCodeChunks {
@@ -1294,6 +1318,10 @@ class IRCodeGen(
         val result = mutableListOf<IRCodeChunkBase>()
 
         fun translateSimple(condition: PtExpression, jumpFalseOpcode: Opcode) {
+
+            if(condition is PtBuiltinFunctionCall && condition.name.startsWith("prog8_ifelse_bittest_"))
+                throw AssemblyError("IR codegen doesn't have special instructions for dedicated BIT tests and should just still use normal AND")
+
             val tr = expressionEval.translateExpression(condition)
             result += tr.chunks
             if(ifElse.hasElse()) {
@@ -1506,17 +1534,16 @@ class IRCodeGen(
     private fun translate(jump: PtJump): IRCodeChunks {
         val result = mutableListOf<IRCodeChunkBase>()
         val chunk = IRCodeChunk(null, null)
-        if(jump.address!=null) {
-            chunk += IRInstruction(Opcode.JUMP, address = jump.address!!.toInt())
+        chunk += if(jump.address!=null) {
+            IRInstruction(Opcode.JUMP, address = jump.address!!.toInt())
         } else {
             if (jump.identifier != null) {
                 if(isIndirectJump(jump)) {
-                    chunk += IRInstruction(Opcode.JUMPI, labelSymbol = jump.identifier!!.name)
+                    IRInstruction(Opcode.JUMPI, labelSymbol = jump.identifier!!.name)
                 } else {
-                    chunk += IRInstruction(Opcode.JUMP, labelSymbol = jump.identifier!!.name)
+                    IRInstruction(Opcode.JUMP, labelSymbol = jump.identifier!!.name)
                 }
-            }
-            else
+            } else
                 throw AssemblyError("weird jump")
         }
         result += chunk

codeGenIntermediate/src/prog8/codegen/intermediate/IRPeepholeOptimizer.kt

@@ -179,8 +179,7 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
         chunks += sub.chunks[0]
         for(ix in 1 until sub.chunks.size) {
             val lastChunk = chunks.last()
-            val candidate = sub.chunks[ix]
-            when(candidate) {
+            when(val candidate = sub.chunks[ix]) {
                 is IRCodeChunk -> {
                     if(mayJoinCodeChunks(lastChunk, candidate)) {
                         lastChunk.instructions += candidate.instructions
@@ -264,6 +263,24 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                     }
                 }
             }
+
+            if(ins.opcode== Opcode.SEI || ins.opcode== Opcode.CLI) {
+                if(idx < chunk.instructions.size-1) {
+                    val insAfter = chunk.instructions[idx+1]
+                    if(insAfter.opcode == ins.opcode) {
+                        chunk.instructions.removeAt(idx)
+                        changed = true
+                    }
+                    else if(ins.opcode== Opcode.SEI && insAfter.opcode== Opcode.CLI) {
+                        chunk.instructions.removeAt(idx)
+                        changed = true
+                    }
+                    else if(ins.opcode== Opcode.CLI && insAfter.opcode== Opcode.SEI) {
+                        chunk.instructions.removeAt(idx)
+                        changed = true
+                    }
+                }
+            }
         }
         return changed
     }

codeGenIntermediate/src/prog8/codegen/intermediate/IRRegisterOptimizer.kt

@@ -1,103 +0,0 @@
-package prog8.codegen.intermediate
-
-import prog8.intermediate.IRProgram
-
-
-class IRRegisterOptimizer(private val irProg: IRProgram) {
-    fun optimize() {
-        // reuseRegisters()
-    }
-
-/*
-    TODO: this register re-use renumbering isn't going to work like this,
-    because subroutines will be clobbering the registers that the subroutine
-    which is calling them might be using...
-
-
-    private fun reuseRegisters() {
-
-        fun addToUsage(usage: MutableMap<Pair<Int, IRDataType>, MutableSet<IRCodeChunkBase>>,
-                       regnum: Int,
-                       dt: IRDataType,
-                       chunk: IRCodeChunkBase) {
-            val key = regnum to dt
-            val chunks = usage[key] ?: mutableSetOf()
-            chunks.add(chunk)
-            usage[key] = chunks
-        }
-
-        val usage: MutableMap<Pair<Int, IRDataType>, MutableSet<IRCodeChunkBase>> = mutableMapOf()
-
-        irProg.foreachCodeChunk { chunk ->
-            chunk.usedRegisters().regsTypes.forEach { (regNum, types) ->
-                types.forEach { dt ->
-                    addToUsage(usage, regNum, dt, chunk)
-                }
-            }
-        }
-
-        val registerReplacements = usage.asSequence()
-            .filter { it.value.size==1 }
-            .map { it.key to it.value.iterator().next() }
-            .groupBy({ it.second }, {it.first})
-            .asSequence()
-            .associate { (chunk, registers) ->
-                chunk to registers.withIndex().associate { (index, reg) -> reg to 50000+index }
-            }
-
-        registerReplacements.forEach { replaceRegisters(it.key, it.value) }
-    }
-
-    private fun replaceRegisters(chunk: IRCodeChunkBase, replacements: Map<Pair<Int, IRDataType>, Int>) {
-        val (rF, rI) = replacements.asSequence().partition { it.key.second==IRDataType.FLOAT }
-        val replacementsInt = rI.associate { it.key.first to it.value }
-        val replacementsFloat = rF.associate { it.key.first to it.value }
-
-        fun replaceRegs(fcallArgs: FunctionCallArgs?): FunctionCallArgs? {
-            if(fcallArgs==null)
-                return null
-            val args = if(fcallArgs.arguments.isEmpty()) fcallArgs.arguments else {
-                fcallArgs.arguments.map {
-                    FunctionCallArgs.ArgumentSpec(
-                        it.name,
-                        it.address,
-                        FunctionCallArgs.RegSpec(
-                            it.reg.dt,
-                            if(it.reg.dt==IRDataType.FLOAT)
-                                replacementsFloat.getOrDefault(it.reg.registerNum, it.reg.registerNum)
-                            else
-                                replacementsInt.getOrDefault(it.reg.registerNum, it.reg.registerNum),
-                            it.reg.cpuRegister
-                        )
-                    )
-                }
-            }
-            val rt = fcallArgs.returns
-            val returns = if(rt==null) null else {
-                FunctionCallArgs.RegSpec(
-                    rt.dt,
-                    if(rt.dt==IRDataType.FLOAT)
-                        replacementsFloat.getOrDefault(rt.registerNum, rt.registerNum)
-                    else
-                        replacementsInt.getOrDefault(rt.registerNum, rt.registerNum),
-                    rt.cpuRegister
-                )
-            }
-            return FunctionCallArgs(args, returns)
-        }
-
-        fun replaceRegs(instruction: IRInstruction): IRInstruction {
-            val reg1 = replacementsInt.getOrDefault(instruction.reg1, instruction.reg1)
-            val reg2 = replacementsInt.getOrDefault(instruction.reg2, instruction.reg2)
-            val fpReg1 = replacementsFloat.getOrDefault(instruction.fpReg1, instruction.fpReg1)
-            val fpReg2 = replacementsFloat.getOrDefault(instruction.fpReg2, instruction.fpReg2)
-            return instruction.copy(reg1 = reg1, reg2 = reg2, fpReg1 = fpReg1, fpReg2 = fpReg2, fcallArgs = replaceRegs(instruction.fcallArgs))
-        }
-        val newInstructions = chunk.instructions.map {
-            replaceRegs(it)
-        }
-        chunk.instructions.clear()
-        chunk.instructions.addAll(newInstructions)
-    }
-*/
-}

codeGenIntermediate/test/TestIRPeepholeOpt.kt

@@ -80,21 +80,52 @@ class TestIRPeepholeOpt: FunSpec({
         instr[1].opcode shouldBe Opcode.INC
     }
 
-    test("remove double sec/clc") {
+    test("remove double sec/clc/sei/cli") {
         val irProg = makeIRProgram(listOf(
             IRInstruction(Opcode.SEC),
             IRInstruction(Opcode.SEC),
             IRInstruction(Opcode.SEC),
             IRInstruction(Opcode.CLC),
             IRInstruction(Opcode.CLC),
-            IRInstruction(Opcode.CLC)
+            IRInstruction(Opcode.CLC),
+            IRInstruction(Opcode.SEI),
+            IRInstruction(Opcode.SEI),
+            IRInstruction(Opcode.SEI),
+            IRInstruction(Opcode.CLI),
+            IRInstruction(Opcode.CLI),
+            IRInstruction(Opcode.CLI),
         ))
-        irProg.chunks().single().instructions.size shouldBe 6
+        irProg.chunks().single().instructions.size shouldBe 12
         val opt = IRPeepholeOptimizer(irProg)
         opt.optimize(true, ErrorReporterForTests())
         val instr = irProg.chunks().single().instructions
-        instr.size shouldBe 1
+        instr.size shouldBe 2
         instr[0].opcode shouldBe Opcode.CLC
+        instr[1].opcode shouldBe Opcode.CLI
+    }
+
+    test("remove double sec/clc/sei/cli reversed") {
+        val irProg = makeIRProgram(listOf(
+            IRInstruction(Opcode.CLC),
+            IRInstruction(Opcode.CLC),
+            IRInstruction(Opcode.CLC),
+            IRInstruction(Opcode.SEC),
+            IRInstruction(Opcode.SEC),
+            IRInstruction(Opcode.SEC),
+            IRInstruction(Opcode.CLI),
+            IRInstruction(Opcode.CLI),
+            IRInstruction(Opcode.CLI),
+            IRInstruction(Opcode.SEI),
+            IRInstruction(Opcode.SEI),
+            IRInstruction(Opcode.SEI),
+        ))
+        irProg.chunks().single().instructions.size shouldBe 12
+        val opt = IRPeepholeOptimizer(irProg)
+        opt.optimize(true, ErrorReporterForTests())
+        val instr = irProg.chunks().single().instructions
+        instr.size shouldBe 2
+        instr[0].opcode shouldBe Opcode.SEC
+        instr[1].opcode shouldBe Opcode.SEI
     }
 
     test("push followed by pop") {

codeOptimizers/build.gradle

@@ -6,9 +6,8 @@ plugins {
 }
 
 java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(javaVersion)
-    }
+    targetCompatibility = JavaLanguageVersion.of(javaVersion)
+    sourceCompatibility = JavaLanguageVersion.of(javaVersion)
 }
 
 compileKotlin {
@@ -27,7 +26,7 @@ dependencies {
     implementation project(':codeCore')
     implementation project(':compilerAst')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.20"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.0"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
 }
 

codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -91,7 +91,7 @@ class ConstantFoldingOptimizer(private val program: Program, private val errors:
                         program.encoding.encodeString(leftString.value, leftString.encoding) + program.encoding.encodeString(rightString.value, rightString.encoding),
                         leftString.encoding)
                 }
-                val concatStr = StringLiteral(concatenated, leftString.encoding, expr.position)
+                val concatStr = StringLiteral.create(concatenated, leftString.encoding, expr.position)
                 return listOf(IAstModification.ReplaceNode(expr, concatStr, parent))
             }
             else if(expr.operator=="*" && rightconst!=null && expr.left is StringLiteral) {
@@ -99,7 +99,7 @@ class ConstantFoldingOptimizer(private val program: Program, private val errors:
                 val part = expr.left as StringLiteral
                 if(part.value.isEmpty())
                     errors.warn("resulting string has length zero", part.position)
-                val newStr = StringLiteral(part.value.repeat(rightconst.number.toInt()), part.encoding, expr.position)
+                val newStr = StringLiteral.create(part.value.repeat(rightconst.number.toInt()), part.encoding, expr.position)
                 return listOf(IAstModification.ReplaceNode(expr, newStr, parent))
             }
         }

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -154,11 +154,10 @@ class VarConstantValueTypeAdjuster(
         if(func==listOf("clamp")) {
             val t1 = functionCallExpr.args[0].inferType(program)
             if(t1.isKnown) {
-                val replaceFunc: String
-                if(t1.isBytes) {
-                    replaceFunc = if(t1.istype(DataType.BYTE)) "clamp__byte" else "clamp__ubyte"
+                val replaceFunc = if(t1.isBytes) {
+                    if(t1.istype(DataType.BYTE)) "clamp__byte" else "clamp__ubyte"
                 } else if(t1.isInteger) {
-                    replaceFunc = if(t1.istype(DataType.WORD)) "clamp__word" else "clamp__uword"
+                    if(t1.istype(DataType.WORD)) "clamp__word" else "clamp__uword"
                 } else {
                     errors.err("clamp builtin not supported for floats, use floats.clamp", functionCallExpr.position)
                     return noModifications

codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -14,9 +14,6 @@ import kotlin.math.log2
 import kotlin.math.pow
 
 class ExpressionSimplifier(private val program: Program, private val options: CompilationOptions, private val errors: IErrorReporter) : AstWalker() {
-    private val powersOfTwo = (1..16).map { (2.0).pow(it) }.toSet()
-    private val negativePowersOfTwo = powersOfTwo.map { -it }.toSet()
-
     override fun after(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> {
         val mods = mutableListOf<IAstModification>()
 
@@ -104,7 +101,7 @@ class ExpressionSimplifier(private val program: Program, private val options: Co
         val leftIDt = expr.left.inferType(program)
         val rightIDt = expr.right.inferType(program)
         if (!leftIDt.isKnown || !rightIDt.isKnown)
-            throw FatalAstException("can't determine datatype of both expression operands $expr")
+            return noModifications
 
         // X + (-A)  -->  X - A
         if (expr.operator == "+" && (expr.right as? PrefixExpression)?.operator == "-") {
@@ -686,7 +683,7 @@ class ExpressionSimplifier(private val program: Program, private val options: Co
                     if(!idt.isKnown)
                         throw FatalAstException("unknown dt")
                     return NumericLiteral(idt.getOr(DataType.UNDEFINED), 0.0, expr.position)
-                } else if (cv in powersOfTwo) {
+                } else if (cv in powersOfTwoFloat) {
                     expr.operator = "&"
                     expr.right = NumericLiteral.optimalInteger(cv!!.toInt()-1, expr.position)
                     return null
@@ -711,6 +708,7 @@ class ExpressionSimplifier(private val program: Program, private val options: Co
                 return null
             val leftDt = leftIDt.getOr(DataType.UNDEFINED)
             when (cv) {
+                0.0 -> return null // fall through to regular float division to properly deal with division by zero
                 -1.0 -> {
                     //  '/' -> -left
                     if (expr.operator == "/") {
@@ -738,12 +736,10 @@ class ExpressionSimplifier(private val program: Program, private val options: Co
                         else -> return null
                     }
                 }
-                in powersOfTwo -> {
-                    if (leftDt==DataType.UBYTE || leftDt==DataType.UWORD) {
-                        // Unsigned number divided by a power of two => shift right
-                        // Signed number can't simply be bitshifted in this case (due to rounding issues for negative values),
-                        // so we leave that as is and let the code generator deal with it.
-                        val numshifts = log2(cv).toInt()
+                in powersOfTwoFloat -> {
+                    val numshifts = powersOfTwoFloat.indexOf(cv)
+                    if (leftDt in IntegerDatatypes) {
+                        // division by a power of two => shift right (signed and unsigned)
                         return BinaryExpression(expr.left, ">>", NumericLiteral.optimalInteger(numshifts, expr.position), expr.position)
                     }
                 }
@@ -795,14 +791,14 @@ class ExpressionSimplifier(private val program: Program, private val options: Co
                     // left
                     return expr2.left
                 }
-                in powersOfTwo -> {
+                in powersOfTwoFloat -> {
                     if (leftValue.inferType(program).isInteger) {
                         // times a power of two => shift left
                         val numshifts = log2(cv).toInt()
                         return BinaryExpression(expr2.left, "<<", NumericLiteral.optimalInteger(numshifts, expr.position), expr.position)
                     }
                 }
-                in negativePowersOfTwo -> {
+                in negativePowersOfTwoFloat -> {
                     if (leftValue.inferType(program).isInteger) {
                         // times a negative power of two => negate, then shift
                         val numshifts = log2(-cv).toInt()

codeOptimizers/src/prog8/optimizer/Inliner.kt

@@ -30,11 +30,11 @@ class Inliner(private val program: Program, private val options: CompilationOpti
         }
 
         override fun visit(subroutine: Subroutine) {
-            if(!subroutine.isAsmSubroutine && !subroutine.inline && subroutine.parameters.isEmpty()) {
-                val containsSubsOrVariables = subroutine.statements.any { it is VarDecl || it is Subroutine}
-                if(!containsSubsOrVariables) {
-                    if(subroutine.statements.size==1 || (subroutine.statements.size==2 && isEmptyReturn(subroutine.statements[1]))) {
-                        if(subroutine !== program.entrypoint) {
+            if (!subroutine.isAsmSubroutine && !subroutine.inline && subroutine.parameters.isEmpty()) {
+                val containsSubsOrVariables = subroutine.statements.any { it is VarDecl || it is Subroutine }
+                if (!containsSubsOrVariables) {
+                    if (subroutine.statements.size == 1 || (subroutine.statements.size == 2 && isEmptyReturn(subroutine.statements[1]))) {
+                        if (subroutine !== program.entrypoint) {
                             // subroutine is possible candidate to be inlined
                             subroutine.inline =
                                 when (val stmt = subroutine.statements[0]) {
@@ -87,9 +87,9 @@ class Inliner(private val program: Program, private val options: CompilationOpti
                                                 } else
                                                     false
                                             targetInline || valueInline
-                                        } else if(stmt.target.identifier!=null && stmt.isAugmentable) {
+                                        } else if (stmt.target.identifier != null && stmt.isAugmentable) {
                                             val binExpr = stmt.value as BinaryExpression
-                                            if(binExpr.operator in "+-" && binExpr.right.constValue(program)?.number==1.0) {
+                                            if (binExpr.operator in "+-" && binExpr.right.constValue(program)?.number == 1.0) {
                                                 makeFullyScoped(stmt.target.identifier!!)
                                                 makeFullyScoped(binExpr.left as IdentifierReference)
                                                 true
@@ -121,8 +121,8 @@ class Inliner(private val program: Program, private val options: CompilationOpti
                         }
                     }
 
-                    if(subroutine.inline && subroutine.statements.size>1) {
-                        require(subroutine.statements.size==2 && isEmptyReturn(subroutine.statements[1]))
+                    if (subroutine.inline && subroutine.statements.size > 1) {
+                        require(subroutine.statements.size == 2 && isEmptyReturn(subroutine.statements[1]))
                         subroutine.statements.removeLast()      // get rid of the Return, to be able to inline the (single) statement preceding it.
                     }
                 }
@@ -147,6 +147,7 @@ class Inliner(private val program: Program, private val options: CompilationOpti
         }
 
         private fun makeFullyScoped(call: FunctionCallStatement) {
+            makeFullyScoped(call.target)
             call.target.targetSubroutine(program)?.let { sub ->
                 val scopedName = IdentifierReference(sub.scopedName, call.target.position)
                 val scopedArgs = makeScopedArgs(call.args)
@@ -169,6 +170,7 @@ class Inliner(private val program: Program, private val options: CompilationOpti
         }
 
         private fun makeFullyScoped(call: FunctionCallExpression) {
+            makeFullyScoped(call.target)
             call.target.targetSubroutine(program)?.let { sub ->
                 val scopedName = IdentifierReference(sub.scopedName, call.target.position)
                 val scopedArgs = makeScopedArgs(call.args)

codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt

@@ -21,7 +21,8 @@ class StatementOptimizer(private val program: Program,
         if(functionCallStatement.target.nameInSource.size==1) {
             val functionName = functionCallStatement.target.nameInSource[0]
             if (functionName in functions.purefunctionNames) {
-                errors.warn("statement has no effect (function return value is discarded)", functionCallStatement.position)
+                if("ignore_unused" !in parent.definingBlock.options())
+                    errors.warn("statement has no effect (function return value is discarded)", functionCallStatement.position)
                 return listOf(IAstModification.Remove(functionCallStatement, parent as IStatementContainer))
             }
         }

codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -149,7 +149,8 @@ class UnusedCodeRemover(private val program: Program,
                                         val declIndex = (parent as IStatementContainer).statements.indexOf(decl)
                                         val singleUseIndex = (parent as IStatementContainer).statements.indexOf(singleUse.parent)
                                         if(declIndex==singleUseIndex-1) {
-                                            errors.info("replaced unused variable '${decl.name}' with void call, maybe this can be removed altogether", decl.position)
+                                            if("ignore_unused" !in decl.definingBlock.options())
+                                                errors.info("replaced unused variable '${decl.name}' with void call, maybe this can be removed altogether", decl.position)
                                             val fcall = assignment.value as IFunctionCall
                                             val voidCall = FunctionCallStatement(fcall.target, fcall.args, true, fcall.position)
                                             return listOf(

compiler/build.gradle

@@ -2,14 +2,14 @@ plugins {
     id 'java'
     id 'application'
     id 'org.jetbrains.kotlin.jvm'
-    id 'com.github.johnrengelman.shadow' version '8.1.1'
+    // id 'com.github.johnrengelman.shadow' version '8.1.1'
+    id 'io.github.goooler.shadow' version '8.1.7'
     id 'com.peterabeles.gversion' version '1.10.2'
 }
 
 java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(javaVersion)
-    }
+    targetCompatibility = JavaLanguageVersion.of(javaVersion)
+    sourceCompatibility = JavaLanguageVersion.of(javaVersion)
 }
 
 compileKotlin {
@@ -32,15 +32,15 @@ dependencies {
     implementation project(':codeGenIntermediate')
     implementation project(':codeGenExperimental')
     implementation project(':virtualmachine')
-    implementation "org.antlr:antlr4-runtime:4.13.1"
+    implementation "org.antlr:antlr4-runtime:4.13.2"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
     implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.6'
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.20"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.0"
 
     testImplementation project(':codeCore')
     testImplementation project(':intermediate')
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.9.1'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 

compiler/res/prog8lib/anyall.p8

@@ -0,0 +1,82 @@
+; any() and all()  checks on arrays/memory buffers.
+; These were builtin functions in older versions of the language.
+
+%option no_symbol_prefixing, ignore_unused
+
+anyall {
+    sub any(uword arrayptr, uword num_elements) -> bool {
+        ; -- returns true if any byte in the array is not zero.
+        cx16.r1 = arrayptr
+        if msb(num_elements)==0 {
+            for cx16.r0L in 0 to lsb(num_elements)-1 {
+                if cx16.r1[cx16.r0L]!=0
+                    return true
+            }
+            return false
+        }
+        repeat num_elements {
+            if @(cx16.r1)!=0
+                return true
+            cx16.r1++
+        }
+        return false
+    }
+
+    sub all(uword arrayptr, uword num_elements) -> bool {
+        ; -- returns true if all bytes in the array are not zero.
+        cx16.r1 = arrayptr
+        if msb(num_elements)==0 {
+            for cx16.r0L in 0 to lsb(num_elements)-1 {
+                if cx16.r1[cx16.r0L]==0
+                    return false
+            }
+            return true
+        }
+        repeat num_elements {
+            if @(cx16.r1)==0
+                return false
+            cx16.r1++
+        }
+        return true
+    }
+
+    sub anyw(uword arrayptr, uword num_elements) -> bool {
+        ; -- returns true if any word in the array is not zero.
+        ;    doesn't work on @split arrays.
+        cx16.r1 = arrayptr
+        if msb(num_elements)==0 {
+            repeat lsb(num_elements) {
+                if peekw(cx16.r1)!=0
+                    return true
+                cx16.r1+=2
+            }
+            return false
+        }
+        repeat num_elements {
+            if peekw(cx16.r1)!=0
+                return true
+            cx16.r1+=2
+        }
+        return false
+    }
+
+    sub allw(uword arrayptr, uword num_elements) -> bool {
+        ; -- returns true if all words in the array are not zero.
+        ;    doesn't work on @split arrays.
+        cx16.r1 = arrayptr
+        if msb(num_elements)==0 {
+            repeat lsb(num_elements) {
+                if peekw(cx16.r1)==0
+                    return false
+                cx16.r1+=2
+            }
+            return true
+        }
+        repeat num_elements {
+            if peekw(cx16.r1)==0
+                return false
+            cx16.r1+=2
+        }
+        return true
+    }
+}

compiler/res/prog8lib/buffers.p8

@@ -0,0 +1,152 @@
+; experimental buffer data structures
+
+%option no_symbol_prefixing, ignore_unused
+
+smallringbuffer {
+    ; -- A ringbuffer (FIFO queue) that occupies a single page in memory, containing 255 bytes maximum.
+    ;    You can store and retrieve words too.
+    ;    It's optimized for speed and depends on the byte-wrap-around feature when doing incs and decs.
+
+    ubyte fill
+    ubyte head
+    ubyte tail
+    ubyte[256] buffer
+
+    sub init() {
+        ; -- (re)initialize the ringbuffer, you must call this before using the other routines
+        head = fill = 0
+        tail = 255
+    }
+
+    sub put(ubyte value) -> bool {
+        ; -- store a byte in the buffer, returns success
+        if fill==255
+            return false
+        buffer[head] = value
+        head++
+        fill++
+        return true
+    }
+
+    sub putw(uword value) -> bool {
+        ; -- store a word in the buffer, returns success
+        if fill>=254
+            return false
+        fill += 2
+        buffer[head] = lsb(value)
+        head++
+        buffer[head] = msb(value)
+        head++
+        return true
+    }
+
+    sub get() -> ubyte {
+        ; -- retrieves a byte from the buffer. Also sets Carry flag: set=success, clear=buffer was empty
+        if fill==0 {
+            sys.clear_carry()
+            return 0
+        }
+        fill--
+        tail++
+        sys.set_carry()
+        return buffer[tail]
+    }
+
+    sub getw() -> uword {
+        ; -- retrieves a word from the buffer. Also sets Carry flag: set=success, clear=buffer was empty
+        if fill<2 {
+            sys.clear_carry()
+            return 0
+        }
+        fill -= 2
+        tail++
+        cx16.r0L = buffer[tail]
+        tail++
+        cx16.r0H = buffer[tail]
+        sys.set_carry()
+        return cx16.r0
+    }
+}
+
+
+ringbuffer {
+    ; -- A ringbuffer (FIFO queue) that occupies a single page in memory, containing 8 KB maximum.
+    ;    You can store and retrieve words too.
+
+    uword fill
+    uword head
+    uword tail
+    uword buffer_ptr = memory("ringbuffer", 8192, 0)
+
+    sub init() {
+        ; -- (re)initialize the ringbuffer, you must call this before using the other routines
+        head = fill = 0
+        tail = 8191
+    }
+
+    sub put(ubyte value) -> bool {
+        ; -- store a byte in the buffer, returns success
+        if fill==8192
+            return false
+        buffer_ptr[head] = value
+        inc_head()
+        fill++
+        return true
+    }
+
+    sub putw(uword value) -> bool {
+        ; -- store a word in the buffer, returns success
+        if fill>=8191
+            return false
+        fill += 2
+        buffer_ptr[head] = lsb(value)
+        inc_head()
+        buffer_ptr[head] = msb(value)
+        inc_head()
+        return true
+    }
+
+    sub get() -> ubyte {
+        ; -- retrieves a byte from the buffer. Also sets Carry flag: set=success, clear=buffer was empty
+        if fill==0 {
+            sys.clear_carry()
+            return 0
+        }
+        fill--
+        inc_tail()
+        cx16.r0L = buffer_ptr[tail]
+        sys.set_carry()
+        return cx16.r0L
+    }
+
+    sub getw() -> uword {
+        ; -- retrieves a word from the buffer. Also sets Carry flag: set=success, clear=buffer was empty
+        if fill<2 {
+            sys.clear_carry()
+            return 0
+        }
+        fill -= 2
+        inc_tail()
+        cx16.r0L = buffer_ptr[tail]
+        inc_tail()
+        cx16.r0H = buffer_ptr[tail]
+        sys.set_carry()
+        return cx16.r0
+    }
+
+    sub inc_head() {
+        head++
+        if msb(head)==$20
+            head=0
+    }
+
+    sub inc_tail() {
+        tail++
+        if msb(tail)==$20
+            tail=0
+    }
+}
+
+
+; TODO ringbuffer (FIFO queue) should use banked ram on the X16, but still work on virtual
+; TODO stack (LIFO queue) using more than 1 page of ram (maybe even banked ram on the x16)

compiler/res/prog8lib/c64/floats_funcs.asm

@@ -6,108 +6,6 @@ func_sign_f_into_A	.proc
 		jmp  SIGN
 		.pend
 
-func_swap_f	.proc
-		; -- swap floats pointed to by SCRATCH_ZPWORD1, SCRATCH_ZPWORD2
-		ldy  #4
--               lda  (P8ZP_SCRATCH_W1),y
-		pha
-		lda  (P8ZP_SCRATCH_W2),y
-		sta  (P8ZP_SCRATCH_W1),y
-		pla
-		sta  (P8ZP_SCRATCH_W2),y
-		dey
-		bpl  -
-		rts
-		.pend
-
-func_reverse_f	.proc
-		; --- reverse an array of floats (array in P8ZP_SCRATCH_W1, num elements in A)
-_left_index = P8ZP_SCRATCH_W2
-_right_index = P8ZP_SCRATCH_W2+1
-_loop_count = P8ZP_SCRATCH_REG
-		pha
-		jsr  a_times_5
-		sec
-		sbc  #5
-		sta  _right_index
-		lda  #0
-		sta  _left_index
-		pla
-		lsr  a
-		sta  _loop_count
-_loop		; push the left indexed float on the stack
-		ldy  _left_index
-		lda  (P8ZP_SCRATCH_W1),y
-		pha
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		pha
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		pha
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		pha
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		pha
-		; copy right index float to left index float
-		ldy  _right_index
-		lda  (P8ZP_SCRATCH_W1),y
-		ldy  _left_index
-		sta  (P8ZP_SCRATCH_W1),y
-		inc  _left_index
-		inc  _right_index
-		ldy  _right_index
-		lda  (P8ZP_SCRATCH_W1),y
-		ldy  _left_index
-		sta  (P8ZP_SCRATCH_W1),y
-		inc  _left_index
-		inc  _right_index
-		ldy  _right_index
-		lda  (P8ZP_SCRATCH_W1),y
-		ldy  _left_index
-		sta  (P8ZP_SCRATCH_W1),y
-		inc  _left_index
-		inc  _right_index
-		ldy  _right_index
-		lda  (P8ZP_SCRATCH_W1),y
-		ldy  _left_index
-		sta  (P8ZP_SCRATCH_W1),y
-		inc  _left_index
-		inc  _right_index
-		ldy  _right_index
-		lda  (P8ZP_SCRATCH_W1),y
-		ldy  _left_index
-		sta  (P8ZP_SCRATCH_W1),y
-		; pop the float off the stack into the right index float
-		ldy  _right_index
-		pla
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		pla
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		pla
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		pla
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		pla
-		sta  (P8ZP_SCRATCH_W1),y
-		inc  _left_index
-		lda  _right_index
-		sec
-		sbc  #9
-		sta  _right_index
-		dec  _loop_count
-		bne  _loop
-		rts
-
-		.pend
-
-
 
 a_times_5	.proc
 		sta  P8ZP_SCRATCH_B1
@@ -118,26 +16,6 @@ a_times_5	.proc
 		rts
 		.pend
 
-func_any_f_into_A	.proc
-		jsr  a_times_5
-		jmp  prog8_lib.func_any_b_into_A
-		.pend
-
-func_all_f_into_A	.proc
-		jsr  a_times_5
-		jmp  prog8_lib.func_all_b_into_A
-		.pend
-
-func_any_f_stack	.proc
-		jsr  a_times_5
-		jmp  prog8_lib.func_any_b_stack
-		.pend
-
-func_all_f_stack	.proc
-		jsr  a_times_5
-		jmp  prog8_lib.func_all_b_stack
-		.pend
-
 func_abs_f_into_FAC1    .proc
         jsr  MOVFM
         jmp  ABS

compiler/res/prog8lib/conv.p8

@@ -517,16 +517,16 @@ _stop
 
 asmsub internal_ubyte2decimal(ubyte value @A) -> ubyte @Y, ubyte @X, ubyte @A {
     %asm {{
-        ldy #'0'-1
-        ldx #'9'+1
+        ldy  #'0'-1
+        ldx  #'9'+1
         sec
 -       iny
-        sbc #100
-        bcs -
+        sbc  #100
+        bcs  -
 -       dex
-        adc #10
-        bmi -
-        adc #'0'-1
+        adc  #10
+        bmi  -
+        adc  #'0'-1
         rts
     }}
 }

compiler/res/prog8lib/cx16/diskio.p8

@@ -379,6 +379,7 @@ m_in_buffer     sta  $ffff
     ; optimized for Commander X16 to use MACPTR block read kernal call
     sub f_read_all(uword bufferpointer) -> uword {
         ; -- read the full contents of the file, returns number of bytes read.
+        ;    It is assumed the file size is less than 64 K.
         ;    NOTE: cannot be used to load into VRAM.  Use vload() or call cx16.MACPTR() yourself with the vera data register as address.
         if not iteration_in_progress
             return 0
@@ -393,12 +394,12 @@ m_in_buffer     sta  $ffff
         return total_read
     }
 
-    asmsub f_readline(uword bufptr @AY) clobbers(X) -> ubyte @Y {
+    asmsub f_readline(uword bufptr @AY) clobbers(X) -> ubyte @Y, ubyte @A {
         ; Routine to read text lines from a text file. Lines must be less than 255 characters.
         ; Reads characters from the input file UNTIL a newline or return character (or EOF).
         ; The line read will be 0-terminated in the buffer (and not contain the end of line character).
         ; The length of the line is returned in Y. Note that an empty line is okay and is length 0!
-        ; I/O error status should be checked by the caller itself via READST() routine.
+        ; The I/O error status byte is returned in A.
         %asm {{
             sta  P8ZP_SCRATCH_W1
             sty  P8ZP_SCRATCH_W1+1
@@ -415,7 +416,8 @@ _loop       jsr  cbm.CHRIN
 _line_end   dey     ; get rid of the trailing end-of-line char
             lda  #0
             sta  (P8ZP_SCRATCH_W1),y
-_end        rts
+_end        jsr  cbm.READST
+            rts
         }}
     }
 
@@ -467,6 +469,7 @@ _end        rts
 
     sub f_write(uword bufferpointer, uword num_bytes) -> bool {
         ; -- write the given number of bytes to the currently open file
+        ;    you can call this multiple times to append more data
         if num_bytes!=0 {
             reset_write_channel()
             do {
@@ -688,7 +691,7 @@ io_error:
     }
 
     sub send_command(uword commandptr) {
-        ; -- send a dos command to the drive
+        ; -- send a dos command to the drive (don't read any response)
         cbm.SETNAM(string.length(commandptr), commandptr)
         cbm.SETLFS(15, drivenumber, 15)
         void cbm.OPEN()
@@ -863,13 +866,13 @@ io_error:
 
     sub f_seek(uword pos_hiword, uword pos_loword) {
         ; -- seek in the reading file opened with f_open, to the given 32-bits position
+        ;    Note: this will not work if you have already read the last byte of the file! Then you must close and reopen the file first.
         ubyte[6] command = ['p',0,0,0,0,0]
         command[1] = READ_IO_CHANNEL       ; f_open uses this secondary address
         command[2] = lsb(pos_loword)
         command[3] = msb(pos_loword)
         command[4] = lsb(pos_hiword)
         command[5] = msb(pos_hiword)
-    send_command:
         cbm.SETNAM(sizeof(command), &command)
         cbm.SETLFS(15, drivenumber, 15)
         void cbm.OPEN()
@@ -892,4 +895,55 @@ io_error:
         reset_write_channel()    ; back to the write io channel
     }
 
+    asmsub f_tell() -> uword @R0, uword @R1, uword @R2, uword @R3 {
+        ; -- Returns the current read position of the opened read file,
+        ;    in R0 and R1 (low + high words) and the file size in R2 and R3 (low + high words).
+        ;    Returns 0 as size if the command is not supported by the DOS implementation/version.
+        %asm {{
+            jmp  internal_f_tell
+        }}
+    }
+
+    sub internal_f_tell() {
+        ; gets the (32 bits) position + file size of the opened read file channel
+        ubyte[2] command = ['t',0]
+        command[1] = READ_IO_CHANNEL       ; f_open uses this secondary address
+        cbm.SETNAM(sizeof(command), &command)
+        cbm.SETLFS(15, drivenumber, 15)
+        void cbm.OPEN()
+        void cbm.CHKIN(15)        ; use #15 as input channel
+        bool success=false
+        ; valid response starts with "07," followed by hex notations of the position and filesize
+        if cbm.CHRIN()=='0' and cbm.CHRIN()=='7' and cbm.CHRIN()==',' {
+            cx16.r1 = read4hex()
+            cx16.r0 = read4hex()        ; position in R1:R0
+            void cbm.CHRIN()            ; separator space
+            cx16.r3 = read4hex()
+            cx16.r2 = read4hex()        ; filesize in R3:R2
+            success = true
+        }
+
+        while cbm.READST()==0 {
+            cx16.r5L = cbm.CHRIN()
+            if cx16.r5L=='\r' or cx16.r5L=='\n'
+                break
+        }
+
+        cbm.CLOSE(15)
+        reset_read_channel()       ; back to the read io channel
+        if success
+            return
+
+        cx16.r0 = cx16.r1 = cx16.r2 = cx16.r3 = 0
+
+        sub read4hex() -> uword {
+            str hex = "0000"
+            hex[0] = cbm.CHRIN()
+            hex[1] = cbm.CHRIN()
+            hex[2] = cbm.CHRIN()
+            hex[3] = cbm.CHRIN()
+            return conv.hex2uword(hex)
+        }
+    }
+
 }

compiler/res/prog8lib/cx16/gfx2.p8

@@ -13,6 +13,7 @@
 ; NOTE: For sake of speed, NO BOUNDS CHECKING is performed in most routines!
 ;       You'll have to make sure yourself that you're not writing outside of bitmap boundaries!
 ;
+; NOTE: the bitmap screen data is positioned in vram at $0:0000
 ;
 ; SCREEN MODE LIST:
 ;   mode 0 = reset back to default text mode
@@ -254,6 +255,7 @@ gfx2 {
                 ;; color <<= gfx2.plot.shift4c[lsb(xx) & 3]
                 cx16.r2L = lsb(xx) & 3
                 when color & 3 {
+                    0 -> color = 0
                     1 -> color = gfx2.plot.shiftedleft_4c_1[cx16.r2L]
                     2 -> color = gfx2.plot.shiftedleft_4c_2[cx16.r2L]
                     3 -> color = gfx2.plot.shiftedleft_4c_3[cx16.r2L]
@@ -272,10 +274,10 @@ gfx2 {
 
         sub set_both_strides(ubyte stride) {
             stride <<= 4
-            cx16.VERA_CTRL = 0
-            cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & %00000111 | stride
             cx16.VERA_CTRL = 1
             cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & %00000111 | stride
+            cx16.VERA_CTRL = 0
+            cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & %00000111 | stride
         }
 
     }
@@ -547,6 +549,7 @@ gfx2 {
                 ; color &= 3
                 ; color <<= shift4c[cx16.r2L]
                 when color & 3 {
+                    0 -> color = 0
                     1 -> color = shiftedleft_4c_1[cx16.r2L]
                     2 -> color = shiftedleft_4c_2[cx16.r2L]
                     3 -> color = shiftedleft_4c_3[cx16.r2L]
@@ -626,10 +629,18 @@ gfx2 {
     }
 
     sub fill(uword x, uword y, ubyte new_color) {
+        ; reuse a few virtual registers in ZP for variables
+        &ubyte fillm = &cx16.r7L
+        &ubyte seedm = &cx16.r8L
+        &ubyte cmask = &cx16.r8H
+        &ubyte vub   = &cx16.r13L
+        &ubyte nvub  = &cx16.r13H
+        ubyte[4] amask = [$c0,$30,$0c,$03] ; array of cmask bytes
+
         ; Non-recursive scanline flood fill.
         ; based loosely on code found here https://www.codeproject.com/Articles/6017/QuickFill-An-efficient-flood-fill-algorithm
         ; with the fixes applied to the seedfill_4 routine as mentioned in the comments.
-        const ubyte MAXDEPTH = 64
+        const ubyte MAXDEPTH = 100
         word @zp xx = x as word
         word @zp yy = y as word
         word[MAXDEPTH] @split @shared stack_xl
@@ -641,6 +652,7 @@ gfx2 {
         word x2
         byte dy
         cx16.r10L = new_color
+
         sub push_stack(word sxl, word sxr, word sy, byte sdy) {
             if cx16.r12L==MAXDEPTH
                 return
@@ -704,39 +716,27 @@ gfx2 {
             return
         if xx<0 or xx>width-1 or yy<0 or yy>height-1
             return
+        if gfx2.active_mode == 2 set_color_masks()
         push_stack(xx, xx, yy, 1)
         push_stack(xx, xx, yy + 1, -1)
         word left = 0
         while cx16.r12L!=0 {
             pop_stack()
             xx = x1
-            ; possible speed optimization: if mode==1 (256c) use vera autodecrement instead of pget(), but code bloat not worth it?
-            while xx >= 0 {
-                if pget(xx as uword, yy as uword) != cx16.r11L
-                    break
-                xx--
+            when active_mode {
+                1 -> if fill_scanline_left_8bpp() goto skip
+                2 -> if fill_scanline_left_2bpp() goto skip
             }
-            if x1!=xx
-                horizontal_line(xx as uword+1, yy as uword, x1-xx as uword, cx16.r10L)
-            else
-                goto skip
-
             left = xx + 1
             if left < x1
                 push_stack(left, x1 - 1, yy, -dy)
             xx = x1 + 1
 
             do {
-                cx16.r9s = xx
-                ; possible speed optimization: if mode==1 (256c) use vera autoincrement instead of pget(), but code bloat not worth it?
-                while xx <= width-1 {
-                    if pget(xx as uword, yy as uword) != cx16.r11L
-                        break
-                    xx++
+                when active_mode {
+                    1 -> fill_scanline_right_8bpp()
+                    2 -> fill_scanline_right_2bpp()
                 }
-                if cx16.r9s!=xx
-                    horizontal_line(cx16.r9, yy as uword, xx-cx16.r9s as uword, cx16.r10L)
-
                 push_stack(left, xx - 1, yy, dy)
                 if xx > x2 + 1
                     push_stack(x2 + 1, xx - 1, yy, -dy)
@@ -750,6 +750,132 @@ skip:
                 left = xx
             } until xx>x2
         }
+
+        sub set_vera_address() {
+            ; set both data0 and data1 addresses (expects H in R1L, M/L in R0)
+            cx16.VERA_CTRL = 0
+            cx16.VERA_ADDR_H = cx16.r1L
+            cx16.VERA_ADDR = cx16.r0
+            cx16.VERA_CTRL = 1
+            cx16.VERA_ADDR_H = cx16.r1L
+            cx16.VERA_ADDR = cx16.r0
+        }
+
+        sub fill_scanline_left_8bpp() -> bool {
+            void addr_mul_24_for_lores_256c(yy as uword, xx as uword)      ; 24 bits result is in r0 and r1L (highest byte)
+            cx16.r1L |= %00011000     ; auto decrement enabled
+            set_vera_address()
+            cx16.r9s = xx
+            while xx >= 0 {
+                if cx16.VERA_DATA0 != cx16.r11L
+                    break
+                cx16.VERA_DATA1 = cx16.r10L
+                xx--
+            }
+            return xx==cx16.r9s
+        }
+
+        sub fill_scanline_right_8bpp() {
+            void addr_mul_24_for_lores_256c(yy as uword, xx as uword)      ; 24 bits result is in r0 and r1L (highest byte)
+            cx16.r1L |= %00010000    ; auto increment enabled
+            set_vera_address()
+            while xx <= width-1 {
+                if cx16.VERA_DATA0 != cx16.r11L
+                    break
+                cx16.VERA_DATA1 = cx16.r10L
+                xx++
+            }
+        }
+
+        sub fill_scanline_left_2bpp() -> bool {
+            uword vx = xx as uword
+            void gfx2.addr_mul_24_for_highres_4c(yy as uword,vx)
+            cx16.r1L |= %0001_1000  ; auto decrement
+            set_vera_address()
+            cmask = amask[lsb(vx) & 3]  ; set the color mask for the first color pel
+
+            repeat {
+                vub = cx16.VERA_DATA0  ; read the VERA color data for 4 pixels
+                if cmask == $03 {     ; only speed fill from far right
+                    ; speed fill
+                    if vub == seedm { ; all four colors match the seed
+                        nvub = fillm  ; replace all four colors at once
+                        xx -= 4
+                        goto set_byte  ; go on
+                    }
+                }
+
+                ; replace one color at a time
+                nvub = vub
+                while cmask != 0 {
+                    if vub & cmask == seedm & cmask {
+                        nvub &= ~cmask
+                        nvub |= cmask & fillm
+;                        %asm{{
+;                            lda  p8v_cmask
+;                            trb  p8v_nvub
+;                            and  p8v_fillm
+;                            tsb  p8v_nvub
+;                        }}
+                        xx--
+                        cmask <<= 2
+                    } else { ; not the seed color, finish here
+                        cx16.VERA_DATA1 = nvub
+                        return vx == xx
+                    }
+                }
+set_byte:
+                cx16.VERA_DATA1 = nvub
+                if xx <= 0 break
+                cmask = $03
+            }
+            return vx == xx
+        }
+
+        sub fill_scanline_right_2bpp() {
+            void gfx2.addr_mul_24_for_highres_4c(yy as uword,xx as uword)
+            cx16.r1L |= %00010000    ; auto increment
+            set_vera_address()
+            cmask = amask[lsb(xx) & 3]  ; set the color mask for the first color pel
+
+            repeat {
+                vub = cx16.VERA_DATA0  ; read the VERA color data for 4 pixels
+                ; speed fill
+                if vub == seedm { ; all four colors match the seed
+                    nvub = fillm  ; replace all four colors at once
+                    xx += 4
+                    goto set_byte   ; go on
+                }
+                ; replace one color at a time
+                nvub = vub
+                while cmask != 0 {
+                    if vub & cmask == seedm & cmask {
+                        nvub &= ~cmask
+                        nvub |= cmask & fillm
+;                        %asm{{
+;                            lda  p8v_cmask
+;                            trb  p8v_nvub
+;                            and  p8v_fillm
+;                            tsb  p8v_nvub
+;                        }}
+                        xx++
+                        cmask >>= 2
+                    } else { ; not the seed color finish here
+                        cx16.VERA_DATA1 = nvub
+                        return
+                    }
+                }
+set_byte:
+                cx16.VERA_DATA1 = nvub
+                if xx >= gfx2.width-1 break
+                cmask = $C0
+            }
+        }
+
+        sub set_color_masks() {
+            seedm = cx16.r11L | (cx16.r11L<<2) | (cx16.r11L<<4) | (cx16.r11L<<6) ; seed mask
+            fillm = cx16.r10L | (cx16.r10L<<2) | (cx16.r10L<<4) | (cx16.r10L<<6) ; fill mask
+        }
     }
 
     sub position(uword @zp xx, uword yy) {

compiler/res/prog8lib/cx16/monogfx.p8

@@ -358,10 +358,10 @@ drawmode:               ora  cx16.r15L
 
         sub set_both_strides(ubyte stride) {
             stride <<= 4
-            cx16.VERA_CTRL = 0
-            cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & %00000111 | stride
             cx16.VERA_CTRL = 1
             cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & %00000111 | stride
+            cx16.VERA_CTRL = 0
+            cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & %00000111 | stride
         }
 
     }
@@ -708,7 +708,7 @@ invert:
         ; Non-recursive scanline flood fill.
         ; based loosely on code found here https://www.codeproject.com/Articles/6017/QuickFill-An-efficient-flood-fill-algorithm
         ; with the fixes applied to the seedfill_4 routine as mentioned in the comments.
-        const ubyte MAXDEPTH = 64
+        const ubyte MAXDEPTH = 100
         word @zp xx = x as word
         word @zp yy = y as word
         word[MAXDEPTH] @split @shared stack_xl
@@ -957,15 +957,15 @@ cdraw_mod2              ora  cx16.VERA_DATA1
         sub set_autoincrs() {
             ; set autoincrements to go to next pixel row (40 or 80 increment)
             if width==320 {
-                cx16.VERA_CTRL = 0
-                cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & $0f | (11<<4)
                 cx16.VERA_CTRL = 1
                 cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & $0f | (11<<4)
+                cx16.VERA_CTRL = 0
+                cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & $0f | (11<<4)
             } else {
-                cx16.VERA_CTRL = 0
-                cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & $0f | (12<<4)
                 cx16.VERA_CTRL = 1
                 cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & $0f | (12<<4)
+                cx16.VERA_CTRL = 0
+                cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & $0f | (12<<4)
             }
         }
     }

compiler/res/prog8lib/cx16/sprites.p8

@@ -42,9 +42,15 @@ sprites {
         cx16.vpoke_mask(1, sprite_reg+1, %11110000, msb(addr))    ; address 16:13
     }
 
-    sub get_data_ptr(ubyte spritenum) {
+    inline asmsub get_data_ptr(ubyte spritenum @A) -> ubyte @R1, uword @R0 {
         ; -- returns the VRAM address where the sprite's bitmap data is stored
         ;    R1 (byte) = the vera bank (0 or 1), R0 (word) = the address.
+        %asm {{
+            jsr  p8b_sprites.p8s_get_data_ptr_internal
+        }}
+    }
+
+    sub get_data_ptr_internal(ubyte spritenum) {
         sprite_reg = VERA_SPRITEREGS + spritenum*$0008
         cx16.r0L = cx16.vpeek(1, sprite_reg)
         cx16.r0H = cx16.vpeek(1, sprite_reg+1)
@@ -176,7 +182,7 @@ sprites {
     }
 
     sub set_mousepointer_image(uword data, bool compressed) {
-        get_data_ptr(0)  ; the mouse cursor is sprite 0
+        get_data_ptr_internal(0)  ; the mouse cursor is sprite 0
         if cx16.r1L==0 and cx16.r0==0
             return    ; mouse cursor not enabled
         ubyte vbank = cx16.r1L

compiler/res/prog8lib/cx16/syslib.p8

@@ -6,6 +6,39 @@
 cbm {
     ; Commodore (CBM) common variables, vectors and kernal routines
 
+; irq, system and hardware vectors  (common across cbm machines):
+    &uword  IERROR      = $0300
+    &uword  IMAIN       = $0302
+    &uword  ICRNCH      = $0304
+    &uword  IQPLOP      = $0306
+    &uword  IGONE       = $0308
+    &uword  IEVAL       = $030a
+    &ubyte  SAREG       = $030c     ; register storage for A for SYS calls
+    &ubyte  SXREG       = $030d     ; register storage for X for SYS calls
+    &ubyte  SYREG       = $030e     ; register storage for Y for SYS calls
+    &ubyte  SPREG       = $030f     ; register storage for P (status register) for SYS calls
+    &uword  USRADD      = $0311     ; vector for the USR() basic command
+    ; $0313 is unused.
+    &uword  CINV        = $0314     ; IRQ vector (in ram)
+    &uword  CBINV       = $0316     ; BRK vector (in ram)
+    &uword  NMINV       = $0318     ; NMI vector (in ram)
+    &uword  IOPEN       = $031a
+    &uword  ICLOSE      = $031c
+    &uword  ICHKIN      = $031e
+    &uword  ICKOUT      = $0320
+    &uword  ICLRCH      = $0322
+    &uword  IBASIN      = $0324
+    &uword  IBSOUT      = $0326
+    &uword  ISTOP       = $0328
+    &uword  IGETIN      = $032a
+    &uword  ICLALL      = $032c
+    ; $032e has a X16 specific function (KEYHDL) so you'll find this as cx16.KEYHDL
+    &uword  ILOAD       = $0330
+    &uword  ISAVE       = $0332
+    &uword  NMI_VEC     = $FFFA     ; 65c02 nmi vector, determined by the kernal if banked in
+    &uword  RESET_VEC   = $FFFC     ; 65c02 reset vector, determined by the kernal if banked in
+    &uword  IRQ_VEC     = $FFFE     ; 65c02 interrupt vector, determined by the kernal if banked in
+
 
 ; STROUT --> use txt.print
 ; CLEARSCR -> use txt.clear_screen
@@ -117,42 +150,14 @@ asmsub kbdbuf_clear() {
 
 cx16 {
 
-; irq, system and hardware vectors:
-    &uword  IERROR      = $0300
-    &uword  IMAIN       = $0302
-    &uword  ICRNCH      = $0304
-    &uword  IQPLOP      = $0306
-    &uword  IGONE       = $0308
-    &uword  IEVAL       = $030a
-    &ubyte  SAREG       = $030c     ; register storage for A for SYS calls
-    &ubyte  SXREG       = $030d     ; register storage for X for SYS calls
-    &ubyte  SYREG       = $030e     ; register storage for Y for SYS calls
-    &ubyte  SPREG       = $030f     ; register storage for P (status register) for SYS calls
-    &uword  USRADD      = $0311     ; vector for the USR() basic command
-    ; $0313 is unused.
-    &uword  CINV        = $0314     ; IRQ vector (in ram)
-    &uword  CBINV       = $0316     ; BRK vector (in ram)
-    &uword  NMINV       = $0318     ; NMI vector (in ram)
-    &uword  IOPEN       = $031a
-    &uword  ICLOSE      = $031c
-    &uword  ICHKIN      = $031e
-    &uword  ICKOUT      = $0320
-    &uword  ICLRCH      = $0322
-    &uword  IBASIN      = $0324
-    &uword  IBSOUT      = $0326
-    &uword  ISTOP       = $0328
-    &uword  IGETIN      = $032a
-    &uword  ICLALL      = $032c
+; cx16 specific vectors and variables
     &uword  KEYHDL      = $032e     ; keyboard scan code handler see examples/cx16/keyboardhandler.p8
-    &uword  ILOAD       = $0330
-    &uword  ISAVE       = $0332
-    &uword  NMI_VEC     = $FFFA     ; 65c02 nmi vector, determined by the kernal if banked in
-    &uword  RESET_VEC   = $FFFC     ; 65c02 reset vector, determined by the kernal if banked in
-    &uword  IRQ_VEC     = $FFFE     ; 65c02 interrupt vector, determined by the kernal if banked in
 
     &uword  edkeyvec    = $ac03     ; (ram bank 0): for intercepting BASIN/CHRIN key strokes. See set_chrin_keyhandler()
     &ubyte  edkeybk     = $ac05     ; ...the RAM bank of the handler routine, if not in low ram
 
+    &ubyte  stavec      = $03b2     ; argument for stash()
+
 
 ; the sixteen virtual 16-bit registers in both normal unsigned mode and signed mode (s)
     &uword r0  = $0002
@@ -395,8 +400,8 @@ romsub $ff5c = LKUPSA(ubyte sa @Y)  clobbers(A,X,Y)
 romsub $ff5f = screen_mode(ubyte mode @A, bool getCurrent @Pc) -> ubyte @A, ubyte @X, ubyte @Y, bool @Pc        ; also see SCREEN or get_screen_mode()
 romsub $ff62 = screen_set_charset(ubyte charset @A, uword charsetptr @XY)  clobbers(A,X,Y)
 romsub $ff6e = JSRFAR()  ; following word = address to call, byte after that=rom/ram bank it is in
-romsub $ff74 = fetch(ubyte bank @X, ubyte index @Y)  clobbers(X) -> ubyte @A
-romsub $ff77 = stash(ubyte data @A, ubyte bank @X, ubyte index @Y)  clobbers(X)
+romsub $ff74 = fetch(ubyte zp_startaddr @A, ubyte bank @X, ubyte index @Y)  clobbers(X) -> ubyte @A
+romsub $ff77 = stash(ubyte data @A, ubyte bank @X, ubyte index @Y)  clobbers(X)     ;  note: The the zero page address containing the base address is passed in stavec ($03B2)
 romsub $ff7d = PRIMM()
 
 ; high level graphics & fonts
@@ -466,7 +471,7 @@ romsub $fec0 = kbdbuf_get_modifiers() -> ubyte @A
 romsub $fec3 = kbdbuf_put(ubyte key @A) clobbers(X)
 romsub $fed2 = keymap(uword identifier @XY, bool read @Pc) -> bool @Pc
 romsub $ff68 = mouse_config(byte shape @A, ubyte resX @X, ubyte resY @Y)  clobbers (A, X, Y)
-romsub $ff6b = mouse_get(ubyte zpdataptr @X) -> ubyte @A        ;  use mouse_pos() instead
+romsub $ff6b = mouse_get(ubyte zdataptr @X) -> ubyte @A, byte @X    ;  use mouse_pos() instead
 romsub $ff71 = mouse_scan()  clobbers(A, X, Y)
 romsub $ff53 = joystick_scan()  clobbers(A, X, Y)
 romsub $ff56 = joystick_get(ubyte joynr @A) -> uword @AX, bool @Y   ; note: everything is inverted
@@ -549,6 +554,7 @@ const ubyte  EXTAPI_ps2data_raw = $09
 const ubyte  EXTAPI_cursor_blink = $0A
 const ubyte  EXTAPI_led_update = $0B
 const ubyte  EXTAPI_mouse_set_position = $0C
+const ubyte  EXTAPI_scnsiz = $0D        ; rom R48+
 
 ; extapi16 call numbers
 const ubyte  EXTAPI16_test = $00
@@ -587,9 +593,9 @@ asmsub mouse_config2(byte shape @A) clobbers (A, X, Y) {
     }}
 }
 
-asmsub mouse_pos() clobbers(X) -> ubyte @A, word @R0, word @R1 {
+asmsub mouse_pos() -> ubyte @A, uword @R0, uword @R1, byte @X {
     ; -- short wrapper around mouse_get() kernal routine:
-    ; -- gets the position of the mouse cursor in cx16.r0 and cx16.r1 (x/y coordinate), returns mouse button status in A.
+    ; -- gets the position of the mouse cursor in cx16.r0 and cx16.r1 (x/y coordinate), returns mouse button status in A, scroll wheel in X.
     ;    Note: mouse pointer needs to be enabled for this to do anything.
     %asm {{
         ldx  #cx16.r0
@@ -642,6 +648,15 @@ asmsub iso_cursor_char(ubyte character @X) clobbers(A,X,Y) {
     }}
 }
 
+asmsub scnsiz(ubyte width @X, ubyte heigth @Y) clobbers(A,X,Y) {
+    ; -- sets the screen editor size dimensions (without changing the graphical screen mode itself)
+    ;    (rom R48+)
+    %asm {{
+        lda  #EXTAPI_scnsiz
+        jmp  cx16.extapi
+    }}
+}
+
 ; TODO : implement shims for the remaining extapi calls.
 
 
@@ -1060,8 +1075,8 @@ asmsub  enable_irq_handlers(bool disable_all_irq_sources @Pc) clobbers(A,Y)  {
         trb  cx16.VERA_IEN      ; disable all IRQ sources
 +       lda  #<_irq_dispatcher
         ldy  #>_irq_dispatcher
-        sta  cx16.CINV
-        sty  cx16.CINV+1
+        sta  cbm.CINV
+        sty  cbm.CINV+1
         plp
         rts
 
@@ -1185,6 +1200,7 @@ asmsub set_sprcol_irq_handler(uword address @AY) clobbers(A) {
 asmsub set_aflow_irq_handler(uword address @AY) clobbers(A) {
     ; Sets the AFLOW irq handler to use with enable_irq_handlers().  Also enables AFLOW irqs.
     ; NOTE: unless a proper irq handler is already running, you should enclose this call in set_irqd() / clear_irqd() to avoid system crashes.
+    ; NOTE: the handler itself must fill the audio fifo buffer to at least 25% full again (1 KB) or the aflow irq will keep triggering!
     %asm {{
         php
         sei
@@ -1312,6 +1328,23 @@ _continue   iny
         void cx16.i2c_write_byte($42, $05, cx16.r0L)
     }
 
+    asmsub rom_version() clobbers(Y) -> ubyte @A, bool @Pc {
+        ; Returns the KERNEL ROM version. Carry set if pre-release, clear if offical release.
+        %asm{{
+            ; the ROM BANK is unknown on entry
+            ldy  $01
+            stz  $01        ; KERNEL ROM
+            clc             ; prepare for released ROM
+            lda  $FF80
+            bpl  _final     ; pre-release versions are negative
+            eor  #$FF       ; twos complement
+            ina
+            sec
+    _final:
+            sty  $01
+            rts
+        }}
+    }
 }
 
 sys {
@@ -1368,9 +1401,9 @@ asmsub  init_system()  {
 asmsub  init_system_phase2()  {
     %asm {{
         sei
-        lda  cx16.CINV
+        lda  cbm.CINV
         sta  restore_irq._orig_irqvec
-        lda  cx16.CINV+1
+        lda  cbm.CINV+1
         sta  restore_irq._orig_irqvec+1
         lda  #PROG8_VARSHIGH_RAMBANK
         sta  $00    ; select ram bank
@@ -1408,9 +1441,9 @@ asmsub  set_irq(uword handler @AY) clobbers(A)  {
         sta  _modified+1
         sty  _modified+2
         lda  #<_irq_handler
-        sta  cx16.CINV
+        sta  cbm.CINV
         lda  #>_irq_handler
-        sta  cx16.CINV+1
+        sta  cbm.CINV+1
         lda  #1
         tsb  cx16.VERA_IEN      ; enable the vsync irq
         cli
@@ -1439,9 +1472,9 @@ asmsub  restore_irq() clobbers(A) {
 	%asm {{
 	    sei
 	    lda  _orig_irqvec
-	    sta  cx16.CINV
+	    sta  cbm.CINV
 	    lda  _orig_irqvec+1
-	    sta  cx16.CINV+1
+	    sta  cbm.CINV+1
 	    lda  cx16.VERA_IEN
 	    and  #%11110000     ; disable all Vera IRQs but the vsync
 	    ora  #%00000001
@@ -1468,9 +1501,9 @@ asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0) clobbers(A) {
             ldy  cx16.r0+1
             jsr  set_rasterline
             lda  #<_raster_irq_handler
-            sta  cx16.CINV
+            sta  cbm.CINV
             lda  #>_raster_irq_handler
-            sta  cx16.CINV+1
+            sta  cbm.CINV+1
             cli
             rts
 

compiler/res/prog8lib/cx16/textio.p8

@@ -262,6 +262,12 @@ sub iso16() {
     cx16.screen_set_charset(10, 0)  ; charset
 }
 
+sub kata() {
+    ; -- switch to katakana character set (requires rom 48+)
+    cbm.CHROUT($0f)                 ; iso mode
+    cx16.screen_set_charset(12, 0)  ; charset
+}
+
 asmsub  scroll_left() clobbers(A, X, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself

compiler/res/prog8lib/cx16/verafx.p8

@@ -1,6 +1,6 @@
 ; Somewhat experimental Vera FX support.
 ; Docs:
-; https://github.com/X16Community/x16-docs/blob/101759f3bfa5e6cce4e8c5a0b67cb0f2f1c6341e/X16%20Reference%20-%2010%20-%20VERA%20FX%20Reference.md
+; https://github.com/X16Community/x16-docs/blob/fb63156cca2d6de98be0577aacbe4ddef458f896/X16%20Reference%20-%2010%20-%20VERA%20FX%20Reference.md
 ; https://docs.google.com/document/d/1q34uWOiM3Be2pnaHRVgSdHySI-qsiQWPTo_gfE54PTg
 
 verafx {
@@ -166,6 +166,8 @@ verafx {
     }
 
     sub transparency(bool enable) {
+        ; Set transparent write mode for VeraFX cached writes and also for normal writes to DATA0/DATA.
+        ; If enabled, pixels with value 0 do not modify VRAM when written (so they are "transparent")
         cx16.VERA_CTRL = 2<<1       ; dcsel = 2
         if enable
             cx16.VERA_FX_CTRL |= %10000000

compiler/res/prog8lib/diskio.p8

@@ -333,6 +333,7 @@ m_in_buffer     sta  $ffff
 
     sub f_read_all(uword bufferpointer) -> uword {
         ; -- read the full contents of the file, returns number of bytes read.
+        ;    It is assumed the file size is less than 64 K.
         if not iteration_in_progress
             return 0
 
@@ -346,12 +347,13 @@ m_in_buffer     sta  $ffff
         return total_read
     }
 
-    asmsub f_readline(uword bufptr @AY) clobbers(X) -> ubyte @Y {
+    asmsub f_readline(uword bufptr @AY) clobbers(X) -> ubyte @Y, ubyte @A {
         ; Routine to read text lines from a text file. Lines must be less than 255 characters.
         ; Reads characters from the input file UNTIL a newline or return character (or EOF).
         ; The line read will be 0-terminated in the buffer (and not contain the end of line character).
         ; The length of the line is returned in Y. Note that an empty line is okay and is length 0!
         ; I/O error status should be checked by the caller itself via READST() routine.
+        ; The I/O error status byte is returned in A.
         %asm {{
             sta  P8ZP_SCRATCH_W1
             sty  P8ZP_SCRATCH_W1+1
@@ -368,7 +370,8 @@ _loop       jsr  cbm.CHRIN
 _line_end   dey     ; get rid of the trailing end-of-line char
             lda  #0
             sta  (P8ZP_SCRATCH_W1),y
-_end        rts
+_end        jsr  cbm.READST
+            rts
         }}
     }
 
@@ -405,6 +408,7 @@ _end        rts
 
     sub f_write(uword bufferpointer, uword num_bytes) -> bool {
         ; -- write the given number of bytes to the currently open file
+        ;    you can call this multiple times to append more data
         if num_bytes!=0 {
             reset_write_channel()
             repeat num_bytes {

compiler/res/prog8lib/prog8_funcs.asm

@@ -1,60 +1,5 @@
 ; ---- builtin functions
 
-
-func_any_b_into_A	.proc
-		; -- any(array),  array in P8ZP_SCRATCH_W1, num bytes in A
-		sta  _cmp_mod+1		; self-modifying code
-		ldy  #0
--		lda  (P8ZP_SCRATCH_W1),y
-		bne  _got_any
-		iny
-_cmp_mod	cpy  #255		; modified
-		bne  -
-		lda  #0
-		rts
-_got_any	lda  #1
-		rts
-		.pend
-
-
-func_all_b_into_A	.proc
-		; -- all(array),  array in P8ZP_SCRATCH_W1, num bytes in A
-		sta  _cmp_mod+1		; self-modifying code
-		ldy  #0
--		lda  (P8ZP_SCRATCH_W1),y
-		beq  _got_not_all
-		iny
-_cmp_mod	cpy  #255		; modified
-		bne  -
-		lda  #1
-_got_not_all	rts
-		.pend
-
-func_any_w_into_A	.proc
-		asl  a
-		jmp  func_any_b_into_A
-		.pend
-
-func_all_w_into_A	.proc
-		; -- all(warray),  array in P8ZP_SCRATCH_W1, num bytes in A
-		asl  a			; times 2 because of word
-		sta  _cmp_mod+1		; self-modifying code
-		ldy  #0
--		lda  (P8ZP_SCRATCH_W1),y
-		bne  +
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		bne  ++
-		lda  #0
-		rts
-+		iny
-+		iny
-_cmp_mod	cpy  #255		; modified
-		bne  -
-		lda  #1
-		rts
-		.pend
-
 abs_b_into_A	.proc
 	; -- A = abs(A)
 		cmp  #0

compiler/res/prog8lib/prog8_lib.asm

@@ -248,31 +248,25 @@ _arg_s2		.word  0
 
 strcmp_mem	.proc
 		; --   compares strings in s1 (AY) and s2 (P8ZP_SCRATCH_W2).
-		;      Returns -1,0,1 in A, depeding on the ordering. Clobbers Y.
+		;      Returns -1,0,1 in A, depending on the ordering. Clobbers Y.
 		sta  P8ZP_SCRATCH_W1
 		sty  P8ZP_SCRATCH_W1+1
 		ldy  #0
-_loop		lda  (P8ZP_SCRATCH_W1),y
-		bne  +
-		lda  (P8ZP_SCRATCH_W2),y
-		bne  _return_minusone
-		beq  _return
-+		cmp  (P8ZP_SCRATCH_W2),y
-		bcc  _return_minusone
-		bne  _return_one
-		inc  P8ZP_SCRATCH_W1
-		bne  +
-		inc  P8ZP_SCRATCH_W1+1
-+		inc  P8ZP_SCRATCH_W2
-		bne  _loop
-		inc  P8ZP_SCRATCH_W2+1
-		bne  _loop
-_return_one
+_loop           lda  (P8ZP_SCRATCH_W1),y
+		beq  _c1_zero
+		cmp  (P8ZP_SCRATCH_W2),y
+		beq  _equal
+		bmi  _less
 		lda  #1
-_return		rts
-_return_minusone
-		lda  #-1
 		rts
+_less           lda  #-1
+		rts
+_equal          iny
+		bne  _loop
+_c1_zero        lda  (P8ZP_SCRATCH_W2),y
+		beq  +
+		lda  #-1
++		rts
 		.pend
 
 

compiler/res/prog8lib/shared_floats_functions.p8

@@ -96,7 +96,16 @@ sub atan(float value) -> float {
 ; two-argument arctangent that returns an angle in the correct quadrant
 ; for the signs of x and y, normalized to the range [0, 2π]
 sub atan2(float y, float x) -> float {
-    float atn = atan(y / x)
+    float atn
+    if x == 0 {
+        atn = π/2
+        if y == 0 return 0
+        if y < 0 {
+            atn += π
+        }
+    } else {
+        atn = atan(y / x)
+    }
     if x < 0 atn += π
     if atn < 0 atn += 2*π
     return atn

compiler/res/prog8lib/string.p8

@@ -151,6 +151,37 @@ _found	tya
         }}
     }
 
+    asmsub rfind(uword string @AY, ubyte character @X) -> ubyte @A, bool @Pc {
+        ; Locates the first position of the given character in the string, starting from the right.
+        ; returns Carry set if found + index in A, or Carry clear if not found (and A will be 255, an invalid index).
+        %asm {{
+            stx  P8ZP_SCRATCH_B1
+            sta  _str
+            sty  _str+1
+            jsr  string.length
+            dey
+            lda  _str
+    		sta  P8ZP_SCRATCH_W1
+    		lda  _str+1
+    		sta  P8ZP_SCRATCH_W1+1
+-           lda  (P8ZP_SCRATCH_W1),y
+            cmp  P8ZP_SCRATCH_B1
+            beq  _found
+            dey
+            cpy  #255
+            bne  -
+_notfound   lda  #255
+            clc
+            rts
+_found      tya
+            sec
+            rts
+
+_str    .word 0
+
+        }}
+    }
+
     asmsub contains(uword string @AY, ubyte character @X) -> bool @Pc {
         ; Just return true/false if the character is in the given string or not.
         %asm {{
@@ -199,9 +230,9 @@ _found	tya
 
     asmsub compare(uword string1 @R0, uword string2 @AY) clobbers(Y) -> byte @A {
         ; Compares two strings for sorting.
-        ; Returns -1 (255), 0 or 1 depending on wether string1 sorts before, equal or after string2.
+        ; Returns -1 (255), 0 or 1, meaning: string1 sorts before, equal or after string2.
         ; Note that you can also directly compare strings and string values with eachother using
-        ; comparison operators ==, < etcetera (it will use strcmp for you under water automatically).
+        ; comparison operators ==, < etcetera (this will use strcmp automatically).
         %asm {{
 		sta  P8ZP_SCRATCH_W2
 		sty  P8ZP_SCRATCH_W2+1

compiler/res/prog8lib/virtual/diskio.p8

@@ -11,7 +11,7 @@ diskio {
         %ir {{
             loadm.w r65534,diskio.load.filenameptr
             loadm.w r65535,diskio.load.address_override
-            syscall 61 (): r0.b
+            syscall 48 (): r0.b
             returnr.b r0
         }}
     }
@@ -72,6 +72,7 @@ diskio {
 
     sub f_read_all(uword bufferpointer) -> uword {
         ; -- read the full contents of the file, returns number of bytes read.
+        ;    It is assumed the file size is less than 64 K.
         txt.print("@TODO: f_read_all\n")
         return 0
     }
@@ -81,7 +82,7 @@ diskio {
         ; Reads characters from the input file UNTIL a newline or return character (or EOF).
         ; The line read will be 0-terminated in the buffer (and not contain the end of line character).
         ; The length of the line is returned in Y. Note that an empty line is okay and is length 0!
-        ; I/O error status should be checked by the caller itself via READST() routine.
+        ; This routine is not able here to return the status as well in a secondary return value, so you have to do that yourself.
         txt.print("@TODO: f_readline\n")
         return 0
     }
@@ -107,6 +108,7 @@ diskio {
 
     sub f_write(uword bufferpointer, uword num_bytes) -> bool {
         ; -- write the given number of bytes to the currently open file
+        ;    you can call this multiple times to append more data
         txt.print("@TODO: f_write\n")
         return false
     }
@@ -157,7 +159,7 @@ diskio {
             loadm.w r65533,diskio.save.filenameptr
             loadm.w r65534,diskio.save.start_address
             loadm.w r65535,diskio.save.savesize
-            syscall 58 (r65532.b, r65533.w, r65534.w, r65535.w): r0.b
+            syscall 45 (r65532.b, r65533.w, r65534.w, r65535.w): r0.b
             returnr.b r0
         }}
     }
@@ -169,7 +171,7 @@ diskio {
             loadm.w r65533,diskio.save.filenameptr
             loadm.w r65534,diskio.save.start_address
             loadm.w r65535,diskio.save.savesize
-            syscall 58 (r65532.b, r65533.w, r65534.w, r65535.w): r0.b
+            syscall 45 (r65532.b, r65533.w, r65534.w, r65535.w): r0.b
             returnr.b r0
         }}
     }
@@ -184,7 +186,7 @@ diskio {
         %ir {{
             loadm.w r65534,diskio.load.filenameptr
             loadm.w r65535,diskio.load.address_override
-            syscall 56 (r65534.w, r65535.w): r0.w
+            syscall 43 (r65534.w, r65535.w): r0.w
             returnr.w r0
         }}
     }
@@ -196,7 +198,7 @@ diskio {
         %ir {{
             loadm.w r65534,diskio.load_raw.filenameptr
             loadm.w r65535,diskio.load_raw.start_address
-            syscall 57 (r65534.w, r65535.w): r0.w
+            syscall 44 (r65534.w, r65535.w): r0.w
             returnr.w r0
         }}
     }
@@ -205,7 +207,7 @@ diskio {
         ; -- delete a file on the drive
         %ir {{
             loadm.w r65535,diskio.delete.filenameptr
-            syscall 59 (r65535.w)
+            syscall 46 (r65535.w)
         }}
     }
 
@@ -214,7 +216,7 @@ diskio {
         %ir {{
             loadm.w r65534,diskio.rename.oldfileptr
             loadm.w r65535,diskio.rename.newfileptr
-            syscall 60 (r65534.w, r65535.w)
+            syscall 47 (r65534.w, r65535.w)
         }}
     }
 }

compiler/res/prog8lib/virtual/floats.p8

@@ -13,7 +13,7 @@ sub print(float value) {
     ; ---- prints the floating point value (without a newline and no leading spaces).
     %ir {{
         loadm.f fr65535,floats.print.value
-        syscall 25 (fr65535.f)
+        syscall 15 (fr65535.f)
         return
     }}
 }
@@ -24,7 +24,7 @@ sub tostr(float value) -> str {
     %ir {{
         load.w r65535,floats.tostr.buffer
         loadm.f fr65535,floats.tostr.value
-        syscall 47 (r65535.w, fr65535.f)
+        syscall 34 (r65535.w, fr65535.f)
         load.w r0,floats.tostr.buffer
         returnr.w r0
     }}
@@ -34,7 +34,7 @@ sub parse(str value) -> float {
     ; -- parse a string value of a number to float
     %ir {{
         loadm.w  r65535,floats.parse.value
-        syscall 45 (r65535.w): fr0.f
+        syscall 32 (r65535.w): fr0.f
         returnr.f fr0
     }}
 }
@@ -147,7 +147,7 @@ sub ceil(float value) -> float {
 
 sub rnd() -> float {
     %ir {{
-        syscall 35 () : fr0.f
+        syscall 22 () : fr0.f
         returnr.f fr0
     }}
 }
@@ -155,7 +155,7 @@ sub rnd() -> float {
 sub rndseed(float seed) {
     %ir {{
         loadm.f  fr65535,floats.rndseed.seed
-        syscall 32 (fr65535.f)
+        syscall 19 (fr65535.f)
         return
     }}
 }

compiler/res/prog8lib/virtual/math.p8

@@ -164,14 +164,14 @@ math {
 
     sub rnd() -> ubyte {
         %ir {{
-            syscall 33 (): r0.b
+            syscall 20 (): r0.b
             returnr.b r0
         }}
     }
 
     sub rndw() -> uword {
         %ir {{
-            syscall 34 (): r0.w
+            syscall 21 (): r0.w
             returnr.w r0
         }}
     }
@@ -199,7 +199,7 @@ math {
         %ir {{
             loadm.w r65534,math.rndseed.seed1
             loadm.w r65535,math.rndseed.seed2
-            syscall 31 (r65534.w, r65535.w)
+            syscall 19 (r65534.w, r65535.w)
             return
         }}
     }
@@ -280,7 +280,7 @@ math {
             loadm.b r65533,math.atan2.y1
             loadm.b r65534,math.atan2.x2
             loadm.b r65535,math.atan2.y2
-            syscall 44 (r65532.b, r65533.b, r65534.b, r65535.b): r0.b
+            syscall 31 (r65532.b, r65533.b, r65534.b, r65535.b): r0.b
             returnr.b r0
         }}
     }
@@ -294,7 +294,7 @@ math {
         ;   - not all multiplications in the source code result in an actual multiplication call:
         ;     some simpler multiplications will be optimized away into faster routines. These will not set the upper 16 bits at all!
         %ir {{
-            syscall 46 (): r0.w
+            syscall 33 (): r0.w
             returnr.w r0
         }}
     }

compiler/res/prog8lib/virtual/monogfx.p8

@@ -377,7 +377,7 @@ monogfx {
         ; Non-recursive scanline flood fill.
         ; based loosely on code found here https://www.codeproject.com/Articles/6017/QuickFill-An-efficient-flood-fill-algorithm
         ; with the fixes applied to the seedfill_4 routine as mentioned in the comments.
-        const ubyte MAXDEPTH = 64
+        const ubyte MAXDEPTH = 100
         word @zp xx = x as word
         word @zp yy = y as word
         word[MAXDEPTH] @split @shared stack_xl
@@ -423,11 +423,10 @@ monogfx {
             while xx >= 0 {
                 if pget(xx as uword, yy as uword) as ubyte != cx16.r11L
                     break
+                plot(xx as uword, yy as uword, cx16.r10L as bool)
                 xx--
             }
-            if x1!=xx
-                horizontal_line(xx as uword+1, yy as uword, x1-xx as uword, cx16.r10L as bool)
-            else
+            if x1==xx
                 goto skip
 
             left = xx + 1
@@ -436,15 +435,12 @@ monogfx {
             xx = x1 + 1
 
             do {
-                cx16.r9 = xx as uword
                 while xx <= width-1 {
                     if pget(xx as uword, yy as uword) as ubyte != cx16.r11L
                         break
+                    plot(xx as uword, yy as uword, cx16.r10L as bool)
                     xx++
                 }
-                if cx16.r9!=xx
-                    horizontal_line(cx16.r9, yy as uword, (xx as uword)-cx16.r9, cx16.r10L as bool)
-
                 push_stack(left, xx - 1, yy, dy)
                 if xx > x2 + 1
                     push_stack(x2 + 1, xx - 1, yy, -dy)

compiler/res/prog8lib/virtual/string.p8

@@ -56,6 +56,7 @@ string {
     sub find(str st, ubyte character) -> ubyte {
         ; Locates the first position of the given character in the string,
         ; returns Carry set if found + index in A, or Carry clear if not found (and A will be 255, an invalid index).
+        ; NOTE: because this isn't an asmsub, there's only a SINGLE return value here. On the c64/cx16 targets etc there are 2 return values.
         ubyte ix
         for ix in 0 to length(st)-1 {
             if st[ix]==character {
@@ -67,6 +68,21 @@ string {
         return 255
     }
 
+    sub rfind(uword stringptr, ubyte character) -> ubyte {
+        ; Locates the first position of the given character in the string, starting from the right.
+        ; returns Carry set if found + index in A, or Carry clear if not found (and A will be 255, an invalid index).
+        ; NOTE: because this isn't an asmsub, there's only a SINGLE return value here. On the c64/cx16 targets etc there are 2 return values.
+        ubyte ix
+        for ix in string.length(stringptr)-1 downto 0 {
+            if stringptr[ix]==character {
+                sys.set_carry()
+                return ix
+            }
+        }
+        sys.clear_carry()
+        return 255
+    }
+
     sub contains(str st, ubyte character) -> bool {
         void find(st, character)
         if_cs
@@ -82,7 +98,7 @@ string {
         %ir {{
             loadm.w r65534,string.copy.source
             loadm.w r65535,string.copy.target
-            syscall 52 (r65534.w, r65535.w): r0.b
+            syscall 39 (r65534.w, r65535.w): r0.b
             returnr.b r0
         }}
     }
@@ -96,13 +112,13 @@ string {
 
     sub compare(str st1, str st2) -> byte {
         ; Compares two strings for sorting.
-        ; Returns -1 (255), 0 or 1 depending on wether string1 sorts before, equal or after string2.
+        ; Returns -1 (255), 0 or 1, meaning: string1 sorts before, equal or after string2.
         ; Note that you can also directly compare strings and string values with eachother using
-        ; comparison operators ==, < etcetera (it will use strcmp for you under water automatically).
+        ; comparison operators ==, < etcetera (this will use strcmp automatically).
         %ir {{
             loadm.w r65534,string.compare.st1
             loadm.w r65535,string.compare.st2
-            syscall 29 (r65534.w, r65535.w) : r0.b
+            syscall 16 (r65534.w, r65535.w) : r0.b
             returnr.b r0
         }}
     }

compiler/res/prog8lib/virtual/syslib.p8

@@ -34,7 +34,7 @@ sys {
         %ir {{
             loadm.w r65534,sys.internal_stringcopy.source
             loadm.w r65535,sys.internal_stringcopy.tgt
-            syscall 52 (r65534.w, r65535.w): r0.b
+            syscall 39 (r65534.w, r65535.w): r0.b
         }}
     }
 
@@ -43,7 +43,7 @@ sys {
             loadm.w r65533,sys.memcopy.source
             loadm.w r65534,sys.memcopy.tgt
             loadm.w r65535,sys.memcopy.count
-            syscall 49 (r65533.w, r65534.w, r65535.w)
+            syscall 36 (r65533.w, r65534.w, r65535.w)
         }}
     }
 
@@ -52,7 +52,7 @@ sys {
             loadm.w r65533,sys.memset.mem
             loadm.w r65534,sys.memset.numbytes
             loadm.b r65535,sys.memset.value
-            syscall 50 (r65533.w, r65534.w, r65535.b)
+            syscall 37 (r65533.w, r65534.w, r65535.b)
         }}
     }
 
@@ -61,7 +61,7 @@ sys {
             loadm.w r65533,sys.memsetw.mem
             loadm.w r65534,sys.memsetw.numwords
             loadm.w r65535,sys.memsetw.value
-            syscall 51 (r65533.w, r65534.w, r65535.w)
+            syscall 38 (r65533.w, r65534.w, r65535.w)
         }}
     }
 
@@ -85,6 +85,18 @@ sys {
         }}
     }
 
+    sub set_irqd() {
+        %ir {{
+            sei
+        }}
+    }
+
+    sub clear_irqd() {
+        %ir {{
+            cli
+        }}
+    }
+
     sub disable_caseswitch() {
         ; no-op
     }
@@ -128,7 +140,7 @@ sys {
         %ir {{
             loadm.w r65534,sys.gfx_getpixel.xx
             loadm.w r65535,sys.gfx_getpixel.yy
-            syscall 30 (r65534.w, r65535.w): r0.b
+            syscall 17 (r65534.w, r65535.w): r0.b
             returnr.b r0
         }}
     }

compiler/res/prog8lib/virtual/textio.p8

@@ -7,14 +7,14 @@ txt {
 
 sub width() -> ubyte {
     %ir {{
-        syscall 62 (): r0.w
+        syscall 49 (): r0.w
         returnr.b r0
     }}
 }
 
 sub height() -> ubyte {
     %ir {{
-        syscall 62 (): r0.w
+        syscall 49 (): r0.w
         msig.b r1,r0
         returnr.b r1
     }}

compiler/src/prog8/CompilerMain.kt

@@ -56,7 +56,7 @@ private fun compileMain(args: Array<String>): Boolean {
     val printAst1 by cli.option(ArgType.Boolean, fullName = "printast1", description = "print out the compiler AST")
     val printAst2 by cli.option(ArgType.Boolean, fullName = "printast2", description = "print out the intermediate AST that is used for code generation")
     val breakpointCpuInstruction by cli.option(ArgType.Choice(listOf("brk", "stp"), { it }), fullName = "breakinstr", description = "the CPU instruction to use as well for %breakpoint")
-    val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler (one of '${C64Target.NAME}', '${C128Target.NAME}', '${Cx16Target.NAME}', '${AtariTarget.NAME}', '${PETTarget.NAME}', '${VMTarget.NAME}') (required)")
+    val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler (one of ${CompilationTargets.joinToString(",")}) (required)")
     val bytes2float by cli.option(ArgType.String, fullName = "bytes2float", description = "convert a comma separated list of bytes from the target system to a float value. NOTE: you need to supply a target option too, and also still have to supply a dummy module file name as well!")
     val float2bytes by cli.option(ArgType.String, fullName = "float2bytes", description = "convert floating point number to a list of bytes for the target system. NOTE: you need to supply a target option too, and also still have to supply a dummy module file name as well!")
     val startVm by cli.option(ArgType.Boolean, fullName = "vm", description = "load and run a .p8ir IR source file in the VM")
@@ -96,16 +96,20 @@ private fun compileMain(args: Array<String>): Boolean {
             return false
         }
 
-        if (compilationTarget !in setOf(C64Target.NAME, C128Target.NAME, Cx16Target.NAME, AtariTarget.NAME, PETTarget.NAME, VMTarget.NAME)) {
+        if (compilationTarget !in CompilationTargets) {
             System.err.println("Invalid compilation target: $compilationTarget")
             return false
         }
     }
 
-    if(bytes2float!=null)
-        return convertBytesToFloat(bytes2float!!, compilationTarget!!)
-    if(float2bytes!=null)
-        return convertFloatToBytes(float2bytes!!, compilationTarget!!)
+    if(bytes2float!=null) {
+        convertBytesToFloat(bytes2float!!, compilationTarget!!)
+        return true
+    }
+    if(float2bytes!=null) {
+        convertFloatToBytes(float2bytes!!, compilationTarget!!)
+        return true
+    }
 
     if(varsHighBank==0 && compilationTarget==Cx16Target.NAME) {
         System.err.println("On the Commander X16, HiRAM bank 0 is used by the kernal and can't be used.")
@@ -139,7 +143,8 @@ private fun compileMain(args: Array<String>): Boolean {
     }
 
     if(startVm==true) {
-        return runVm(moduleFiles.first())
+        runVm(moduleFiles.first())
+        return true
     }
 
     val processedSymbols = processSymbolDefs(symbolDefs) ?: return false
@@ -297,21 +302,19 @@ private fun compileMain(args: Array<String>): Boolean {
     return true
 }
 
-fun convertFloatToBytes(number: String, target: String): Boolean {
+fun convertFloatToBytes(number: String, target: String) {
     val tgt = getCompilationTargetByName(target)
     val dbl = number.toDouble()
     val bytes = tgt.machine.convertFloatToBytes(dbl)
     print("$dbl in bytes on '$target': ")
     println(bytes.joinToString(","))
-    return true
 }
 
-fun convertBytesToFloat(bytelist: String, target: String): Boolean {
+fun convertBytesToFloat(bytelist: String, target: String) {
     val tgt = getCompilationTargetByName(target)
     val bytes = bytelist.split(',').map { it.trim().toUByte() }
     val number = tgt.machine.convertBytesToFloat(bytes)
     println("floating point value on '$target': $number")
-    return true
 }
 
 private fun processSymbolDefs(symbolDefs: List<String>): Map<String, String>? {
@@ -329,9 +332,8 @@ private fun processSymbolDefs(symbolDefs: List<String>): Map<String, String>? {
     return result
 }
 
-fun runVm(irFilename: String): Boolean {
+fun runVm(irFilename: String) {
     val irFile = Path(irFilename)
     val vmdef = VirtualMachineDefinition()
     vmdef.launchEmulator(0, irFile)
-    return true
 }

compiler/src/prog8/compiler/BuiltinFunctions.kt

@@ -19,8 +19,6 @@ internal val constEvaluatorsForBuiltinFuncs: Map<String, ConstExpressionCaller>
     "sqrt__ubyte" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, false) { sqrt(it.toDouble()) } },
     "sqrt__uword" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, false) { sqrt(it.toDouble()) } },
     "sqrt__float" to { a, p, prg -> oneFloatArgOutputFloat(a, p, prg) { sqrt(it) } },
-    "any" to { a, p, prg -> collectionArgBoolResult(a, p, prg) { array->array.any { it!=0.0 }  } },
-    "all" to { a, p, prg -> collectionArgBoolResult(a, p, prg) { array->array.all { it!=0.0 }  } },
     "lsb" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, true) { x: Int -> (x and 255).toDouble() } },
     "msb" to { a, p, prg -> oneIntArgOutputInt(a, p, prg, true) { x: Int -> (x ushr 8 and 255).toDouble()} },
     "mkword" to ::builtinMkword,
@@ -77,17 +75,6 @@ private fun oneFloatArgOutputFloat(args: List<Expression>, position: Position, p
     return NumericLiteral(DataType.FLOAT, function(constval.number), args[0].position)
 }
 
-private fun collectionArgBoolResult(args: List<Expression>, position: Position, program: Program, function: (arg: List<Double>)->Boolean): NumericLiteral {
-    if(args.size!=1)
-        throw SyntaxError("builtin function requires one non-scalar argument", position)
-
-    val array= args[0] as? ArrayLiteral ?: throw NotConstArgumentException()
-    val constElements = array.value.map{it.constValue(program)?.number}
-    if(constElements.contains(null))
-        throw NotConstArgumentException()
-    return NumericLiteral.fromBoolean(function(constElements.mapNotNull { it }), args[0].position)
-}
-
 private fun builtinAbs(args: List<Expression>, position: Position, program: Program): NumericLiteral {
     // 1 arg, type = int, result type= uword
     if(args.size!=1)
@@ -140,6 +127,8 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
         return NumericLiteral.optimalInteger(arraySize, position)
     if(args[0] is ArrayLiteral)
         return NumericLiteral.optimalInteger((args[0] as ArrayLiteral).value.size, position)
+    if(args[0] is StringLiteral)
+        return NumericLiteral.optimalInteger((args[0] as StringLiteral).value.length, position)
     if(args[0] !is IdentifierReference)
         throw SyntaxError("len argument should be an identifier", position)
     val target = (args[0] as IdentifierReference).targetVarDecl(program)

compiler/src/prog8/compiler/Compiler.kt

@@ -302,10 +302,9 @@ fun parseMainModule(filepath: Path,
         .filter { it.isFromFilesystem }
         .map { Path(it.origin) }
     val compilerOptions = determineCompilationOptions(program, compTarget)
-    // depending on the machine and compiler options we may have to include some libraries
-    for(lib in compTarget.machine.importLibs(compilerOptions, compTarget.name))
-        importer.importImplicitLibraryModule(lib)
 
+    // import the default modules
+    importer.importImplicitLibraryModule("syslib")
     if(compilerOptions.compTarget.name!=VMTarget.NAME && !compilerOptions.experimentalCodegen) {
         importer.importImplicitLibraryModule("math")
     }

compiler/src/prog8/compiler/astprocessing/AstChecker.kt

@@ -570,6 +570,13 @@ internal class AstChecker(private val program: Program,
             checkType(assignment.target, assignment.value, assignment.isAugmentable)
         }
 
+        if(assignment.target.void && assignment.target.multi?.isNotEmpty()!=true) {
+            if(assignment.value is IFunctionCall)
+                errors.err("cannot assign to 'void', perhaps a void function call was intended", assignment.position)
+            else
+                errors.err("cannot assign to 'void'", assignment.position)
+            return
+        }
 
         val fcall = assignment.value as? IFunctionCall
         val fcallTarget = fcall?.target?.targetSubroutine(program)
@@ -837,6 +844,11 @@ internal class AstChecker(private val program: Program,
         if(compilerOptions.zeropage==ZeropageType.DONTUSE && decl.zeropage == ZeropageWish.REQUIRE_ZEROPAGE)
             err("zeropage usage has been disabled by options")
 
+        if(decl.splitArray) {
+            if (decl.datatype !in arrayOf(DataType.ARRAY_W, DataType.ARRAY_UW, DataType.ARRAY_W_SPLIT, DataType.ARRAY_UW_SPLIT)) {
+                errors.err("split can only be used on word arrays", decl.position)
+            }
+        }
         super.visit(decl)
     }
 
@@ -939,7 +951,7 @@ internal class AstChecker(private val program: Program,
                     err("this directive may only occur at module level")
                 val allowedEncodings = Encoding.entries.map {it.prefix}
                 if(directive.args.size!=1 || directive.args[0].name !in allowedEncodings)
-                    err("invalid encoding directive, expected one of ${allowedEncodings}")
+                    err("invalid encoding directive, expected one of $allowedEncodings")
             }
             else -> throw SyntaxError("invalid directive ${directive.directive}", directive.position)
         }
@@ -1406,6 +1418,13 @@ internal class AstChecker(private val program: Program,
         if(target is VarDecl) {
             if(target.datatype !in IterableDatatypes && target.datatype!=DataType.UWORD)
                 errors.err("indexing requires an iterable or address uword variable", arrayIndexedExpression.position)
+            val indexVariable = arrayIndexedExpression.indexer.indexExpr as? IdentifierReference
+            if(indexVariable!=null) {
+                if(indexVariable.targetVarDecl(program)?.datatype in SignedDatatypes) {
+                    errors.err("variable array indexing can't be performed with signed variables", indexVariable.position)
+                    return
+                }
+            }
             val arraysize = target.arraysize?.constIndex()
             val index = arrayIndexedExpression.indexer.constIndex()
             if(arraysize!=null) {

compiler/src/prog8/compiler/astprocessing/AstIdentifiersChecker.kt

@@ -177,7 +177,7 @@ internal class AstIdentifiersChecker(private val errors: IErrorReporter,
                                 '_'
                         }.joinToString("")
                         val textEncoding = (call as Node).definingModule.textEncoding
-                        call.args[0] = StringLiteral(processed, textEncoding, name.position)
+                        call.args[0] = StringLiteral.create(processed, textEncoding, name.position)
                         call.args[0].linkParents(call as Node)
                     }
                 }

compiler/src/prog8/compiler/astprocessing/NotExpressionAndIfComparisonExprChanger.kt

@@ -59,16 +59,15 @@ internal class NotExpressionAndIfComparisonExprChanger(val program: Program, val
             // integer case (only if both are the same type)
             val leftC = expr.left as? BinaryExpression
             val rightC = expr.right as? BinaryExpression
-            if(leftC!=null && rightC!=null && leftC.operator=="==" && rightC.operator=="==") {
+            if(expr.operator=="and" && leftC!=null && rightC!=null && leftC.operator=="==" && rightC.operator=="==") {
                 if (leftC.right.constValue(program)?.number == 0.0 && rightC.right.constValue(program)?.number == 0.0) {
                     val leftDt = leftC.left.inferType(program).getOr(DataType.UNDEFINED)
                     val rightDt = rightC.left.inferType(program).getOr(DataType.UNDEFINED)
                     if(leftDt==rightDt && leftDt in IntegerDatatypes) {
                         if (rightC.left.isSimple) {
-                            // x==0 or y==0    ->  (x & y)==0
                             // x==0 and y==0   ->  (x | y)==0
-                            val newOperator = if(expr.operator=="or") "&" else "|"
-                            val inner = BinaryExpression(leftC.left, newOperator, rightC.left, expr.position)
+                            // the 'or' case cannot be easily optimized with a binary and like this!
+                            val inner = BinaryExpression(leftC.left, "|", rightC.left, expr.position)
                             val compare = BinaryExpression(inner, "==", NumericLiteral(leftDt, 0.0, expr.position), expr.position)
                             return listOf(IAstModification.ReplaceNode(expr, compare, parent))
                         }

compiler/src/prog8/compiler/astprocessing/TypecastsAdder.kt

@@ -332,8 +332,7 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
     private fun afterFunctionCallArgs(call: IFunctionCall): Iterable<IAstModification> {
         // see if a typecast is needed to convert the arguments into the required parameter type
         val modifications = mutableListOf<IAstModification>()
-        val sub = call.target.targetStatement(program)
-        val params = when(sub) {
+        val params = when(val sub = call.target.targetStatement(program)) {
             is BuiltinFunctionPlaceholder -> BuiltinFunctions.getValue(sub.name).parameters
             is Subroutine -> sub.parameters.map { FParam(it.name, listOf(it.type).toTypedArray()) }
             else -> emptyList()

compiler/src/prog8/compiler/astprocessing/VariousCleanups.kt

@@ -205,18 +205,20 @@ internal class VariousCleanups(val program: Program, val errors: IErrorReporter,
         }
 
         fun checkArray(variable: VarDecl): Iterable<IAstModification> {
-            return if(variable.value==null) {
-                val arraySpec = variable.arraysize!!
-                val size = arraySpec.indexExpr.constValue(program)?.number?.toInt() ?: throw FatalAstException("no array size")
-                return if(size==0)
-                    replaceWithFalse()
-                else
-                    noModifications
+            return when (variable.value) {
+                null -> {
+                    val arraySpec = variable.arraysize!!
+                    val size = arraySpec.indexExpr.constValue(program)?.number?.toInt() ?: throw FatalAstException("no array size")
+                    return if(size==0)
+                        replaceWithFalse()
+                    else
+                        noModifications
+                }
+                is ArrayLiteral -> {
+                    checkArray((variable.value as ArrayLiteral).value)
+                }
+                else -> noModifications
             }
-            else if(variable.value is ArrayLiteral) {
-                checkArray((variable.value as ArrayLiteral).value)
-            }
-            else noModifications
         }
 
         fun checkString(stringVal: StringLiteral): Iterable<IAstModification> {
@@ -275,6 +277,10 @@ internal class VariousCleanups(val program: Program, val errors: IErrorReporter,
             val target = arrayIndexedExpression.arrayvar.targetVarDecl(program)
             val arraysize = target?.arraysize?.constIndex()
             if(arraysize!=null) {
+                if(arraysize+index < 0) {
+                    errors.err("index out of bounds", arrayIndexedExpression.position)
+                    return noModifications
+                }
                 // replace the negative index by the normal index
                 val newIndex = NumericLiteral.optimalNumeric(arraysize+index, arrayIndexedExpression.indexer.position)
                 arrayIndexedExpression.indexer.indexExpr = newIndex

compiler/test/ProjectConfig.kt

@@ -1,9 +1,13 @@
 package prog8tests
 
 import io.kotest.core.config.AbstractProjectConfig
+import io.kotest.core.spec.SpecExecutionOrder
+import io.kotest.core.test.TestCaseOrder
 
 object ProjectConfig : AbstractProjectConfig() {
-    override val parallelism = kotlin.math.max(1, Runtime.getRuntime().availableProcessors() / 2)
+    override val testCaseOrder = TestCaseOrder.Lexicographic
+    override val specExecutionOrder = SpecExecutionOrder.Lexicographic
+    override val parallelism = kotlin.math.max(1, Runtime.getRuntime().availableProcessors()-1)
     // override fun listeners() = listOf(SystemOutToNullListener)
 }
 

compiler/test/TestCompilerOnExamples.kt

@@ -108,6 +108,8 @@ class TestCompilerOnExamplesCx16: FunSpec({
             "vtui/testvtui",
             "pcmaudio/play-adpcm",
             "pcmaudio/stream-wav",
+            "pcmaudio/stream-simple-aflow",
+            "pcmaudio/stream-simple-poll",
             "pcmaudio/vumeter",
             "sprites/dragon",
             "sprites/dragons",
@@ -171,9 +173,9 @@ class TestCompilerOnExamplesBothC64andCx16: FunSpec({
             "mandelbrot-gfx",
             "numbergame",
             "primes",
+            "queens",
             "screencodes",
             "sincos",
-            "sorting",
             "swirl",
             "swirl-float",
             "tehtriz",

compiler/test/TestNumericLiteral.kt

@@ -96,11 +96,11 @@ class TestNumericLiteral: FunSpec({
     }
 
     test("testEqualsRef") {
-        (StringLiteral("hello", Encoding.PETSCII, dummyPos) == StringLiteral("hello", Encoding.PETSCII, dummyPos)) shouldBe true
-        (StringLiteral("hello", Encoding.PETSCII, dummyPos) != StringLiteral("bye", Encoding.PETSCII, dummyPos)) shouldBe true
-        (StringLiteral("hello", Encoding.SCREENCODES, dummyPos) == StringLiteral("hello", Encoding.SCREENCODES, dummyPos)) shouldBe true
-        (StringLiteral("hello", Encoding.SCREENCODES, dummyPos) != StringLiteral("bye", Encoding.SCREENCODES, dummyPos)) shouldBe true
-        (StringLiteral("hello", Encoding.SCREENCODES, dummyPos) != StringLiteral("hello", Encoding.PETSCII, dummyPos)) shouldBe true
+        (StringLiteral.create("hello", Encoding.PETSCII, dummyPos) == StringLiteral.create("hello", Encoding.PETSCII, dummyPos)) shouldBe true
+        (StringLiteral.create("hello", Encoding.PETSCII, dummyPos) != StringLiteral.create("bye", Encoding.PETSCII, dummyPos)) shouldBe true
+        (StringLiteral.create("hello", Encoding.SCREENCODES, dummyPos) == StringLiteral.create("hello", Encoding.SCREENCODES, dummyPos)) shouldBe true
+        (StringLiteral.create("hello", Encoding.SCREENCODES, dummyPos) != StringLiteral.create("bye", Encoding.SCREENCODES, dummyPos)) shouldBe true
+        (StringLiteral.create("hello", Encoding.SCREENCODES, dummyPos) != StringLiteral.create("hello", Encoding.PETSCII, dummyPos)) shouldBe true
 
         val lvOne = NumericLiteral(DataType.UBYTE, 1.0, dummyPos)
         val lvTwo = NumericLiteral(DataType.UBYTE, 2.0, dummyPos)

compiler/test/TestOptimization.kt

@@ -688,18 +688,6 @@ main {
         (statements[7] as Assignment).target.memoryAddress!!.addressExpression.constValue(result.compilerAst)!!.number shouldBe 53281.0
     }
 
-    test("no crash on sorting unused array") {
-        val text="""
-main {
-	ubyte[5] cards = [ 14, 6, 29, 16, 3 ]
-
-	sub start() {
-	    sort(cards)
-	}
-}"""
-        compileText(C64Target(), true, text, writeAssembly = false) shouldNotBe null
-    }
-
     test("no string error when inlining") {
         val text="""
 main {
@@ -1059,4 +1047,30 @@ main {
         compileText(VMTarget(), true, src, writeAssembly = true) shouldNotBe null
         compileText(C64Target(), true, src, writeAssembly = true) shouldNotBe null
     }
+
+    test("optimizing inlined functions must reference proper scopes") {
+        val src="""
+main {
+    sub start() {
+        void other.sub1()
+        cx16.r0L = other.sub1()+other.sub1()
+    }
+
+}
+
+other {
+    sub  sub2() -> ubyte{
+        cx16.r0++
+        cx16.r1++
+        return cx16.r0L
+    }
+
+    sub sub1() -> ubyte {
+        return sub2()
+    }
+}"""
+
+        compileText(VMTarget(), true, src, writeAssembly = true) shouldNotBe null
+        compileText(C64Target(), true, src, writeAssembly = true) shouldNotBe null
+    }
 })

compiler/test/TestStringEncodings.kt

@@ -3,15 +3,18 @@ package prog8tests
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.expectError
 import com.github.michaelbull.result.getOrElse
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.assertions.withClue
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
+import prog8.ast.expressions.CharLiteral
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.expressions.StringLiteral
 import prog8.ast.statements.Assignment
 import prog8.ast.statements.VarDecl
 import prog8.code.core.Encoding
+import prog8.code.core.Position
 import prog8.code.core.unescape
 import prog8.code.target.C64Target
 import prog8.code.target.Cx16Target
@@ -21,6 +24,7 @@ import prog8.code.target.encodings.IsoEncoding
 import prog8.code.target.encodings.PetsciiEncoding
 import prog8tests.helpers.ErrorReporterForTests
 import prog8tests.helpers.compileText
+import java.io.CharConversionException
 
 
 class TestStringEncodings: FunSpec({
@@ -231,6 +235,22 @@ class TestStringEncodings: FunSpec({
         }
     }
 
+    context("kata") {
+        test("kata translation to half width glyphs") {
+            val orig = "ｶ が ガ"
+            orig.length shouldBe 5
+            val str = StringLiteral.create(orig, Encoding.KATAKANA, Position.DUMMY)
+            str.value.length shouldBe 7
+
+            val character = CharLiteral.create('ｶ', Encoding.KATAKANA, Position.DUMMY)
+            character.value shouldBe 'ｶ'
+
+            shouldThrow<CharConversionException> {
+                CharLiteral.create('ガ', Encoding.KATAKANA, Position.DUMMY)
+            }
+        }
+    }
+
     test("special pass-through") {
         val passthroughEscaped= """\x00\x1b\x99\xff"""
         val passthrough = passthroughEscaped.unescape()
@@ -299,12 +319,22 @@ class TestStringEncodings: FunSpec({
                 str string1 = "default"
                 str string2 = sc:"screencodes"
                 str string3 = iso:"iso"
-                str string4 = petscii:"petscii"
+                str string4 = iso5:"Хозяин и Работник"
+                str string5 = iso16:"zażółć gęślą jaźń"
+                str string6 = cp437:"≈ IBM Pc ≈ ♂♀♪☺¶"
+                str string7 = petscii:"petscii"
+                str string8 = atascii:"atascii"
+                str string9 = kata:"ｸｼﾞﾝ｡ # が # ガ"
             
                 ubyte char1 = 'd'
                 ubyte char2 = sc:'s'
                 ubyte char3 = iso:'i'
-                ubyte char4 = petscii:'p'
+                ubyte char4 = iso5:'и'
+                ubyte char5 = iso16:'ł'
+                ubyte char6 = cp437:'☺'
+                ubyte char7 = petscii:'p'
+                ubyte char8 = atascii:'p'
+                ubyte char9 = kata:'ｶ'
             
                 sub start() {
                 }

compiler/test/TestTypecasts.kt

@@ -209,7 +209,7 @@ main {
     }
 
     test("ubyte to word casts") {
-        var src="""
+        val src="""
 main {
     sub start() {
         ubyte @shared bb = 255

compiler/test/arithmetic/builtins.p8

@@ -406,15 +406,6 @@ main {
         ub = zero+(all(warr) as ubyte)*1+zero
         txt.print_ub(ub)
         txt.nl()
-
-        sort(ubarr)
-        sort(barr)
-        sort(uwarr)
-        sort(warr)
-        reverse(ubarr)
-        reverse(barr)
-        reverse(uwarr)
-        reverse(warr)
     }
 
     sub floatingpoint() {
@@ -449,7 +440,6 @@ main {
         txt.print_ub(ub)
         txt.nl()
 
-        reverse(flarr)
         for ub in 0 to len(flarr)-1 {
             floats.print(flarr[ub])
             txt.chrout(',')