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

.github/workflows/all-ci.yml

@@ -18,30 +18,24 @@ jobs:
           git clone --depth=1 https://github.com/irmen/64tass
           cd 64tass
           make -j4
-          sudo make install
+          sudo make install          
 
       - name: Set up JDK 11
         uses: actions/setup-java@v4
         with:
           java-version: 11
-          distribution: adopt
+          distribution: temurin
 
       - name: Build and test with Gradle
-        run: ./gradlew build shadowJar --no-daemon
+        run: |
+          ./gradlew build shadowJar --no-daemon
+          sha256sum -b compiler/build/libs/*-all.jar > compiler/build/libs/hash.txt
         
       - name: Create compiler shadowJar artifact
         uses: actions/upload-artifact@v4
         with:
           name: prog8-compiler-jar-zipped
-          path: compiler/build/libs/*-all.jar
+          path: |
+            compiler/build/libs/*-all.jar
+            compiler/build/libs/hash.txt
 
-      - uses: MCJack123/ghaction-generate-release-hashes@v4
-        if: "github.event_name == 'release'"
-        with:
-            hash-type: sha256
-            file-name: hashes.txt
-      - uses: actions/upload-artifact@v4
-        if: "github.event_name == 'release'"
-        with:
-            name: Artifact Hashes
-            path: hashes.txt        

.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

@@ -52,7 +52,8 @@ 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. It's possible to write games purely in Prog8, and even certain raster interrupt 'demoscene' effects.
+- 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,12 +67,12 @@ 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
 - supports the sixteen 'virtual' 16-bit registers R0 - R15 from the Commander X16, and provides them also on the C64.
-- encode strings and characters into petscii or screencodes as desired (C64/Cx16)
+- encode strings and characters into petscii or screencodes or even other encodings, as desired (C64/Cx16)
 
 *Rapid edit-compile-run-debug cycle:*
 
@@ -119,14 +120,13 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
 
     %import textio
     %zeropage basicsafe
-    
+
     main {
-    
-        ubyte[256] sieve
+        bool[256] sieve
         ubyte candidate_prime = 2       ; is increased in the loop
     
         sub start() {
-            sys.memset(sieve, 256, false)   ; clear the sieve
+            sys.memset(sieve, 256, 0)   ; clear the sieve
             txt.print("prime numbers up to 255:\n\n")
             ubyte amount=0
             repeat {
@@ -162,9 +162,6 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
         }
     }
 
-
-
-
 when compiled an ran on a C-64 you'll get:
 
 ![c64 screen](docs/source/_static/primes_example.png)

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

@@ -44,7 +44,7 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
             }
             is PtContainmentCheck -> other is PtContainmentCheck && other.type==type && other.element isSameAs element && other.iterable isSameAs iterable
             is PtIdentifier -> other is PtIdentifier && other.type==type && other.name==name
-            is PtMachineRegister -> other is PtMachineRegister && other.type==type && other.register==register
+            is PtIrRegister -> other is PtIrRegister && other.type==type && other.register==register
             is PtMemoryByte -> other is PtMemoryByte && other.address isSameAs address
             is PtNumber -> other is PtNumber && other.type==type && other.number==number
             is PtBool -> other is PtBool && other.value==value
@@ -87,7 +87,7 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
             is PtContainmentCheck -> false
             is PtFunctionCall -> false
             is PtIdentifier -> true
-            is PtMachineRegister -> true
+            is PtIrRegister -> true
             is PtMemoryByte -> address is PtNumber || address is PtIdentifier
             is PtBool -> true
             is PtNumber -> true
@@ -139,13 +139,9 @@ class PtAddressOf(position: Position) : PtExpression(DataType.UWORD, position) {
 
 class PtArrayIndexer(elementType: DataType, position: Position): PtExpression(elementType, position) {
     val variable: PtIdentifier
-        get() {
-            require((children[0] as? PtIdentifier)?.type in ArrayDatatypes+DataType.STR)        // TODO remove
-            return children[0] as PtIdentifier
-        }
+        get() = children[0] as PtIdentifier
     val index: PtExpression
         get() = children[1] as PtExpression
-
     val splitWords: Boolean
         get() = variable.type in SplitWordArrayTypes
 
@@ -210,11 +206,6 @@ class PtFunctionCall(val name: String,
                      val void: Boolean,
                      type: DataType,
                      position: Position) : PtExpression(type, position) {
-    init {
-        if(!void)
-            require(type!=DataType.UNDEFINED)
-    }
-
     val args: List<PtExpression>
         get() = children.map { it as PtExpression }
 }
@@ -239,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)
@@ -276,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)
@@ -354,7 +345,7 @@ class PtTypeCast(type: DataType, position: Position) : PtExpression(type, positi
 
 
 // special node that isn't created from compiling user code, but used internally in the Intermediate Code
-class PtMachineRegister(val register: Int, type: DataType, position: Position) : PtExpression(type, position)
+class PtIrRegister(val register: Int, type: DataType, position: Position) : PtExpression(type, position)
 
 
 fun constValue(expr: PtExpression): Double? = if(expr is PtNumber) expr.number else if(expr is PtBool) expr.asInt().toDouble() else null

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

@@ -10,7 +10,7 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
     fun type(dt: DataType) = "!${dt.name.lowercase()}!"
     fun txt(node: PtNode): String {
         return when(node) {
-            is PtAssignTarget -> "<target>"
+            is PtAssignTarget -> if(node.void) "<void>" else "<target>"
             is PtAssignment -> "<assign>"
             is PtAugmentedAssign -> "<inplace-assign> ${node.operator}"
             is PtBreakpoint -> "%breakpoint"
@@ -34,7 +34,7 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                 str + node.name + "()"
             }
             is PtIdentifier -> "${node.name} ${type(node.type)}"
-            is PtMachineRegister -> "VMREG#${node.register} ${type(node.type)}"
+            is PtIrRegister -> "IRREG#${node.register} ${type(node.type)}"
             is PtMemoryByte -> "@()"
             is PtNumber -> {
                 val numstr = if(node.type == DataType.FLOAT) node.number.toString() else node.number.toHex()
@@ -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/ast/AstStatements.kt

@@ -41,9 +41,18 @@ class PtSubroutineParameter(name: String, val type: DataType, position: Position
 sealed interface IPtAssignment {
     val children: MutableList<PtNode>
     val target: PtAssignTarget
-        get() = children[0] as PtAssignTarget
+        get() {
+            if(children.size==2)
+                return children[0] as PtAssignTarget
+            else if(children.size<2)
+                throw AssemblyError("incomplete node")
+            else
+                throw AssemblyError("no singular target")
+        }
     val value: PtExpression
-        get() = children[1] as PtExpression
+        get() = children.last() as PtExpression
+    val multiTarget: Boolean
+        get() = children.size>2
 }
 
 class PtAssignment(position: Position) : PtNode(position), IPtAssignment
@@ -51,7 +60,7 @@ class PtAssignment(position: Position) : PtNode(position), IPtAssignment
 class PtAugmentedAssign(val operator: String, position: Position) : PtNode(position), IPtAssignment
 
 
-class PtAssignTarget(position: Position) : PtNode(position) {
+class PtAssignTarget(val void: Boolean, position: Position) : PtNode(position) {
     val identifier: PtIdentifier?
         get() = children.single() as? PtIdentifier
     val array: PtArrayIndexer?
@@ -69,7 +78,7 @@ class PtAssignTarget(position: Position) : PtNode(position) {
             }
         }
 
-    infix fun isSameAs(expression: PtExpression): Boolean = expression.isSameAs(this)
+    infix fun isSameAs(expression: PtExpression): Boolean = !void && expression.isSameAs(this)
 }
 
 

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),
@@ -96,11 +96,9 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "sqrt__ubyte" to FSignature(true, listOf(FParam("value", arrayOf(DataType.UBYTE))), DataType.UBYTE),
     "sqrt__uword" to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD))), DataType.UBYTE),
     "sqrt__float" to FSignature(true, listOf(FParam("value", arrayOf(DataType.FLOAT))), DataType.FLOAT),
-    "divmod"           to FSignature(false, listOf(FParam("number", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("divident", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("division", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("remainder", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
-    "divmod__ubyte"    to FSignature(false, listOf(FParam("number", arrayOf(DataType.UBYTE)), FParam("divident", arrayOf(DataType.UBYTE)), FParam("division", arrayOf(DataType.UBYTE)), FParam("remainder", arrayOf(DataType.UBYTE))), null),
-    "divmod__uword"    to FSignature(false, listOf(FParam("number", arrayOf(DataType.UWORD)), FParam("divident", arrayOf(DataType.UWORD)), FParam("division", 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),
+    "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),
     "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),
@@ -133,4 +131,8 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "call"      to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UWORD),
 )
 
-val InplaceModifyingBuiltinFunctions = setOf("setlsb", "setmsb", "rol", "ror", "rol2", "ror2", "sort", "reverse")
+val InplaceModifyingBuiltinFunctions = setOf(
+    "setlsb", "setmsb",
+    "rol", "ror", "rol2", "ror2",
+    "divmod", "divmod__ubyte", "divmod__uword"
+)

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

@@ -20,6 +20,7 @@ class CompilationOptions(val output: OutputType,
                          var asmListfile: Boolean = false,
                          var includeSourcelines: Boolean = false,
                          var dumpVariables: Boolean = false,
+                         var dumpSymbols: Boolean = false,
                          var experimentalCodegen: Boolean = false,
                          var varsHighBank: Int? = null,
                          var varsGolden: Boolean = false,

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

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

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

@@ -5,7 +5,11 @@ enum class Encoding(val prefix: String) {
     PETSCII("petscii"),         // c64/c128/cx16
     SCREENCODES("sc"),          // c64/c128/cx16
     ATASCII("atascii"),         // atari
-    ISO("iso")                  // cx16
+    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)
+    KATAKANA("kata")                 // cx16  (katakana)
 }
 
 interface IStringEncoding {

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

@@ -1,6 +1,6 @@
 package prog8.code.core
 
-val AssociativeOperators = setOf("+", "*", "&", "|", "^", "==", "!=", "and", "or", "xor")
+val AssociativeOperators = setOf("+", "*", "&", "|", "^", "==", "!=", "xor")       // note: and,or are no longer associative because of Shortcircuit/McCarthy evaluation
 val ComparisonOperators = setOf("==", "!=", "<", ">", "<=", ">=")
 val LogicalOperators = setOf("and", "or", "xor", "not", "in")
 val BitwiseOperators = setOf("&", "|", "^", "~")

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

@@ -1,13 +1,19 @@
 package prog8.code.optimize
 
+import prog8.code.StRomSub
+import prog8.code.SymbolTable
 import prog8.code.ast.*
 import prog8.code.core.*
 
 
-fun optimizeIntermediateAst(program: PtProgram, options: CompilationOptions, errors: IErrorReporter) {
+fun optimizeIntermediateAst(program: PtProgram, options: CompilationOptions, st: SymbolTable, errors: IErrorReporter) {
     if (!options.optimize)
         return
-    while(errors.noErrors() && optimizeCommonSubExpressions(program, errors)>0) {
+    while (errors.noErrors() &&
+        (optimizeCommonSubExpressions(program, errors)
+                + optimizeBitTest(program, options)
+                + optimizeAssignTargets(program, st, errors)) > 0
+    ) {
         // keep rolling
     }
 }
@@ -27,11 +33,15 @@ private var tempVarCounter = 0
 private fun optimizeCommonSubExpressions(program: PtProgram, errors: IErrorReporter): Int {
 
     fun extractableSubExpr(expr: PtExpression): Boolean {
+        if(expr is PtArrayIndexer && expr.index.isSimple())
+            return false
+        if (expr is PtMemoryByte && expr.address.isSimple())
+            return false
+
         val result = if(expr is PtBinaryExpression)
             expr.type !in ByteDatatypes ||
-                    !expr.left.isSimple() ||
-                    !expr.right.isSimple() ||
-                    (expr.operator !in LogicalOperators && expr.operator !in BitwiseOperators)
+            !(expr.left.isSimple() && expr.right.isSimple()) ||
+            (expr.operator !in LogicalOperators && expr.operator !in BitwiseOperators)
         else if (expr is PtArrayIndexer && expr.type !in ByteDatatypes)
             true
         else
@@ -89,7 +99,7 @@ private fun optimizeCommonSubExpressions(program: PtProgram, errors: IErrorRepor
         singleReplacement2.parent = occurrence2.parent
 
         val tempassign = PtAssignment(binexpr.position).also { assign ->
-            assign.add(PtAssignTarget(binexpr.position).also { tgt->
+            assign.add(PtAssignTarget(false, binexpr.position).also { tgt->
                 tgt.add(PtIdentifier("$containerScopedName.$tempvarName", datatype, binexpr.position))
             })
             assign.add(occurrence1)
@@ -109,6 +119,124 @@ private fun optimizeCommonSubExpressions(program: PtProgram, errors: IErrorRepor
 }
 
 
+private fun optimizeAssignTargets(program: PtProgram, st: SymbolTable, errors: IErrorReporter): Int {
+    var changes = 0
+    walkAst(program) { node: PtNode, depth: Int ->
+        if(node is PtAssignment) {
+            val value = node.value
+            val functionName = when(value) {
+                is PtBuiltinFunctionCall -> value.name
+                is PtFunctionCall -> value.name
+                else -> null
+            }
+            if(functionName!=null) {
+                val stNode = st.lookup(functionName)
+                if (stNode is StRomSub) {
+                    require(node.children.size==stNode.returns.size+1) {
+                        "number of targets must match return values"
+                    }
+                    node.children.zip(stNode.returns).withIndex().forEach { (index, xx) ->
+                        val target = xx.first as PtAssignTarget
+                        val returnedRegister = xx.second.register.registerOrPair
+                        if(returnedRegister!=null && !target.void && target.identifier!=null) {
+                            if(isSame(target.identifier!!, xx.second.type, returnedRegister)) {
+                                // output register is already identical to target register, so it can become void
+                                val voidTarget = PtAssignTarget(true, target.position)
+                                node.children[index] = voidTarget
+                                voidTarget.parent = node
+                                changes++
+                            }
+                        }
+                    }
+                }
+                if(node.children.dropLast(1).all { (it as PtAssignTarget).void }) {
+                    // all targets are now void, the whole assignment can be discarded and replaced by just a (void) call to the subroutine
+                    val index = node.parent.children.indexOf(node)
+                    val voidCall = PtFunctionCall(functionName, true, value.type, value.position)
+                    value.children.forEach { voidCall.add(it) }
+                    node.parent.children[index] = voidCall
+                    voidCall.parent = node.parent
+                    changes++
+                }
+            }
+        }
+        true
+    }
+    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()
+        val identifierRegName = identifier.name.substringAfterLast('.')
+        /*
+            cx16.r?    UWORD
+            cx16.r?s   WORD
+            cx16.r?L   UBYTE
+            cx16.r?H   UBYTE
+            cx16.r?sL  BYTE
+            cx16.r?sH  BYTE
+         */
+        if(identifier.type in ByteDatatypes && type in ByteDatatypes) {
+            if(identifier.name.startsWith("cx16.$regname") && identifierRegName.startsWith(regname)) {
+                return identifierRegName.substring(2) in arrayOf("", "L", "sL")     // note: not the -H (msb) variants!
+            }
+        }
+        else if(identifier.type in WordDatatypes && type in WordDatatypes) {
+            if(identifier.name.startsWith("cx16.$regname") && identifierRegName.startsWith(regname)) {
+                return identifierRegName.substring(2) in arrayOf("", "s")
+            }
+        }
+    }
+    return false   // there are no identifiers directly corresponding to cpu registers
+}
+
+
 internal fun findScopeName(node: PtNode): String {
     var parent=node
     while(parent !is PtNamedNode)

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

@@ -19,3 +19,23 @@ class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by Cb
         fun viceMonListName(baseFilename: String) = "$baseFilename.vice-mon-list"
     }
 }
+
+
+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")
+}

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

@@ -4,9 +4,7 @@ import com.github.michaelbull.result.fold
 import prog8.code.core.Encoding
 import prog8.code.core.IStringEncoding
 import prog8.code.core.InternalCompilerException
-import prog8.code.target.cbm.AtasciiEncoding
-import prog8.code.target.cbm.IsoEncoding
-import prog8.code.target.cbm.PetsciiEncoding
+import prog8.code.target.encodings.*
 
 
 object Encoder: IStringEncoding {
@@ -18,6 +16,10 @@ object Encoder: IStringEncoding {
             Encoding.SCREENCODES -> PetsciiEncoding.encodeScreencode(str, true)
             Encoding.ISO -> IsoEncoding.encode(str)
             Encoding.ATASCII -> AtasciiEncoding.encode(str)
+            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(
@@ -31,6 +33,10 @@ object Encoder: IStringEncoding {
             Encoding.SCREENCODES -> PetsciiEncoding.decodeScreencode(bytes, true)
             Encoding.ISO -> IsoEncoding.decode(bytes)
             Encoding.ATASCII -> AtasciiEncoding.decode(bytes)
+            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

@@ -22,13 +22,8 @@ class AtariMachineDefinition: IMachineDefinition {
     override lateinit var golden: GoldenRam
 
     override fun getFloatAsmBytes(num: Number) = TODO("atari float asm bytes from number")
-
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return if (compilerOptions.output == OutputType.XEX)
-            listOf("syslib")
-        else
-            emptyList()
-    }
+    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 launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
         val emulatorName: String

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

@@ -25,11 +25,15 @@ class C128MachineDefinition: IMachineDefinition {
 
     override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
 
-    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 convertFloatToBytes(num: Double): List<UByte> {
+        val m5 = Mflpt5.fromNumber(num)
+        return listOf(m5.b0, m5.b1, m5.b2, m5.b3, m5.b4)
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==5) { "need 5 bytes" }
+        val m5 = Mflpt5(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])
+        return m5.toDouble()
     }
 
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {

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

@@ -26,11 +26,15 @@ class C64MachineDefinition: IMachineDefinition {
 
     override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
 
-    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 convertFloatToBytes(num: Double): List<UByte> {
+        val m5 = Mflpt5.fromNumber(num)
+        return listOf(m5.b0, m5.b1, m5.b2, m5.b3, m5.b4)
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==5) { "need 5 bytes" }
+        val m5 = Mflpt5(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])
+        return m5.toDouble()
     }
 
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {

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

@@ -24,11 +24,16 @@ class CX16MachineDefinition: IMachineDefinition {
     override lateinit var golden: GoldenRam
 
     override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
-    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 convertFloatToBytes(num: Double): List<UByte> {
+        val m5 = Mflpt5.fromNumber(num)
+        return listOf(m5.b0, m5.b1, m5.b2, m5.b3, m5.b4)
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==5) { "need 5 bytes" }
+        val m5 = Mflpt5(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])
+        return m5.toDouble()
     }
 
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {

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

@@ -1,4 +1,4 @@
-package prog8.code.target.cbm
+package prog8.code.target.encodings
 
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result

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

@@ -0,0 +1,69 @@
+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 Cp437Encoding {
+    val charset: Charset = Charset.forName("IBM437")
+
+    fun encode(str: String): Result<List<UByte>, CharConversionException> {
+        return try {
+            val mapped = str.map { chr ->
+                when (chr) {
+                    '\u0000' -> 0u
+                    '\u00a0' -> 255u
+                    '☺' -> 1u
+                    '☻' -> 2u
+                    '♥' -> 3u
+                    '♦' -> 4u
+                    '♣' -> 5u
+                    '♠' -> 6u
+                    '•' -> 7u
+                    '◘' -> 8u
+                    '○' -> 9u
+                    '◙' -> 10u
+                    '♂' -> 11u
+                    '♀' -> 12u
+                    '♪' -> 13u
+                    '♫' -> 14u
+                    '☼' -> 15u
+                    '►' -> 16u
+                    '◄' -> 17u
+                    '↕' -> 18u
+                    '‼' -> 19u
+                    '¶' -> 20u
+                    '§' -> 21u
+                    '▬' -> 22u
+                    '↨' -> 23u
+                    '↑' -> 24u
+                    '↓' -> 25u
+                    '→' -> 26u
+                    '←' -> 27u
+                    '∟' -> 28u
+                    '↔' -> 29u
+                    '▲' -> 30u
+                    '▼' -> 31u
+                    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/encodings/IsoEncoding.kt

@@ -1,4 +1,4 @@
-package prog8.code.target.cbm
+package prog8.code.target.encodings
 
 import com.github.michaelbull.result.Err
 import com.github.michaelbull.result.Ok
@@ -6,8 +6,8 @@ import com.github.michaelbull.result.Result
 import java.io.CharConversionException
 import java.nio.charset.Charset
 
-object IsoEncoding {
-    val charset: Charset = Charset.forName("ISO-8859-15")
+open class IsoEncodingBase(charsetName: String) {
+    val charset: Charset = Charset.forName(charsetName)
 
     fun encode(str: String): Result<List<UByte>, CharConversionException> {
         return try {
@@ -35,3 +35,8 @@ object IsoEncoding {
         }
     }
 }
+
+
+object IsoEncoding: IsoEncodingBase("ISO-8859-15")
+object IsoCyrillicEncoding: IsoEncodingBase("ISO-8859-5")
+object IsoEasternEncoding: IsoEncodingBase("ISO-8859-16")

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/encodings/PetsciiEncoding.kt

@@ -1,4 +1,4 @@
-package prog8.code.target.cbm
+package prog8.code.target.encodings
 
 import com.github.michaelbull.result.Err
 import com.github.michaelbull.result.Ok

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

@@ -25,11 +25,15 @@ class PETMachineDefinition: IMachineDefinition {
 
     override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
 
-    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 convertFloatToBytes(num: Double): List<UByte> {
+        val m5 = Mflpt5.fromNumber(num)
+        return listOf(m5.b0, m5.b1, m5.b2, m5.b3, m5.b4)
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==5) { "need 5 bytes" }
+        val m5 = Mflpt5(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])
+        return m5.toDouble()
     }
 
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {

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

@@ -30,8 +30,24 @@ class VirtualMachineDefinition: IMachineDefinition {
         return parts.joinToString(", ")
     }
 
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return listOf("syslib")
+    override fun convertFloatToBytes(num: Double): List<UByte> {
+        val bits = num.toBits().toULong()
+        val hexStr = bits.toString(16).padStart(16, '0')
+        val parts = hexStr.chunked(2).map { it.toInt(16).toUByte() }
+        return parts
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==8) { "need 8 bytes" }
+        val b0 = bytes[0].toLong() shl (8*7)
+        val b1 = bytes[1].toLong() shl (8*6)
+        val b2 = bytes[2].toLong() shl (8*5)
+        val b3 = bytes[3].toLong() shl (8*4)
+        val b4 = bytes[4].toLong() shl (8*3)
+        val b5 = bytes[5].toLong() shl (8*2)
+        val b6 = bytes[6].toLong() shl (8*1)
+        val b7 = bytes[7].toLong() shl (8*0)
+        return Double.fromBits(b0 or b1 or b2 or b3 or b4 or b5 or b6 or b7)
     }
 
     override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {

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

@@ -66,7 +66,7 @@ class AsmGen6502(val prefixSymbols: Boolean): ICodeGeneratorBackend {
                     if(node.type in SplitWordArrayTypes && (lookupName.endsWith("_lsb") || lookupName.endsWith("_msb"))) {
                         lookupName = lookupName.dropLast(4)
                     }
-                    val stNode = st.lookup(lookupName)!!
+                    val stNode = st.lookup(lookupName) ?: throw AssemblyError("unknown identifier $node")
                     if(stNode.astNode.definingBlock()?.options?.noSymbolPrefixing!=true) {
                         val index = node.parent.children.indexOf(node)
                         nodesToPrefix += node.parent to index
@@ -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()) {
@@ -587,7 +586,10 @@ class AsmGen6502Internal (
             is PtInlineAssembly -> translate(stmt)
             is PtBuiltinFunctionCall -> builtinFunctionsAsmGen.translateFunctioncallStatement(stmt)
             is PtFunctionCall -> functioncallAsmGen.translateFunctionCallStatement(stmt)
-            is PtAssignment -> assignmentAsmGen.translate(stmt)
+            is PtAssignment -> {
+                if(stmt.multiTarget) assignmentAsmGen.translateMultiAssign(stmt)
+                else assignmentAsmGen.translate(stmt)
+            }
             is PtAugmentedAssign -> assignmentAsmGen.translate(stmt)
             is PtJump -> {
                 val (asmLabel, indirect) = getJumpTarget(stmt)
@@ -817,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)
@@ -880,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")
@@ -1317,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()) {
@@ -65,8 +72,6 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
         numberOfOptimizations++
     }
 
-    // TODO more assembly peephole optimizations
-
     return numberOfOptimizations
 }
 
@@ -386,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 ")) ||
@@ -395,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
@@ -510,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)
@@ -579,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
 }
@@ -616,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

@@ -81,8 +81,8 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
             }
             is PtAddressOf -> false
             is PtIdentifier -> false
-            is PtMachineRegister -> false
-            is PtMemoryByte -> return usesOtherRegistersWhileEvaluating(arg.address)
+            is PtIrRegister -> false
+            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

@@ -70,7 +70,7 @@ internal class IfElseAsmGen(private val program: PtProgram,
             is PtNumber,
             is PtBool,
             is PtIdentifier,
-            is PtMachineRegister,
+            is PtIrRegister,
             is PtArrayIndexer,
             is PtPrefix,
             is PtBinaryExpression -> { /* no cmp necessary the lda has been done just prior */ }
@@ -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
@@ -193,7 +264,7 @@ internal class IfElseAsmGen(private val program: PtProgram,
                     else
                         translateIfElseBodies("beq", stmt)
                 } else {
-                    errors.warn("SLOW FALLBACK FOR 'IF' CODEGEN - ask for support", stmt.position)      // TODO should have no more of these at all
+                    errors.warn("SLOW FALLBACK FOR 'IF' CODEGEN - ask for support", stmt.position)      //  should not occur ;-)
                     assignConditionValueToRegisterAndTest(stmt.condition)
                     if(jumpAfterIf!=null)
                         translateJumpElseBodies("bne", "beq", jumpAfterIf, stmt.elseScope)
@@ -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/ProgramAndVarsGen.kt

@@ -635,8 +635,7 @@ internal class ProgramAndVarsGen(
             } else 0
 
         when (variable.dt) {
-            DataType.BOOL -> TODO("bool var to asm")
-            DataType.UBYTE -> asmgen.out("${variable.name}\t.byte  ${initialValue.toHex()}")
+            DataType.BOOL, DataType.UBYTE -> asmgen.out("${variable.name}\t.byte  ${initialValue.toHex()}")
             DataType.BYTE -> asmgen.out("${variable.name}\t.char  $initialValue")
             DataType.UWORD -> asmgen.out("${variable.name}\t.word  ${initialValue.toHex()}")
             DataType.WORD -> asmgen.out("${variable.name}\t.sint  $initialValue")

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/AnyExprAsmGen.kt

@@ -35,7 +35,7 @@ internal class AnyExprAsmGen(
                 require(expr.left.type in WordDatatypes && expr.right.type in WordDatatypes) {
                     "both operands must be words"
                 }
-                return assignWordBinExpr(expr)
+                throw AssemblyError("expression should have been handled otherwise: word ${expr.operator} at ${expr.position}")
             }
             DataType.FLOAT -> {
                 require(expr.left.type==DataType.FLOAT && expr.right.type==DataType.FLOAT) {
@@ -47,30 +47,6 @@ internal class AnyExprAsmGen(
         }
     }
 
-    private fun assignWordBinExpr(expr: PtBinaryExpression): Boolean {
-        when(expr.operator) {
-            "+" -> TODO("word + at ${expr.position}")
-            "-" -> TODO("word - at ${expr.position}")
-            "*" -> TODO("word * at ${expr.position}")
-            "/" -> TODO("word / at ${expr.position}")
-            "<<" -> TODO("word << at ${expr.position}")
-            ">>" -> TODO("word >> at ${expr.position}")
-            "%" -> TODO("word % at ${expr.position}")
-            "and" -> TODO("word logical and (with optional shortcircuit) ${expr.position}")
-            "or" -> TODO("word logical or (with optional shortcircuit) ${expr.position}")
-            "&" -> TODO("word and at ${expr.position}")
-            "|" -> TODO("word or at ${expr.position}")
-            "^", "xor" -> TODO("word xor at ${expr.position}")
-            "==" -> TODO("word == at ${expr.position}")
-            "!=" -> TODO("word != at ${expr.position}")
-            "<" -> TODO("word < at ${expr.position}")
-            "<=" -> TODO("word <= at ${expr.position}")
-            ">" -> TODO("word > at ${expr.position}")
-            ">=" -> TODO("word >= at ${expr.position}")
-            else -> return false
-        }
-    }
-
     private fun assignByteBinExpr(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
         when(expr.operator) {
             "+" -> {
@@ -89,21 +65,11 @@ internal class AnyExprAsmGen(
                 asmgen.assignRegister(RegisterOrPair.A, assign.target)
                 return true
             }
-            "*" -> {
-                TODO("byte * at ${expr.position}")
-            }
-            "/" -> {
-                TODO("byte / at ${expr.position}")
-            }
-            "<<" -> {
-                TODO("byte << at ${expr.position}")
-            }
-            ">>" -> {
-                TODO("byte >> at ${expr.position}")
-            }
-            "%" -> {
-                TODO("byte % at ${expr.position}")
-            }
+            "*" -> TODO("byte * at ${expr.position}")
+            "/" -> TODO("byte / at ${expr.position}")
+            "<<" -> TODO("byte << at ${expr.position}")
+            ">>" -> TODO("byte >> at ${expr.position}")
+            "%" -> TODO("byte % at ${expr.position}")
             "and" -> TODO("logical and (with optional shortcircuit) ${expr.position}")
             "or" -> TODO("logical or (with optional shortcircuit) ${expr.position}")
             "&" -> {
@@ -130,24 +96,12 @@ internal class AnyExprAsmGen(
                 asmgen.assignRegister(RegisterOrPair.A, assign.target)
                 return true
             }
-            "==" -> {
-                TODO("byte == at ${expr.position}")
-            }
-            "!=" -> {
-                TODO("byte != at ${expr.position}")
-            }
-            "<" -> {
-                TODO("byte < at ${expr.position}")
-            }
-            "<=" -> {
-                TODO("byte <= at ${expr.position}")
-            }
-            ">" -> {
-                TODO("byte > at ${expr.position}")
-            }
-            ">=" -> {
-                TODO("byte >= at ${expr.position}")
-            }
+            "==" -> TODO("byte == at ${expr.position}")
+            "!=" -> TODO("byte != at ${expr.position}")
+            "<" -> TODO("byte < at ${expr.position}")
+            "<=" -> TODO("byte <= at ${expr.position}")
+            ">" -> TODO("byte > at ${expr.position}")
+            ">=" -> TODO("byte >= at ${expr.position}")
             else -> return false
         }
     }

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

@@ -1,6 +1,8 @@
 package prog8.codegen.cpu6502.assignment
 
 import prog8.code.StMemVar
+import prog8.code.StRomSub
+import prog8.code.StRomSubParameter
 import prog8.code.StStaticVariable
 import prog8.code.ast.*
 import prog8.code.core.*
@@ -32,6 +34,145 @@ internal class AssignmentAsmGen(private val program: PtProgram,
         augmentableAsmGen.translate(assign, augmentedAssign.definingISub())
     }
 
+    fun translateMultiAssign(assignment: PtAssignment) {
+        val values = assignment.value as? PtFunctionCall
+            ?: throw AssemblyError("only function calls can return multiple values in a multi-assign")
+
+        val sub = asmgen.symbolTable.lookup(values.name) as? StRomSub
+            ?: throw AssemblyError("only asmsubs can return multiple values")
+
+        require(sub.returns.size>=2)
+        if(sub.returns.any { it.type==DataType.FLOAT })
+            TODO("deal with (multiple?) FP return registers")
+
+        asmgen.translate(values)
+
+        fun needsToSaveA(registersResults: List<Pair<StRomSubParameter, PtNode>>): Boolean =
+            if(registersResults.isEmpty())
+                false
+            else if(registersResults.all { (it.second as PtAssignTarget).identifier!=null})
+                false
+            else
+                true
+
+        fun assignCarryFlagResult(target: PtAssignTarget, saveA: Boolean) {
+            if(saveA) asmgen.out("  pha")
+            asmgen.out("  lda  #0  |  rol  a")
+            val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
+            assignRegisterByte(tgt, CpuRegister.A, false, false)
+            if(saveA) asmgen.out("  pla")
+        }
+
+        fun assignZeroFlagResult(target: PtAssignTarget, saveA: Boolean) {
+            if(saveA) asmgen.out("  pha")
+            asmgen.out("""
+                beq  +
+                lda  #0
+                beq  ++
++               lda  #1
++""")
+            val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
+            assignRegisterByte(tgt, CpuRegister.A, false, false)
+            if(saveA) asmgen.out("  pla")
+        }
+
+        fun assignNegativeFlagResult(target: PtAssignTarget, saveA: Boolean) {
+            if(saveA) asmgen.out("  pha")
+            asmgen.out("""
+                bmi  +
+                lda  #0
+                beq  ++
++               lda  #1
++""")
+            val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
+            assignRegisterByte(tgt, CpuRegister.A, false, false)
+            if(saveA) asmgen.out("  pla")
+        }
+
+        fun assignOverflowFlagResult(target: PtAssignTarget, saveA: Boolean) {
+            if(saveA) asmgen.out("  pha")
+            asmgen.out("""
+                bvs  +
+                lda  #0
+                beq  ++
++               lda  #1
++""")
+            val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
+            assignRegisterByte(tgt, CpuRegister.A, false, false)
+            if(saveA) asmgen.out("  pla")
+        }
+
+        fun assignRegisterResults(registersResults: List<Pair<StRomSubParameter, PtNode>>) {
+            registersResults.forEach { (returns, target) ->
+                target as PtAssignTarget
+                if(!target.void) {
+                    val targetIdent = target.identifier
+                    val targetMem = target.memory
+                    if(targetIdent!=null || targetMem!=null) {
+                        val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
+                        when(returns.type) {
+                            in ByteDatatypesWithBoolean -> {
+                                if(returns.register.registerOrPair in Cx16VirtualRegisters) {
+                                    assignVirtualRegister(tgt, returns.register.registerOrPair!!)
+                                } else {
+                                    assignRegisterByte(tgt, returns.register.registerOrPair!!.asCpuRegister(), false, false)
+                                }
+                            }
+                            in WordDatatypes -> {
+                                assignRegisterpairWord(tgt, returns.register.registerOrPair!!)
+                            }
+                            else -> throw AssemblyError("weird dt")
+                        }
+                    }
+                    else TODO("array target for multi-value assignment")        // Not done yet due to result register clobbering complexity
+                }
+            }
+        }
+
+        val assignmentTargets = assignment.children.dropLast(1)
+        if(sub.returns.size==assignmentTargets.size) {
+            // because we can only handle integer results right now we can just zip() it all up
+            val (statusFlagResults, registersResults) = sub.returns.zip(assignmentTargets).partition { it.first.register.statusflag!=null }
+            if(statusFlagResults.isNotEmpty()) {
+                if(statusFlagResults.size>1)
+                    TODO("handle multiple status flag results")
+                val (returns, target) = statusFlagResults.single()
+                target as PtAssignTarget
+                if(target.void) {
+                    // forget about the Carry status flag, only assign the normal return values
+                    assignRegisterResults(registersResults)
+                    return
+                }
+                if(registersResults.all {
+                    val tgt = it.second as PtAssignTarget
+                    tgt.void || tgt.identifier!=null})
+                {
+                    // all other results are just stored into identifiers directly so first handle those
+                    // (simple store instructions that don't modify the carry flag)
+                    assignRegisterResults(registersResults)
+                    return when(returns.register.statusflag!!) {
+                        Statusflag.Pc -> assignCarryFlagResult(target, false)
+                        Statusflag.Pz -> assignZeroFlagResult(target, false)
+                        Statusflag.Pv -> assignOverflowFlagResult(target, false)
+                        Statusflag.Pn -> assignNegativeFlagResult(target, false)
+                    }
+                }
+
+                val saveA = needsToSaveA(registersResults)
+                when(returns.register.statusflag!!) {
+                    Statusflag.Pc -> assignCarryFlagResult(target, saveA)
+                    Statusflag.Pz -> assignZeroFlagResult(target, saveA)
+                    Statusflag.Pv -> assignOverflowFlagResult(target, saveA)
+                    Statusflag.Pn -> assignNegativeFlagResult(target, saveA)
+                }
+            }
+            assignRegisterResults(registersResults)
+        } else {
+            throw AssemblyError("number of values and targets don't match")
+        }
+    }
+
+
     fun translateNormalAssignment(assign: AsmAssignment, scope: IPtSubroutine?) {
         when(assign.source.kind) {
             SourceStorageKind.LITERALBOOLEAN -> {
@@ -143,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 -> {
@@ -163,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 -> {
@@ -178,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 -> {
@@ -562,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)
@@ -597,7 +832,6 @@ internal class AssignmentAsmGen(private val program: PtProgram,
             assignTrue.add(target)
             assignTrue.add(PtNumber.fromBoolean(true, assign.position))
         } else {
-            require(assign.target.datatype in ByteDatatypes)
             when(assign.target.kind) {
                 TargetStorageKind.VARIABLE -> {
                     if(assign.target.datatype in WordDatatypes) {
@@ -614,11 +848,11 @@ 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 -> {
-                    val tgt = PtAssignTarget(assign.target.position)
+                    val tgt = PtAssignTarget(false, assign.target.position)
                     val targetmem = assign.target.memory!!
                     val mem = PtMemoryByte(targetmem.position)
                     mem.add(targetmem.address)
@@ -628,7 +862,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     assignTrue.add(PtNumber.fromBoolean(true, assign.position))
                 }
                 TargetStorageKind.ARRAY -> {
-                    val tgt = PtAssignTarget(assign.target.position)
+                    val tgt = PtAssignTarget(false, assign.target.position)
                     val targetarray = assign.target.array!!
                     val array = PtArrayIndexer(assign.target.datatype, targetarray.position)
                     array.add(targetarray.variable)
@@ -667,7 +901,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
     internal fun directIntoY(expr: PtExpression): Boolean {
         return when(expr) {
             is PtIdentifier -> true
-            is PtMachineRegister -> true
+            is PtIrRegister -> true
             is PtNumber -> true
             is PtBuiltinFunctionCall -> expr.name in arrayOf("lsb", "msb")
             else -> false
@@ -699,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)
@@ -870,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")
@@ -904,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")
@@ -968,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
                 }
@@ -1106,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
@@ -1115,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
@@ -1124,6 +1411,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                                 sbc  #>${right.number.toHex()}
                                 tay
                                 txa""")
+                        }
                     }
                     assignRegisterpairWord(target, RegisterOrPair.AY)
                     return true
@@ -1454,6 +1742,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     in ByteDatatypes -> {
                         assignExpressionToRegister(expr.left, RegisterOrPair.A, dt==DataType.BYTE)
                         asmgen.out("""
+                            cmp  #0
                             beq  +
                             lda  #1
 +                           eor  #1""")
@@ -1662,8 +1951,8 @@ internal class AssignmentAsmGen(private val program: PtProgram,
 
             when (valueDt) {
                 DataType.BOOL -> {
-                    if(targetDt in ByteDatatypes) {
-                        // optimization to assign boolean expression to byte target (just assign the 0 or 1 directly, no cast needed)
+                    if(targetDt in IntegerDatatypes) {
+                        // optimization to assign boolean expression to integer target (just assign the 0 or 1 directly)
                         val assignDirect = AsmAssignment(
                             AsmAssignSource.fromAstSource(value, program, asmgen),
                             target,
@@ -1672,7 +1961,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         )
                         assignExpression(assignDirect, target.scope)
                     } else {
-                        throw AssemblyError("expected bool or byte target type")
+                        TODO("assign bool to non-integer type $targetDt")
                     }
                 }
                 in ByteDatatypes -> {
@@ -2182,7 +2471,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         asmgen.out("""
                             clc
                             adc  #$constIndex
-                            bne  +
+                            bcc  +
                             iny
 +""")
                 }
@@ -2207,7 +2496,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     asmgen.out("""
                         clc
                         adc  P8ZP_SCRATCH_REG
-                        bne  +
+                        bcc  +
                         iny                            
 +""")
                 }
@@ -2217,7 +2506,7 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                         ldy  #>$sourceName
                         clc
                         adc  #<$sourceName
-                        bne  +
+                        bcc  +
                         iny
 +""")
                 }
@@ -3002,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("""
@@ -3045,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("""
@@ -3548,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
+                        """)
+                    }
                 }
             }
             "%" -> {

codeGenCpu6502/test/TestCodegen.kt

@@ -53,7 +53,7 @@ class TestCodegen: FunSpec({
         sub.add(PtVariable("xx", DataType.WORD, ZeropageWish.DONTCARE, PtNumber(DataType.WORD, 1.0, Position.DUMMY), null, Position.DUMMY))
 
         val assign = PtAugmentedAssign("+=", Position.DUMMY)
-        val target = PtAssignTarget(Position.DUMMY).also {
+        val target = PtAssignTarget(false, Position.DUMMY).also {
             val targetIdx = PtArrayIndexer(DataType.UBYTE, Position.DUMMY).also { idx ->
                 idx.add(PtIdentifier("main.start.particleX", DataType.ARRAY_UB, Position.DUMMY))
                 idx.add(PtNumber(DataType.UBYTE, 2.0, Position.DUMMY))
@@ -68,7 +68,7 @@ class TestCodegen: FunSpec({
         sub.add(assign)
 
         val prefixAssign = PtAugmentedAssign("-", Position.DUMMY)
-        val prefixTarget = PtAssignTarget(Position.DUMMY).also {
+        val prefixTarget = PtAssignTarget(false, Position.DUMMY).also {
             it.add(PtIdentifier("main.start.xx", DataType.WORD, Position.DUMMY))
         }
         prefixAssign.add(prefixTarget)
@@ -76,7 +76,7 @@ class TestCodegen: FunSpec({
         sub.add(prefixAssign)
 
         val numberAssign = PtAugmentedAssign("-=", Position.DUMMY)
-        val numberAssignTarget = PtAssignTarget(Position.DUMMY).also {
+        val numberAssignTarget = PtAssignTarget(false, Position.DUMMY).also {
             it.add(PtIdentifier("main.start.xx", DataType.WORD, Position.DUMMY))
         }
         numberAssign.add(numberAssignTarget)
@@ -84,7 +84,7 @@ class TestCodegen: FunSpec({
         sub.add(numberAssign)
 
         val cxregAssign = PtAugmentedAssign("+=", Position.DUMMY)
-        val cxregAssignTarget = PtAssignTarget(Position.DUMMY).also {
+        val cxregAssignTarget = PtAssignTarget(false, Position.DUMMY).also {
             it.add(PtIdentifier("main.start.xx", DataType.WORD, Position.DUMMY))
         }
         cxregAssign.add(cxregAssignTarget)

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

@@ -1,5 +1,7 @@
 package prog8.codegen.intermediate
 
+import prog8.code.StRomSub
+import prog8.code.StRomSubParameter
 import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.intermediate.*
@@ -8,16 +10,73 @@ import prog8.intermediate.*
 internal class AssignmentGen(private val codeGen: IRCodeGen, private val expressionEval: ExpressionGen) {
 
     internal fun translate(assignment: PtAssignment): IRCodeChunks {
-        if(assignment.target.children.single() is PtMachineRegister)
-            throw AssemblyError("assigning to a register should be done by just evaluating the expression into resultregister")
+        if(assignment.multiTarget) {
+            val values = assignment.value as? PtFunctionCall
+                ?: throw AssemblyError("only function calls can return multiple values in a multi-assign")
 
-        val chunks = translateRegularAssign(assignment)
-        chunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(assignment.position)
-        return chunks
+            val sub = codeGen.symbolTable.lookup(values.name) as? StRomSub
+                ?: throw AssemblyError("only asmsubs can return multiple values")
+
+            val result = mutableListOf<IRCodeChunkBase>()
+            val funcCall = this.expressionEval.translate(values)
+            require(funcCall.multipleResultRegs.size + funcCall.multipleResultFpRegs.size >= 2)
+            if(funcCall.multipleResultFpRegs.isNotEmpty())
+                TODO("deal with (multiple?) FP return registers")
+            val assignmentTargets = assignment.children.dropLast(1)
+            addToResult(result, funcCall, funcCall.resultReg, funcCall.resultFpReg)
+            if(sub.returns.size==assignmentTargets.size) {
+                // Targets and values match. Assign all the things. Skip 'void' targets.
+                sub.returns.zip(assignmentTargets).zip(funcCall.multipleResultRegs).forEach {
+                    val target = it.first.second as PtAssignTarget
+                    if(!target.void) {
+                        val regNumber = it.second
+                        val returns = it.first.first
+                        result += assignCpuRegister(returns, regNumber, target)
+                    }
+                }
+            } else {
+                throw AssemblyError("number of values and targets don't match")
+            }
+            return result
+        } else {
+            if (assignment.target.children.single() is PtIrRegister)
+                throw AssemblyError("assigning to a register should be done by just evaluating the expression into resultregister")
+
+            return translateRegularAssign(assignment)
+        }
+    }
+
+    private fun assignCpuRegister(returns: StRomSubParameter, regNum: Int, target: PtAssignTarget): IRCodeChunks {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val loadCpuRegInstr = when(returns.register.registerOrPair) {
+            RegisterOrPair.A -> IRInstruction(Opcode.LOADHA, IRDataType.BYTE, reg1=regNum)
+            RegisterOrPair.X -> IRInstruction(Opcode.LOADHX, IRDataType.BYTE, reg1=regNum)
+            RegisterOrPair.Y -> IRInstruction(Opcode.LOADHY, IRDataType.BYTE, reg1=regNum)
+            RegisterOrPair.AX -> IRInstruction(Opcode.LOADHAX, IRDataType.WORD, reg1=regNum)
+            RegisterOrPair.AY -> IRInstruction(Opcode.LOADHAY, IRDataType.WORD, reg1=regNum)
+            RegisterOrPair.XY -> IRInstruction(Opcode.LOADHXY, IRDataType.WORD, reg1=regNum)
+            in Cx16VirtualRegisters -> IRInstruction(Opcode.LOADM, IRDataType.WORD, reg1=regNum, labelSymbol = "cx16.${returns.register.registerOrPair.toString().lowercase()}")
+            null -> {
+                when(returns.register.statusflag) {
+                    Statusflag.Pc -> IRInstruction(Opcode.LOADHA, IRDataType.BYTE, reg1=regNum)
+                    else -> throw AssemblyError("weird statusflag as returnvalue")
+                }
+            }
+            else -> throw AssemblyError("cannot load register")
+        }
+        addInstr(result, loadCpuRegInstr, null)
+
+        // build an assignment to store the value in the actual target.
+        val assign = PtAssignment(target.position)
+        assign.add(target)
+        assign.add(PtIrRegister(regNum, target.type, target.position))
+        result += translate(assign)
+        return result
     }
 
     internal fun translate(augAssign: PtAugmentedAssign): IRCodeChunks {
-        if(augAssign.target.children.single() is PtMachineRegister)
+        // augmented assignment always has just a single target
+        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
@@ -28,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)
@@ -50,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
     }
@@ -81,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()
 
@@ -270,11 +328,11 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                     else
                         throw AssemblyError("assignment value and target dt mismatch")
                 } else false
-                if (assignment.value is PtMachineRegister) {
-                    valueRegister = (assignment.value as PtMachineRegister).register
+                if (assignment.value is PtIrRegister) {
+                    valueRegister = (assignment.value as PtIrRegister).register
                     if(extendByteToWord) {
                         valueRegister = codeGen.registers.nextFree()
-                        addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=valueRegister, reg2=(assignment.value as PtMachineRegister).register), null)
+                        addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=valueRegister, reg2=(assignment.value as PtIrRegister).register), null)
                     }
                 } else {
                     val tr = expressionEval.translateExpression(assignment.value)
@@ -444,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)
@@ -1334,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?
@@ -1357,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()
@@ -854,10 +720,10 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
     private fun assignRegisterTo(target: PtExpression, register: Int): IRCodeChunks {
         val assignment = PtAssignment(target.position)
-        val assignTarget = PtAssignTarget(target.position)
+        val assignTarget = PtAssignTarget(false, target.position)
         assignTarget.children.add(target)
         assignment.children.add(assignTarget)
-        assignment.children.add(PtMachineRegister(register, target.type, target.position))
+        assignment.children.add(PtIrRegister(register, target.type, target.position))
         val result = mutableListOf<IRCodeChunkBase>()
         result += codeGen.translateNode(assignment)
         return result

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.*
@@ -7,8 +8,11 @@ import prog8.code.core.*
 import prog8.intermediate.*
 
 
-internal class ExpressionCodeResult(val chunks: IRCodeChunks, val dt: IRDataType, val resultReg: Int, val resultFpReg: Int) {
-    constructor(chunks: IRCodeChunk, dt: IRDataType, resultReg: Int, resultFpReg: Int) : this(listOf(chunks), dt, resultReg, resultFpReg)
+internal class ExpressionCodeResult(val chunks: IRCodeChunks, val dt: IRDataType, val resultReg: Int, val resultFpReg: Int,
+                                    val multipleResultRegs: List<Int> = emptyList(), val multipleResultFpRegs: List<Int> = emptyList()
+) {
+    constructor(chunk: IRCodeChunk, dt: IRDataType, resultReg: Int, resultFpReg: Int, multipleResultRegs: List<Int> = emptyList(), multipleResultFpRegs: List<Int> = emptyList())
+            : this(listOf(chunk), dt, resultReg, resultFpReg, multipleResultRegs, multipleResultFpRegs)
 
     companion object {
         val EMPTY: ExpressionCodeResult = ExpressionCodeResult(emptyList(), IRDataType.BYTE, -1, -1)
@@ -24,7 +28,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
 
     fun translateExpression(expr: PtExpression): ExpressionCodeResult {
         return when (expr) {
-            is PtMachineRegister -> {
+            is PtIrRegister -> {
                 ExpressionCodeResult(emptyList(), irType(expr.type), expr.register, -1)
             }
             is PtBool -> {
@@ -448,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)
@@ -463,7 +496,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                         argRegisters.add(FunctionCallArgs.ArgumentSpec(parameter.name, null, FunctionCallArgs.RegSpec(paramDt, tr.resultReg, null)))
                     result += tr.chunks
                 }
-                // return value
+                // return value (always singular for normal Subs)
                 val returnRegSpec = if(fcall.void) null else {
                     val returnIrType = irType(callTarget.returnType!!)
                     if(returnIrType==IRDataType.FLOAT)
@@ -472,7 +505,8 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                         FunctionCallArgs.RegSpec(returnIrType, codeGen.registers.nextFree(), null)
                 }
                 // create the call
-                addInstr(result, IRInstruction(Opcode.CALL, labelSymbol = fcall.name, fcallArgs = FunctionCallArgs(argRegisters, returnRegSpec)), null)
+                addInstr(result, IRInstruction(Opcode.CALL, labelSymbol = fcall.name,
+                    fcallArgs = FunctionCallArgs(argRegisters, if(returnRegSpec==null) emptyList() else listOf(returnRegSpec))), null)
                 return if(fcall.void)
                     ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
                 else if(fcall.type==DataType.FLOAT)
@@ -493,44 +527,57 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     else
                         argRegisters.add(FunctionCallArgs.ArgumentSpec("", null, FunctionCallArgs.RegSpec(paramDt, tr.resultReg, parameter.register)))
                     result += tr.chunks
+                    when(parameter.register.registerOrPair) {
+                        RegisterOrPair.A -> addInstr(result, IRInstruction(Opcode.STOREHA, IRDataType.BYTE, reg1=tr.resultReg), null)
+                        RegisterOrPair.X -> addInstr(result, IRInstruction(Opcode.STOREHX, IRDataType.BYTE, reg1=tr.resultReg), null)
+                        RegisterOrPair.Y -> addInstr(result, IRInstruction(Opcode.STOREHY, IRDataType.BYTE, reg1=tr.resultReg), null)
+                        RegisterOrPair.AX -> addInstr(result, IRInstruction(Opcode.STOREHAX, IRDataType.WORD, reg1=tr.resultReg), null)
+                        RegisterOrPair.AY -> addInstr(result, IRInstruction(Opcode.STOREHAY, IRDataType.WORD, reg1=tr.resultReg), null)
+                        RegisterOrPair.XY -> addInstr(result, IRInstruction(Opcode.STOREHXY, IRDataType.WORD, reg1=tr.resultReg), null)
+                        in Cx16VirtualRegisters -> {
+                            addInstr(result, IRInstruction(Opcode.STOREM, paramDt, reg1=tr.resultReg, labelSymbol = "cx16.${parameter.register.registerOrPair.toString().lowercase()}"), null)
+                        }
+                        null -> when(parameter.register.statusflag) {
+                            // TODO: do the statusflag argument as last
+                            Statusflag.Pc -> addInstr(result, IRInstruction(Opcode.LSR, paramDt, reg1=tr.resultReg), null)
+                            else -> throw AssemblyError("weird statusflag as param")
+                        }
+                        else -> throw AssemblyError("unsupported register arg")
+                    }
                 }
-                // return value
-                var statusFlagResult: Statusflag? = null
+
+                if(callTarget.returns.size>1)
+                    return callRomSubWithMultipleReturnValues(callTarget, fcall, argRegisters, result)
+
+                // return a single value (or nothing)
                 val returnRegSpec = if(fcall.void) null else {
                     if(callTarget.returns.isEmpty())
                         null
-                    else if(callTarget.returns.size==1) {
+                    else {
                         val returns = callTarget.returns[0]
                         val returnIrType = irType(returns.type)
-                        if(returnIrType==IRDataType.FLOAT)
+                        if (returnIrType == IRDataType.FLOAT)
                             FunctionCallArgs.RegSpec(returnIrType, codeGen.registers.nextFreeFloat(), returns.register)
                         else {
-                            statusFlagResult = returns.register.statusflag
-                            val returnRegister = if(statusFlagResult==null) codeGen.registers.nextFree() else -1
+                            val returnRegister = codeGen.registers.nextFree()
                             FunctionCallArgs.RegSpec(returnIrType, returnRegister, returns.register)
                         }
-                    } else {
-                        // multiple return values: take the first *register* (not status flag) return value and ignore the rest.
-                        val returns = callTarget.returns.first { it.register.registerOrPair!=null }
-                        val returnIrType = irType(returns.type)
-                        if(returnIrType==IRDataType.FLOAT)
-                            FunctionCallArgs.RegSpec(returnIrType, codeGen.registers.nextFreeFloat(), returns.register)
-                        else
-                            FunctionCallArgs.RegSpec(returnIrType, codeGen.registers.nextFree(), returns.register)
                     }
                 }
                 // create the call
+                val returnRegs = if(returnRegSpec==null) emptyList() else listOf(returnRegSpec)
                 val call =
                     if(callTarget.address==null)
-                        IRInstruction(Opcode.CALL, labelSymbol = fcall.name, fcallArgs = FunctionCallArgs(argRegisters, returnRegSpec))
+                        IRInstruction(Opcode.CALL, labelSymbol = fcall.name, fcallArgs = FunctionCallArgs(argRegisters, returnRegs))
                     else
-                        IRInstruction(Opcode.CALL, address = callTarget.address!!.toInt(), fcallArgs = FunctionCallArgs(argRegisters, returnRegSpec))
+                        IRInstruction(Opcode.CALL, address = callTarget.address!!.toInt(), fcallArgs = FunctionCallArgs(argRegisters, returnRegs))
                 addInstr(result, call, null)
                 var finalReturnRegister = returnRegSpec?.registerNum ?: -1
 
                 if(fcall.parent is PtAssignment || fcall.parent is PtTypeCast) {
                     // look if the status flag bit should actually be returned as a 0/1 byte value in a result register (so it can be assigned)
-                    if(statusFlagResult!=null && returnRegSpec!=null) {
+                    val statusFlagResult = returnRegSpec?.cpuRegister?.statusflag
+                    if(statusFlagResult!=null) {
                         // assign status flag bit to the return value register
                         finalReturnRegister = returnRegSpec.registerNum
                         if(finalReturnRegister<0)
@@ -573,6 +620,62 @@ 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,
+        argRegisters: MutableList<FunctionCallArgs.ArgumentSpec>,
+        result: MutableList<IRCodeChunkBase>
+    ): ExpressionCodeResult {
+        // return multiple values
+        val returnRegisters = callTarget.returns.map {
+            val regnum = if(it.type==DataType.FLOAT) codeGen.registers.nextFreeFloat() else codeGen.registers.nextFree()
+            FunctionCallArgs.RegSpec(irType(it.type), regnum, it.register)
+        }
+        // create the call
+        val call =
+            if(callTarget.address==null)
+                IRInstruction(Opcode.CALL, labelSymbol = fcall.name, fcallArgs = FunctionCallArgs(argRegisters, returnRegisters))
+            else
+                IRInstruction(Opcode.CALL, address = callTarget.address!!.toInt(), fcallArgs = FunctionCallArgs(argRegisters, returnRegisters))
+        addInstr(result, call, null)
+        val resultRegs = returnRegisters.filter{it.dt!=IRDataType.FLOAT}.map{it.registerNum}
+        val resultFpRegs = returnRegisters.filter{it.dt==IRDataType.FLOAT}.map{it.registerNum}
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1, resultRegs, resultFpRegs)
+    }
+
     private fun operatorGreaterThan(
         binExpr: PtBinaryExpression,
         vmDt: IRDataType,
@@ -746,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()) {
@@ -1451,6 +1479,10 @@ class IRCodeGen(
         }
 
         when(val cond=ifElse.condition) {
+            is PtBool -> {
+                // normally this will be optimized away, but not with -noopt
+                translateSimple(cond, Opcode.BSTEQ)
+            }
             is PtTypeCast -> {
                 require(cond.type==DataType.BOOL && cond.value.type in NumericDatatypes)
                 translateSimple(cond, Opcode.BSTEQ)
@@ -1502,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
@@ -1650,7 +1681,8 @@ class IRCodeGen(
             val args = params.map { (dt, reg)->
                 FunctionCallArgs.ArgumentSpec("", null, FunctionCallArgs.RegSpec(dt, reg, null))
             }
-            val returnSpec = if(returns==null) null else FunctionCallArgs.RegSpec(returns.first, returns.second, null)
+            // for now, syscalls have 0 or 1 return value
+            val returnSpec = if(returns==null) emptyList() else listOf(FunctionCallArgs.RegSpec(returns.first, returns.second, null))
             it += IRInstruction(Opcode.SYSCALL, immediate = syscall.number, fcallArgs = FunctionCallArgs(args, returnSpec))
         }
     }

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

@@ -52,15 +52,12 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                                 || removeWeirdBranches(chunk1, chunk2, indexedInstructions)
                                 || removeDoubleSecClc(chunk1, indexedInstructions)
                                 || cleanupPushPop(chunk1, indexedInstructions)
-                        // TODO other optimizations
                     } while (changed)
                 }
             }
             removeEmptyChunks(sub)
         }
 
-        // TODO also do register optimization step here at the end?
-
         irprog.linkChunks()  // re-link
     }
 
@@ -182,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
@@ -267,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
     }
@@ -433,21 +447,34 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
     }
 
     private fun removeDoubleLoadsAndStores(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
-        return false
-
-/*
         var changed = false
         indexedInstructions.forEach { (idx, ins) ->
+            if(ins.opcode==Opcode.STOREM) {
+                val prev = indexedInstructions[idx-1].value
+                if(prev.opcode==Opcode.LOADM) {
+                    // loadm.X rX,something | storem.X rX,something ?? -> get rid of the store.
+                    if(ins.labelSymbol!=null && ins.labelSymbol==prev.labelSymbol && ins.labelSymbolOffset==prev.labelSymbolOffset) {
+                        changed=true
+                        chunk.instructions.removeAt(idx)
+                    }
+                    else if(ins.address!=null && ins.address==prev.address) {
+                        changed=true
+                        chunk.instructions.removeAt(idx)
+                    }
+                }
+            }
 
-            // TODO: detect multiple loads to the same target registers, only keep first (if source is not I/O memory)
-            // TODO: detect multiple stores to the same target, only keep first (if target is not I/O memory)
-            // TODO: detect multiple float ffrom/fto to the same target, only keep first
-            // TODO: detect subsequent same xors/nots/negs, remove the pairs completely as they cancel out
-            // TODO: detect multiple same ands, ors; only keep first
-            // TODO: (hard) detect multiple registers being assigned the same value (and not changed) - use only 1 of them
+/*
+    Possible other optimizations:
+            // detect multiple loads to the same target registers, only keep first (if source is not I/O memory)
+            // detect multiple stores to the same target, only keep first (if target is not I/O memory)
+            // detect multiple float ffrom/fto to the same target, only keep first
+            // detect subsequent same xors/nots/negs, remove the pairs completely as they cancel out
+            // detect multiple same ands, ors; only keep first
+            // detect multiple registers being assigned the same value (and not changed) - use only 1 of them  (hard!)
             // ...
+*/
         }
         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") {

codeGenIntermediate/test/TestVmCodeGen.kt

@@ -50,7 +50,7 @@ class TestVmCodeGen: FunSpec({
         sub.add(PtVariable("xx", DataType.WORD, ZeropageWish.DONTCARE, PtNumber(DataType.WORD, 1.0, Position.DUMMY), null, Position.DUMMY))
 
         val assign = PtAugmentedAssign("+=", Position.DUMMY)
-        val target = PtAssignTarget(Position.DUMMY).also {
+        val target = PtAssignTarget(false, Position.DUMMY).also {
             val targetIdx = PtArrayIndexer(DataType.UBYTE, Position.DUMMY).also { idx ->
                 idx.add(PtIdentifier("main.start.particleX", DataType.ARRAY_UB, Position.DUMMY))
                 idx.add(PtNumber(DataType.UBYTE, 2.0, Position.DUMMY))
@@ -65,7 +65,7 @@ class TestVmCodeGen: FunSpec({
         sub.add(assign)
 
         val prefixAssign = PtAugmentedAssign("-", Position.DUMMY)
-        val prefixTarget = PtAssignTarget(Position.DUMMY).also {
+        val prefixTarget = PtAssignTarget(false, Position.DUMMY).also {
             it.add(PtIdentifier("main.start.xx", DataType.WORD, Position.DUMMY))
         }
         prefixAssign.add(prefixTarget)
@@ -73,7 +73,7 @@ class TestVmCodeGen: FunSpec({
         sub.add(prefixAssign)
 
         val numberAssign = PtAugmentedAssign("+=", Position.DUMMY)
-        val numberAssignTarget = PtAssignTarget(Position.DUMMY).also {
+        val numberAssignTarget = PtAssignTarget(false, Position.DUMMY).also {
             it.add(PtIdentifier("main.start.xx", DataType.WORD, Position.DUMMY))
         }
         numberAssign.add(numberAssignTarget)
@@ -81,7 +81,7 @@ class TestVmCodeGen: FunSpec({
         sub.add(numberAssign)
 
         val cxregAssign = PtAugmentedAssign("+=", Position.DUMMY)
-        val cxregAssignTarget = PtAssignTarget(Position.DUMMY).also {
+        val cxregAssignTarget = PtAssignTarget(false, Position.DUMMY).also {
             it.add(PtIdentifier("main.start.xx", DataType.WORD, Position.DUMMY))
         }
         cxregAssign.add(cxregAssignTarget)

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))
             }
         }
@@ -435,7 +435,6 @@ class ConstantFoldingOptimizer(private val program: Program, private val errors:
        subrightIsConst: Boolean): IAstModification?
     {
         // NOTE: THESE REORDERINGS ARE ONLY VALID FOR FLOATING POINT CONSTANTS
-        // TODO: this implements only a small set of possible reorderings at this time, we could perhaps add more
 
         if(expr.operator==subExpr.operator) {
             // both operators are the same.

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -75,10 +75,11 @@ class VarConstantValueTypeAdjuster(
                     val declValue = decl.value?.constValue(program)
                     if (declValue != null) {
                         // variable is never written to, so it can be replaced with a constant, IF the value is a constant
-                        errors.info("variable is never written to and was replaced by a constant", decl.position)
+                        errors.info("variable '${decl.name}' is never written to and was replaced by a constant", decl.position)
                         val const = VarDecl(VarDeclType.CONST, decl.origin, decl.datatype, decl.zeropage, decl.arraysize, decl.name, decl.names, declValue, decl.sharedWithAsm, decl.splitArray, decl.position)
+                        decl.value = null
                         return listOf(
-                            IAstModification.ReplaceNode(decl, const, parent),
+                            IAstModification.ReplaceNode(decl, const, parent)
                         )
                     }
                 }
@@ -94,7 +95,7 @@ class VarConstantValueTypeAdjuster(
                         )
                     }
                     // variable only has a single write and it is the initialization value, so it can be replaced with a constant, IF the value is a constant
-                    errors.info("variable is never written to and was replaced by a constant", decl.position)
+                    errors.info("variable '${decl.name}' is never written to and was replaced by a constant", decl.position)
                     val const = VarDecl(VarDeclType.CONST, decl.origin, decl.datatype, decl.zeropage, decl.arraysize, decl.name, decl.names, singleAssignment.value, decl.sharedWithAsm, decl.splitArray, decl.position)
                     return listOf(
                         IAstModification.ReplaceNode(decl, const, parent),
@@ -103,15 +104,15 @@ class VarConstantValueTypeAdjuster(
                 }
             }
             /*
-        TODO: need to check if there are no variable usages between the declaration and the assignment (because these rely on the original initialization value)
-        if(writes.size==2) {
-            val firstAssignment = writes[0].parent as? Assignment
-            val secondAssignment = writes[1].parent as? Assignment
-            if(firstAssignment?.origin==AssignmentOrigin.VARINIT && secondAssignment?.value?.constValue(program)!=null) {
-                errors.warn("variable is only assigned once here, consider using this as the initialization value in the declaration instead", secondAssignment.position)
+            TODO: need to check if there are no variable usages between the declaration and the assignment (because these rely on the original initialization value)
+            if(writes.size==2) {
+                val firstAssignment = writes[0].parent as? Assignment
+                val secondAssignment = writes[1].parent as? Assignment
+                if(firstAssignment?.origin==AssignmentOrigin.VARINIT && secondAssignment?.value?.constValue(program)!=null) {
+                    errors.warn("variable is only assigned once here, consider using this as the initialization value in the declaration instead", secondAssignment.position)
+                }
             }
-        }
-        */
+            */
         }
 
         return noModifications
@@ -153,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
@@ -309,7 +309,7 @@ internal class ConstantIdentifierReplacer(
                 val add = BinaryExpression(NumericLiteral(cval.type, cval.number, identifier.position), "+", arrayIdx.indexer.indexExpr, identifier.position)
                 return if(arrayIdx.parent is AssignTarget) {
                     val memwrite = DirectMemoryWrite(add, identifier.position)
-                    val assignTarget = AssignTarget(null, null, memwrite, identifier.position)
+                    val assignTarget = AssignTarget(null, null, memwrite, null, false, identifier.position)
                     listOf(IAstModification.ReplaceNode(arrayIdx.parent, assignTarget, arrayIdx.parent.parent))
                 } else {
                     val memread = DirectMemoryRead(add, identifier.position)

codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -4,7 +4,6 @@ import prog8.ast.*
 import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.AnonymousScope
-import prog8.ast.statements.Assignment
 import prog8.ast.statements.IfElse
 import prog8.ast.statements.Jump
 import prog8.ast.walk.AstWalker
@@ -14,12 +13,7 @@ import kotlin.math.abs
 import kotlin.math.log2
 import kotlin.math.pow
 
-// TODO add more peephole expression optimizations? Investigate what optimizations binaryen has?
-
 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>()
 
@@ -107,13 +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")
-
-        // NonBinaryExpression  <associativeoperator>  BinaryExpression  -->  BinaryExpression  <associativeoperator>  NonBinaryExpression
-        if (expr.operator in AssociativeOperators && expr.left !is BinaryExpression && expr.right is BinaryExpression) {
-            if(parent !is Assignment || !(expr.left isSameAs parent.target) && maySwapOperandOrder(expr))
-                return listOf(IAstModification.SwapOperands(expr))
-        }
+            return noModifications
 
         // X + (-A)  -->  X - A
         if (expr.operator == "+" && (expr.right as? PrefixExpression)?.operator == "-") {
@@ -249,10 +237,13 @@ class ExpressionSimplifier(private val program: Program, private val options: Co
         // optimize boolean constant comparisons
         if(expr.operator=="==") {
             if(rightDt==DataType.BOOL && leftDt==DataType.BOOL) {
-                if(rightVal?.asBooleanValue==true)
-                    return listOf(IAstModification.ReplaceNode(expr, expr.left, parent))
-                else
-                    return listOf(IAstModification.ReplaceNode(expr, PrefixExpression("not", expr.left, expr.position), parent))
+                val rightConstBool = rightVal?.asBooleanValue
+                if(rightConstBool!=null) {
+                    return if(rightConstBool)
+                        listOf(IAstModification.ReplaceNode(expr, expr.left, parent))
+                    else
+                        listOf(IAstModification.ReplaceNode(expr, PrefixExpression("not", expr.left, expr.position), parent))
+                }
             }
             if (rightVal?.number == 1.0) {
                 if (options.strictBool) {
@@ -692,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
@@ -717,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 == "/") {
@@ -744,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),  TODO is this correct???
-                        // 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)
                     }
                 }
@@ -801,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))
             }
         }
@@ -162,7 +163,7 @@ class StatementOptimizer(private val program: Program,
                 // for loop over a (constant) range of just a single value-- optimize the loop away
                 // loopvar/reg = range value , follow by block
                 val scope = AnonymousScope(mutableListOf(), forLoop.position)
-                scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), range.from, AssignmentOrigin.OPTIMIZER, forLoop.position))
+                scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, null, false, forLoop.position), range.from, AssignmentOrigin.OPTIMIZER, forLoop.position))
                 scope.statements.addAll(forLoop.body.statements)
                 return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
             }
@@ -177,7 +178,7 @@ class StatementOptimizer(private val program: Program,
                     val character = options.compTarget.encodeString(sv.value, sv.encoding)[0]
                     val byte = NumericLiteral(DataType.UBYTE, character.toDouble(), iterable.position)
                     val scope = AnonymousScope(mutableListOf(), forLoop.position)
-                    scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), byte, AssignmentOrigin.OPTIMIZER, forLoop.position))
+                    scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, null, false, forLoop.position), byte, AssignmentOrigin.OPTIMIZER, forLoop.position))
                     scope.statements.addAll(forLoop.body.statements)
                     return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
                 }
@@ -190,7 +191,7 @@ class StatementOptimizer(private val program: Program,
                     if(av!=null) {
                         val scope = AnonymousScope(mutableListOf(), forLoop.position)
                         scope.statements.add(Assignment(
-                                AssignTarget(forLoop.loopVar, null, null, forLoop.position), NumericLiteral.optimalInteger(av.toInt(), iterable.position),
+                                AssignTarget(forLoop.loopVar, null, null, null, false, forLoop.position), NumericLiteral.optimalInteger(av.toInt(), iterable.position),
                                 AssignmentOrigin.OPTIMIZER, forLoop.position))
                         scope.statements.addAll(forLoop.body.statements)
                         return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
@@ -206,7 +207,7 @@ class StatementOptimizer(private val program: Program,
                 val pos = forLoop.position
                 val loopVar = forLoop.loopVar
                 val addSubOne = BinaryExpression(loopVar.copy(), if(inc) "+" else "-", NumericLiteral.optimalInteger(1, pos), pos, false)
-                return Assignment(AssignTarget(loopVar.copy(), null, null, pos), addSubOne, AssignmentOrigin.USERCODE, pos)
+                return Assignment(AssignTarget(loopVar.copy(), null, null, null, false, pos), addSubOne, AssignmentOrigin.USERCODE, pos)
             }
 
             if (range != null && range.to.constValue(program)?.number == 0.0 && range.step.constValue(program)?.number==-1.0) {
@@ -219,7 +220,7 @@ class StatementOptimizer(private val program: Program,
                     val decOne = incOrDec(false)
                     forLoop.body.statements.add(decOne)
                     val replacement = AnonymousScope(mutableListOf(
-                        Assignment(AssignTarget(forLoop.loopVar.copy(), null, null, pos),
+                        Assignment(AssignTarget(forLoop.loopVar.copy(), null, null, null, false, pos),
                             fromExpr, AssignmentOrigin.OPTIMIZER, pos),
                         UntilLoop(forLoop.body, condition, pos)
                     ), pos)
@@ -454,12 +455,6 @@ class StatementOptimizer(private val program: Program,
 
     override fun after(whenStmt: When, parent: Node): Iterable<IAstModification> {
 
-        fun replaceWithIf(condition: Expression, trueBlock: AnonymousScope, elseBlock: AnonymousScope?): List<IAstModification> {
-            val ifStmt = IfElse(condition, trueBlock, elseBlock ?: AnonymousScope(mutableListOf(), whenStmt.position), whenStmt.position)
-            errors.info("for boolean condition a normal if statement is preferred", whenStmt.position)
-            return listOf(IAstModification.ReplaceNode(whenStmt, ifStmt, parent))
-        }
-
         val constantValue = whenStmt.condition.constValue(program)?.number
         if(constantValue!=null) {
             // when condition is a constant

codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -69,14 +69,14 @@ class UnusedCodeRemover(private val program: Program,
     override fun after(block: Block, parent: Node): Iterable<IAstModification> {
         if("force_output" !in block.options()) {
             if (block.containsNoCodeNorVars) {
-                if(block.name != internedStringsModuleName) {
+                if(block.name != internedStringsModuleName && "ignore_unused" !in block.options()) {
                     if(!block.statements.any { it is Subroutine && it.hasBeenInlined })
                         errors.info("removing unused block '${block.name}'", block.position)
                 }
                 return listOf(IAstModification.Remove(block, parent as IStatementContainer))
             }
             if(callgraph.unused(block)) {
-                if(block.statements.any{ it !is VarDecl || it.type== VarDeclType.VAR}) {
+                if(block.statements.any{ it !is VarDecl || it.type== VarDeclType.VAR} && "ignore_unused" !in block.options()) {
                     if(!block.statements.any { it is Subroutine && it.hasBeenInlined })
                         errors.info("removing unused block '${block.name}'", block.position)
                 }
@@ -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/atari/textio.p8

@@ -3,7 +3,6 @@
 
 %import syslib
 %import conv
-%import shared_textio_functions
 
 txt {
 
@@ -17,6 +16,10 @@ sub  clear_screen() {
     chrout(125)
 }
 
+sub  cls() {
+    chrout(125)
+}
+
 sub nl() {
     chrout('\n')
 }
@@ -148,15 +151,15 @@ _tmp_outchar
 }
 
 asmsub  print (str text @ AY) clobbers(A,Y)  {
-	; ---- print null terminated string from A/Y
+	; ---- print zero terminated string from A/Y
 	; note: the compiler contains an optimization that will replace
 	;       a call to this subroutine with a string argument of just one char,
 	;       by just one call to CHROUT of that single char.
 	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		sty  P8ZP_SCRATCH_REG
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
 		ldy  #0
--		lda  (P8ZP_SCRATCH_B1),y
+-		lda  (P8ZP_SCRATCH_W2),y
 		beq  +
 		jsr  chrout
 		iny
@@ -168,13 +171,13 @@ asmsub  print (str text @ AY) clobbers(A,Y)  {
 asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
-		jsr  conv.ubyte2decimal
+		jsr  conv.internal_ubyte2decimal
 		pha
 		tya
 		jsr  chrout
-		pla
-		jsr  chrout
 		txa
+		jsr  chrout
+		pla
 		jmp  chrout
 	}}
 }
@@ -182,21 +185,21 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
 asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
-		jsr  conv.ubyte2decimal
+		jsr  conv.internal_ubyte2decimal
 _print_byte_digits
 		pha
 		cpy  #'0'
 		beq  +
 		tya
 		jsr  chrout
-		pla
+		txa
 		jsr  chrout
 		jmp  _ones
-+       pla
-        cmp  #'0'
++       cpx  #'0'
         beq  _ones
+        txa
         jsr  chrout
-_ones   txa
+_ones   pla
 		jmp  chrout
 	}}
 }
@@ -210,7 +213,7 @@ asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
 		lda  #'-'
 		jsr  chrout
 +		pla
-		jsr  conv.byte2decimal
+		jsr  conv.internal_byte2decimal
 		jmp  print_ub._print_byte_digits
 	}}
 }
@@ -223,7 +226,7 @@ asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 		lda  #'$'
 		jsr  chrout
 		pla
-+		jsr  conv.ubyte2hex
++		jsr  conv.internal_ubyte2hex
 		jsr  chrout
 		tya
 		jmp  chrout
@@ -277,9 +280,9 @@ asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
-		jsr  conv.uword2decimal
+		jsr  conv.internal_uword2decimal
 		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
+-		lda  conv.internal_uword2decimal.decTenThousands,y
         beq  +
 		jsr  chrout
 		iny
@@ -291,9 +294,9 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
 asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
-		jsr  conv.uword2decimal
+		jsr  conv.internal_uword2decimal
 		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
+-		lda  conv.internal_uword2decimal.decTenThousands,y
 		beq  _allzero
 		cmp  #'0'
 		bne  _gotdigit
@@ -303,7 +306,7 @@ asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
 _gotdigit
 		jsr  chrout
 		iny
-		lda  conv.uword2decimal.decTenThousands,y
+		lda  conv.internal_uword2decimal.decTenThousands,y
 		bne  _gotdigit
 		rts
 _allzero

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/c128/syslib.p8

@@ -93,11 +93,12 @@ romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> bool @Pc, ubyte @ A
 romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) -> bool @ Pc, ubyte @ A          ; (via 818 ($332)) save to a device
 romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
 romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y       ; read the software clock (A=lo,X=mid,Y=high)
-romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A      ; (via 808 ($328)) check the STOP key (and some others in A)
-romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A    ; (via 810 ($32A)) get a character
+romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A       ; (via 808 ($328)) check the STOP key (and some others in A)     also see STOP2
+romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A     ; (via 810 ($32A)) get a character       also see GETIN2
 romsub $FFE7 = CLALL() clobbers(A,X)                            ; (via 812 ($32C)) close all files
 romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
-romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of screen rows and columns
+romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; get current window dimensions into X (columns) and Y (rows)  NOTE: changed behavior compared to VIC/C64/PET SCREEN() routine!
+romsub $FFED = SCRORG() -> ubyte @ X, ubyte @ Y                 ; get current window dimensions into X (columns) and Y (rows)  NOTE: changed behavior compared to VIC/C64/PET SCREEN() routine!
 romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, bool dir @ Pc) clobbers(A) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use txt.plot for a 'safe' wrapper that preserves X.
 romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
 
@@ -105,15 +106,20 @@ romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base addr
 
 ; ---- utilities -----
 
-asmsub STOP2() clobbers(X) -> bool @A  {
-    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
+inline asmsub STOP2() clobbers(X,A) -> bool @Pz  {
+    ; -- just like STOP, but omits the special keys result value in A.
+    ;    just for convenience because most of the times you're only interested in the stop pressed or not status.
     %asm {{
         jsr  cbm.STOP
-        beq  +
-        lda  #0
-        rts
-+       lda  #1
-        rts
+    }}
+}
+
+inline asmsub GETIN2() clobbers(X,Y) -> ubyte @A {
+    ; -- just like GETIN, but omits the carry flag result value.
+    ;    just for convenience because GETIN is so often used to just read keyboard input,
+    ;    where you don't have to deal with a potential error status
+    %asm {{
+        jsr  cbm.GETIN
     }}
 }
 

compiler/res/prog8lib/c128/textio.p8

@@ -4,7 +4,7 @@
 
 %import syslib
 %import conv
-%import shared_textio_functions
+%import shared_cbm_textio_functions
 
 
 txt {
@@ -13,11 +13,17 @@ txt {
 const ubyte DEFAULT_WIDTH = 40
 const ubyte DEFAULT_HEIGHT = 25
 
+romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse. Note: takes a PETSCII encoded character.
+
 
 sub  clear_screen() {
     chrout(147)
 }
 
+sub  cls() {
+    chrout(147)
+}
+
 sub home() {
     chrout(19)
 }
@@ -288,216 +294,6 @@ _scroll_screen  ; scroll only the screen memory
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte char @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse. Note: takes a PETSCII encoded character.
-
-asmsub  print (str text @ AY) clobbers(A,Y)  {
-	; ---- print null terminated string, in PETSCII encoding, from A/Y
-	; note: the compiler contains an optimization that will replace
-	;       a call to this subroutine with a string argument of just one char,
-	;       by just one call to cbm.CHROUT of that single char.
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		sty  P8ZP_SCRATCH_REG
-		ldy  #0
--		lda  (P8ZP_SCRATCH_B1),y
-		beq  +
-		jsr  cbm.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
-	%asm {{
-		jsr  conv.ubyte2decimal
-		pha
-		tya
-		jsr  cbm.CHROUT
-		pla
-		jsr  cbm.CHROUT
-		txa
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in decimal form, without left padding 0s
-	%asm {{
-		jsr  conv.ubyte2decimal
-_print_byte_digits
-		pha
-		cpy  #'0'
-		beq  +
-		tya
-		jsr  cbm.CHROUT
-		pla
-		jsr  cbm.CHROUT
-		jmp  _ones
-+       pla
-        cmp  #'0'
-        beq  _ones
-        jsr  cbm.CHROUT
-_ones   txa
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
-	; ---- print the byte in A in decimal form, without left padding 0s
-	%asm {{
-		pha
-		cmp  #0
-		bpl  +
-		lda  #'-'
-		jsr  cbm.CHROUT
-+		pla
-		jsr  conv.byte2decimal
-		jmp  print_ub._print_byte_digits
-	}}
-}
-
-asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		bcc  +
-		pha
-		lda  #'$'
-		jsr  cbm.CHROUT
-		pla
-+		jsr  conv.ubyte2hex
-		jsr  cbm.CHROUT
-		tya
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'%'
-		jsr  cbm.CHROUT
-+		ldy  #8
--		lda  #'0'
-		asl  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'1'
-+		jsr  cbm.CHROUT
-		dey
-		bne  -
-		rts
-	}}
-}
-
-asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubbin
-		pla
-		clc
-		jmp  print_ubbin
-	}}
-}
-
-asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in hexadecimal form (4 digits)
-	;      (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubhex
-		pla
-		clc
-		jmp  print_ubhex
-	}}
-}
-
-asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
-	%asm {{
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-        beq  +
-		jsr  cbm.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in decimal form, without left padding 0s
-	%asm {{
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-		beq  _allzero
-		cmp  #'0'
-		bne  _gotdigit
-		iny
-		bne  -
-
-_gotdigit
-		jsr  cbm.CHROUT
-		iny
-		lda  conv.uword2decimal.decTenThousands,y
-		bne  _gotdigit
-		rts
-_allzero
-        lda  #'0'
-        jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
-	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
-	%asm {{
-		cpy  #0
-		bpl  +
-		pha
-		lda  #'-'
-		jsr  cbm.CHROUT
-		tya
-		eor  #255
-		tay
-		pla
-		eor  #255
-		clc
-		adc  #1
-		bcc  +
-		iny
-+		jmp  print_uw
-	}}
-}
-
-asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
-	; ---- Input a string (max. 80 chars) from the keyboard, in PETSCII encoding.
-	;      Returns length in Y. (string is terminated with a 0 byte as well)
-	;      It assumes the keyboard is selected as I/O channel!
-
-	%asm {{
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0				; char counter = 0
--		jsr  cbm.CHRIN
-		cmp  #$0d			; return (ascii 13) pressed?
-		beq  +				; yes, end.
-		sta  (P8ZP_SCRATCH_W1),y	; else store char in buffer
-		iny
-		bne  -
-+		lda  #0
-		sta  (P8ZP_SCRATCH_W1),y	; finish string with 0 byte
-		rts
-
-	}}
-}
-
 asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A, Y)  {
 	; ---- sets the character in the screen matrix at the given position
 	%asm {{

compiler/res/prog8lib/c64/floats.p8

@@ -4,11 +4,7 @@
 %import shared_floats_functions
 
 floats {
-	; ---- this block contains C-64 floating point related functions ----
-        const float  π      = 3.141592653589793
-        const float  PI     = π
-        const float  TWOPI  = 2*π
-
+; ---- this block contains C-64 floating point related functions ----
 
 ; ---- C64 basic and kernal ROM float constants and functions ----
 
@@ -24,7 +20,7 @@ romsub $bba6 = FREADMEM() clobbers(A,Y)                     ; load mflpt value f
 romsub $ba8c = CONUPK(uword mflpt @ AY) clobbers(A,Y)       ; load mflpt value from memory  in A/Y into fac2
 romsub $ba90 = FAREADMEM() clobbers(A,Y)                    ; load mflpt value from memory  in $22/$23 into fac2
 romsub $bbfc = MOVFA() clobbers(A,X)                        ; copy fac2 to fac1
-romsub $bc0c = MOVAF() clobbers(A,X)                        ; copy fac1 to fac2  (rounded)
+romsub $bc0c = MOVAF() clobbers(A,X)                        ; copy fac1 to fac2  (rounded the least significant bit)
 romsub $bc0f = MOVEF() clobbers(A,X)                        ; copy fac1 to fac2
 romsub $bbd4 = MOVMF(uword mflpt @ XY) clobbers(A,Y)        ; store fac1 to memory  X/Y as 5-byte mflpt
 
@@ -49,7 +45,7 @@ romsub $b7b5 = FREADSTR(ubyte length @ A) clobbers(A,X,Y)   ; str -> fac1, $22/2
 romsub $aabc = FPRINTLN() clobbers(A,X,Y)                   ; print string of fac1, on one line (= with newline) destroys fac1.  (consider FOUT + STROUT as well)
 romsub $bddd = FOUT() clobbers(X) -> uword @ AY             ; fac1 -> string, address returned in AY ($0100)
 
-romsub $b849 = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for rounding- call this before INT
+romsub $b849 = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for integer rounding- call this before INT
 romsub $bae2 = MUL10() clobbers(A,X,Y)                      ; fac1 *= 10
 romsub $bafe = DIV10() clobbers(A,X,Y)                      ; fac1 /= 10 , CAUTION: result is always positive! You have to fix sign manually!
 romsub $bc5b = FCOMP(uword mflpt @ AY) clobbers(X,Y) -> ubyte @ A   ; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
@@ -67,7 +63,7 @@ romsub $bf78 = FPWR(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = fac2 ** mfl
 romsub $bd7e = FINLOG(byte value @A) clobbers (A, X, Y)     ; fac1 += signed byte in A
 
 romsub $aed4 = NOTOP() clobbers(A,X,Y)                      ; fac1 = NOT(fac1)
-romsub $bccc = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to round instead of trunc
+romsub $bccc = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to integer round instead of trunc
 romsub $b9ea = LOG() clobbers(A,X,Y)                        ; fac1 = LN(fac1)  (natural log)
 romsub $bc39 = SGN() clobbers(A,X,Y)                        ; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
 romsub $bc2b = SIGN() -> ubyte @ A                          ; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive

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/c64/syslib.p8

@@ -94,23 +94,29 @@ romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> bool @Pc, ubyte @ A
 romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) -> bool @ Pc, ubyte @ A          ; (via 818 ($332)) save to a device
 romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
 romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y       ; read the software clock (A=lo,X=mid,Y=high)
-romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A      ; (via 808 ($328)) check the STOP key (and some others in A)
-romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A    ; (via 810 ($32A)) get a character
+romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A       ; (via 808 ($328)) check the STOP key (and some others in A)     also see STOP2
+romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A     ; (via 810 ($32A)) get a character       also see GETIN2
 romsub $FFE7 = CLALL() clobbers(A,X)                            ; (via 812 ($32C)) close all files
 romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
-romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of screen rows and columns
+romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; get size of text screen into X (columns) and Y (rows)
 romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, bool dir @ Pc) clobbers(A) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use txt.plot for a 'safe' wrapper that preserves X.
 romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
 
-asmsub STOP2() clobbers(X) -> bool @A  {
-    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
+
+inline asmsub STOP2() clobbers(X,A) -> bool @Pz  {
+    ; -- just like STOP, but omits the special keys result value in A.
+    ;    just for convenience because most of the times you're only interested in the stop pressed or not status.
     %asm {{
         jsr  cbm.STOP
-        beq  +
-        lda  #0
-        rts
-+       lda  #1
-        rts
+    }}
+}
+
+inline asmsub GETIN2() clobbers(X,Y) -> ubyte @A {
+    ; -- just like GETIN, but omits the carry flag result value.
+    ;    just for convenience because GETIN is so often used to just read keyboard input,
+    ;    where you don't have to deal with a potential error status
+    %asm {{
+        jsr  cbm.GETIN
     }}
 }
 

compiler/res/prog8lib/c64/textio.p8

@@ -4,7 +4,7 @@
 
 %import syslib
 %import conv
-%import shared_textio_functions
+%import shared_cbm_textio_functions
 
 txt {
 
@@ -13,11 +13,16 @@ txt {
 const ubyte DEFAULT_WIDTH = 40
 const ubyte DEFAULT_HEIGHT = 25
 
+romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse. Note: takes a PETSCII encoded character.
 
 sub  clear_screen() {
     chrout(147)
 }
 
+sub  cls() {
+    chrout(147)
+}
+
 sub home() {
     chrout(19)
 }
@@ -292,216 +297,6 @@ _scroll_screen  ; scroll only the screen memory
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse. Note: takes a PETSCII encoded character.
-
-asmsub  print (str text @ AY) clobbers(A,Y)  {
-	; ---- print null terminated string, in PESCII encoding, from A/Y
-	; note: the compiler contains an optimization that will replace
-	;       a call to this subroutine with a string argument of just one char,
-	;       by just one call to cbm.CHROUT of that single char.
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		sty  P8ZP_SCRATCH_REG
-		ldy  #0
--		lda  (P8ZP_SCRATCH_B1),y
-		beq  +
-		jsr  cbm.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
-	%asm {{
-		jsr  conv.ubyte2decimal
-		pha
-		tya
-		jsr  cbm.CHROUT
-		pla
-		jsr  cbm.CHROUT
-		txa
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in decimal form, without left padding 0s
-	%asm {{
-		jsr  conv.ubyte2decimal
-_print_byte_digits
-		pha
-		cpy  #'0'
-		beq  +
-		tya
-		jsr  cbm.CHROUT
-		pla
-		jsr  cbm.CHROUT
-		jmp  _ones
-+       pla
-        cmp  #'0'
-        beq  _ones
-        jsr  cbm.CHROUT
-_ones   txa
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
-	; ---- print the byte in A in decimal form, without left padding 0s
-	%asm {{
-		pha
-		cmp  #0
-		bpl  +
-		lda  #'-'
-		jsr  cbm.CHROUT
-+		pla
-		jsr  conv.byte2decimal
-		jmp  print_ub._print_byte_digits
-	}}
-}
-
-asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		bcc  +
-		pha
-		lda  #'$'
-		jsr  cbm.CHROUT
-		pla
-+		jsr  conv.ubyte2hex
-		jsr  cbm.CHROUT
-		tya
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'%'
-		jsr  cbm.CHROUT
-+		ldy  #8
--		lda  #'0'
-		asl  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'1'
-+		jsr  cbm.CHROUT
-		dey
-		bne  -
-		rts
-	}}
-}
-
-asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubbin
-		pla
-		clc
-		jmp  print_ubbin
-	}}
-}
-
-asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in hexadecimal form (4 digits)
-	;      (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubhex
-		pla
-		clc
-		jmp  print_ubhex
-	}}
-}
-
-asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
-	%asm {{
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-        beq  +
-		jsr  cbm.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in decimal form, without left padding 0s
-	%asm {{
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-		beq  _allzero
-		cmp  #'0'
-		bne  _gotdigit
-		iny
-		bne  -
-
-_gotdigit
-		jsr  cbm.CHROUT
-		iny
-		lda  conv.uword2decimal.decTenThousands,y
-		bne  _gotdigit
-		rts
-_allzero
-        lda  #'0'
-        jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
-	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
-	%asm {{
-		cpy  #0
-		bpl  +
-		pha
-		lda  #'-'
-		jsr  cbm.CHROUT
-		tya
-		eor  #255
-		tay
-		pla
-		eor  #255
-		clc
-		adc  #1
-		bcc  +
-		iny
-+		jmp  print_uw
-	}}
-}
-
-asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
-	; ---- Input a string (max. 80 chars) from the keyboard, in PETSCII encoding.
-	;      Returns length in Y. (string is terminated with a 0 byte as well)
-	;      It assumes the keyboard is selected as I/O channel!
-
-	%asm {{
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0				; char counter = 0
--		jsr  cbm.CHRIN
-		cmp  #$0d			; return (ascii 13) pressed?
-		beq  +				; yes, end.
-		sta  (P8ZP_SCRATCH_W1),y	; else store char in buffer
-		iny
-		bne  -
-+		lda  #0
-		sta  (P8ZP_SCRATCH_W1),y	; finish string with 0 byte
-		rts
-
-	}}
-}
-
 asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A, Y)  {
 	; ---- sets the character in the screen matrix at the given position
 	%asm {{

compiler/res/prog8lib/conv.p8

@@ -8,97 +8,79 @@ conv {
 
     str  @shared string_out = "????????????????"       ; result buffer for the string conversion routines
 
-asmsub  str_ub0  (ubyte value @ A) clobbers(X) -> str @AY  {
-	; ---- convert the ubyte in A in decimal string form, with left padding 0s (3 positions total)
-	%asm {{
-        jsr  conv.ubyte2decimal
-        sty  string_out
-        sta  string_out+1
-        stx  string_out+2
-        lda  #0
-        sta  string_out+3
-        lda  #<string_out
-        ldy  #>string_out
-        rts
-	}}
-}
+    asmsub str_ub0(ubyte value @A) clobbers(X) -> str @AY {
+        ; ---- convert the ubyte in A in decimal string form, with left padding 0s (3 positions total)
+        %asm {{
+            jsr  internal_ubyte2decimal
+            sty  conv.string_out
+            stx  conv.string_out+1
+            sta  conv.string_out+2
+            lda  #0
+            sta  conv.string_out+3
+            lda  #<conv.string_out
+            ldy  #>conv.string_out
+            rts
+        }}
+    }
 
-asmsub  str_ub  (ubyte value @ A) clobbers(X) -> str @AY  {
-	; ---- convert the ubyte in A in decimal string form, without left padding 0s
-	%asm {{
-		ldy  #0
-		sty  P8ZP_SCRATCH_B1
-		jsr  ubyte2decimal     ; result in Y/A/X (100s, 10s, 1s).
-        ; hundreds?
-		cpy  #'0'
-		beq  +
-		sty  string_out
-		sta  string_out+1
-		stx  string_out+2
-		lda  #0
-		sta  string_out+3
-		jmp  _done
-		; tens?
-+		cmp  #'0'
-		beq  +
-		sta  string_out
-		stx  string_out+1
-		lda  #0
-		sta  string_out+2
-		jmp  _done
-+       ; ones.
-        stx  string_out
-		lda  #0
-		sta  string_out+1
-_done   lda  #<string_out
-        ldy  #>string_out
-        rts
-	}}
-}
+    asmsub str_ub(ubyte value @A) clobbers(X) -> str @AY {
+        ; ---- convert the ubyte in A in decimal string form, without left padding 0s
+        %asm {{
+            jsr  internal_ubyte2decimal
+            cpy  #'0'
+            beq  +
+            sty  conv.string_out
+            stx  conv.string_out+1
+            sta  conv.string_out+2
+            lda  #0
+            sta  conv.string_out+3
+            jmp  _done
++           cpx  #'0'
+            beq  +
+            stx  conv.string_out
+            sta  conv.string_out+1
+            lda  #0
+            sta  conv.string_out+2
+            jmp  _done
++           sta  conv.string_out
+            lda  #0
+            sta  conv.string_out+1
+_done       lda  #<conv.string_out
+            ldy  #>conv.string_out
+            rts
+        }}
+    }
 
-asmsub  str_b  (byte value @ A) clobbers(X) -> str @AY  {
-	; ---- convert the byte in A in decimal string form, without left padding 0s
-	%asm {{
-	    ldy  #0
-        cmp  #0
-        bpl  +
-        ldy  #'-'
-        sty  string_out
-        ldy  #1
-+       sty  P8ZP_SCRATCH_REG
-   	    jsr  conv.byte2decimal      ; result in Y/A/X (100s, 10s, 1s).  and in uword2decimal.decHundreds, decTens, decOnes.
-        ; hundreds?
-		cpy  #'0'
-		bne  _out_hundreds
-		ldy  P8ZP_SCRATCH_REG
-        cmp  #'0'
-        bne  _out_tens
-        beq  _out_ones
-_out_hundreds
-		ldy  P8ZP_SCRATCH_REG
-		lda  uword2decimal.decHundreds
-		sta  string_out,y
-		iny
-_out_tens
-		lda  uword2decimal.decTens
-		sta  string_out,y
-		iny
-_out_ones
-		lda  uword2decimal.decOnes
-        sta  string_out,y
-        iny
-        lda  #0
-        sta  string_out,y
-        lda  #<string_out
-        ldy  #>string_out
-   	    rts
-	}}
-}
+    asmsub str_b(byte value @A) clobbers(X) -> str @AY {
+        ; ---- convert the byte in A in decimal string form, without left padding 0s
+        %asm {{
+            cmp  #0
+            bpl  str_ub
+            eor  #255
+            clc
+            adc  #1
+            jsr  str_ub
+            ; insert a minus sign at the start
+            lda  #0
+            sta  conv.string_out+4
+            lda  conv.string_out+2
+            sta  conv.string_out+3
+            lda  conv.string_out+1
+            sta  conv.string_out+2
+            lda  conv.string_out
+            sta  conv.string_out+1
+            lda  #'-'
+            sta  conv.string_out
+            lda  #<conv.string_out
+            ldy  #>conv.string_out
+            rts
+        }}
+    }
 
 asmsub  str_ubhex  (ubyte value @ A) clobbers(X) -> str @AY {
 	; ---- convert the ubyte in A in hex string form
 	%asm {{
-        jsr  conv.ubyte2hex
+        jsr  internal_ubyte2hex
         sta  string_out
         sty  string_out+1
         lda  #0
@@ -158,11 +140,11 @@ asmsub  str_uwhex  (uword value @ AY) -> str @AY  {
 	%asm {{
         pha
         tya
-        jsr  conv.ubyte2hex
+        jsr  internal_ubyte2hex
         sta  string_out
         sty  string_out+1
         pla
-        jsr  conv.ubyte2hex
+        jsr  internal_ubyte2hex
         sta  string_out+2
         sty  string_out+3
         lda  #0
@@ -176,9 +158,9 @@ asmsub  str_uwhex  (uword value @ AY) -> str @AY  {
 asmsub  str_uw0  (uword value @ AY) clobbers(X) -> str @AY  {
 	; ---- convert the uword in A/Y in decimal string form, with left padding 0s (5 positions total)
 	%asm {{
-	    jsr  conv.uword2decimal
+	    jsr  conv.internal_uword2decimal
 	    ldy  #0
--       lda  conv.uword2decimal.decTenThousands,y
+-       lda  conv.internal_uword2decimal.decTenThousands,y
         sta  string_out,y
         beq  +
         iny
@@ -193,11 +175,11 @@ asmsub  str_uw0  (uword value @ AY) clobbers(X) -> str @AY  {
 asmsub  str_uw  (uword value @ AY) clobbers(X) -> str @AY  {
 	; ---- convert the uword in A/Y in decimal string form, without left padding 0s
 	%asm {{
-	    jsr  conv.uword2decimal
+	    jsr  conv.internal_uword2decimal
 	    ldx  #0
 _output_digits
 	    ldy  #0
--       lda  conv.uword2decimal.decTenThousands,y
+-       lda  internal_uword2decimal.decTenThousands,y
         beq  _allzero
         cmp  #'0'
         bne  _gotdigit
@@ -206,7 +188,7 @@ _output_digits
 _gotdigit   sta  string_out,x
         inx
         iny
-        lda  conv.uword2decimal.decTenThousands,y
+        lda  internal_uword2decimal.decTenThousands,y
         bne  _gotdigit
 _end    lda  #0
         sta  string_out,x
@@ -238,7 +220,7 @@ asmsub  str_w  (word value @ AY) clobbers(X) -> str @AY  {
         adc  #1
         bcc  +
         iny
-+	    jsr  conv.uword2decimal
++	    jsr  conv.internal_uword2decimal
 	    ldx  #1
 	    bne  str_uw._output_digits
 	    rts
@@ -533,17 +515,25 @@ _stop
 
 ; ----- low level number conversions to decimal strings ----
 
-asmsub  ubyte2decimal  (ubyte value @A) -> ubyte @Y, ubyte @A, ubyte @X  {
-	; ---- A to decimal string in Y/A/X  (100s in Y, 10s in A, 1s in X)
-	%asm {{
-		ldy  #uword2decimal.ASCII_0_OFFSET
-		jmp  uword2decimal.hex_try200
-	}}
+asmsub internal_ubyte2decimal(ubyte value @A) -> ubyte @Y, ubyte @X, ubyte @A {
+    %asm {{
+        ldy  #'0'-1
+        ldx  #'9'+1
+        sec
+-       iny
+        sbc  #100
+        bcs  -
+-       dex
+        adc  #10
+        bmi  -
+        adc  #'0'-1
+        rts
+    }}
 }
 
-asmsub  uword2decimal  (uword value @AY) -> ubyte @Y, ubyte @A, ubyte @X  {
+asmsub  internal_uword2decimal  (uword value @AY) -> ubyte @Y, ubyte @A, ubyte @X  {
 	;  ---- convert 16 bit uword in A/Y to decimal
-	;  output in uword2decimal.decTenThousands, decThousands, decHundreds, decTens, decOnes
+	;  output in internal_uword2decimal.decTenThousands, decThousands, decHundreds, decTens, decOnes
 	;  (these are terminated by a zero byte so they can be easily printed)
 	;  also returns Y = 100's, A = 10's, X = 1's
 
@@ -716,7 +706,7 @@ decOnes   		.byte  0
     }}
 }
 
-asmsub  byte2decimal  (byte value @A) -> ubyte @Y, ubyte @A, ubyte @X  {
+asmsub  internal_byte2decimal  (byte value @A) -> ubyte @Y, ubyte @A, ubyte @X  {
 	; ---- A (signed byte) to decimal string in Y/A/X  (100s in Y, 10s in A, 1s in X)
 	;      note: if the number is negative, you have to deal with the '-' yourself!
 	%asm {{
@@ -725,11 +715,11 @@ asmsub  byte2decimal  (byte value @A) -> ubyte @Y, ubyte @A, ubyte @X  {
 		eor  #255
 		clc
 		adc  #1
-+		jmp  ubyte2decimal
++		jmp  internal_ubyte2decimal
 	}}
 }
 
-asmsub  ubyte2hex  (ubyte value @A) clobbers(X) -> ubyte @A, ubyte @Y  {
+asmsub  internal_ubyte2hex  (ubyte value @A) clobbers(X) -> ubyte @A, ubyte @Y  {
 	; ---- A to hex petscii string in AY (first hex char in A, second hex char in Y)
 	%asm {{
 		pha
@@ -749,7 +739,7 @@ _hex_digits	.text "0123456789abcdef"	; can probably be reused for other stuff as
 	}}
 }
 
-asmsub  uword2hex  (uword value @AY) clobbers(A,Y)  {
+asmsub  internal_uword2hex  (uword value @AY) clobbers(A,Y)  {
 	; ---- convert 16 bit uword in A/Y into 4-character hexadecimal string 'uword2hex.output' (0-terminated)
 	%asm {{
 		sta  P8ZP_SCRATCH_REG

compiler/res/prog8lib/cx16/bmx.p8

@@ -170,6 +170,7 @@ save_end:
     sub set_bpp(ubyte bpp) {
         ubyte[8] depths = [0,1,1,2,2,2,2,3]
         vera_colordepth = depths[bpp-1]
+        bitsperpixel = bpp
     }
 
     sub set_vera_colordepth(ubyte depth) {
@@ -234,7 +235,7 @@ save_end:
 
     sub read_scanline(uword size) {
         while size!=0 {
-            cx16.r0 = cx16.MACPTR(min(255, size) as ubyte, &cx16.VERA_DATA0, true)
+            void, cx16.r0 = cx16.MACPTR(min(255, size) as ubyte, &cx16.VERA_DATA0, true)
             if_cs {
                 ; no MACPTR support
                 repeat size
@@ -296,7 +297,7 @@ save_end:
                 cx16.r0L = lsb(size)
                 if msb(size)!=0
                     cx16.r0L = 0        ; 256 bytes
-                cx16.r0 = cx16.MCIOUT(cx16.r0L, &cx16.VERA_DATA0, true)
+                void, cx16.r0 = cx16.MCIOUT(cx16.r0L, &cx16.VERA_DATA0, true)
                 if_cs {
                     ; no MCIOUT support
                     repeat size

compiler/res/prog8lib/cx16/diskio.p8

@@ -32,6 +32,19 @@ diskio {
         cbm.CHKOUT(WRITE_IO_CHANNEL)
     }
 
+    sub fastmode(ubyte mode) -> bool {
+        ; -- set fast serial mode (0=none, 1=auto_tx, 2=fast writes, 3=both) for the SD card.
+        ;    Returns success status (fails on emulator host fs for example)
+        list_filename[0] = 'u'
+        list_filename[1] = '0'
+        list_filename[2] = '>'
+        list_filename[3] = 'b'
+        list_filename[4] = mode | $30
+        list_filename[5] = 0
+        send_command(list_filename)
+        return status_code()==0
+    }
+
     sub directory() -> bool {
         ; -- Prints the directory contents to the screen. Returns success.
 
@@ -70,7 +83,8 @@ diskio {
             void cbm.CHRIN()     ; skip 2 bytes
             void cbm.CHRIN()
             status = cbm.READST()
-            if cbm.STOP2()
+            void cbm.STOP()
+            if_z
                 break
         }
         status = cbm.READST()
@@ -319,7 +333,7 @@ close_end:
             readsize = 255
             if num_bytes<readsize
                 readsize = num_bytes
-            readsize = cx16.MACPTR(lsb(readsize), bufferpointer, false)     ; fast block reads
+            void, readsize = cx16.MACPTR(lsb(readsize), bufferpointer, false)     ; fast block reads
             if_cs
                 goto byte_read_loop     ; MACPTR block read not supported, do fallback loop
             list_blocks += readsize
@@ -365,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
@@ -379,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
@@ -401,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
         }}
     }
 
@@ -453,10 +469,11 @@ _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 {
-                cx16.r0 = cx16.MCIOUT(lsb(num_bytes), bufferpointer, false)     ; fast block writes
+                void, cx16.r0 = cx16.MCIOUT(lsb(num_bytes), bufferpointer, false)     ; fast block writes
                 if_cs
                     goto no_mciout
                 num_bytes -= cx16.r0
@@ -525,6 +542,39 @@ io_error:
         goto done
     }
 
+    ; similar to above, but instead of fetching the entire string, it only fetches the status code and returns it as ubyte
+    ; in case of IO error, returns 255 (CMDR-DOS itself is physically unable to return such a value)
+    sub status_code() -> ubyte {
+        if cbm.READST()==128 {
+            return 255
+        }
+
+        cbm.SETNAM(0, list_filename)
+        cbm.SETLFS(15, drivenumber, 15)
+        void cbm.OPEN()          ; open 15,8,15
+        if_cs
+            goto io_error
+        void cbm.CHKIN(15)        ; use #15 as input channel
+
+        list_filename[0] = cbm.CHRIN()
+        list_filename[1] = cbm.CHRIN()
+        list_filename[2] = 0
+
+        while cbm.READST()==0 {
+            void cbm.CHRIN()
+        }
+
+        cbm.CLRCHN()        ; restore default i/o devices
+        cbm.CLOSE(15)
+        return conv.str2ubyte(list_filename)
+
+io_error:
+        cbm.CLRCHN()
+        cbm.CLOSE(15)
+        return 255
+    }
+
+
 
     ; saves a block of memory to disk, including the default 2 byte prg header.
     sub save(uword filenameptr, uword startaddress, uword savesize) -> bool {
@@ -641,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()
@@ -816,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()
@@ -845,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/emudbg.p8

@@ -1,5 +1,5 @@
 ; Emulator debug interface.
-; Docs: https://github.com/X16Community/x16-emulator#emulator-io-registers
+; Docs: https://github.com/X16Community/x16-emulator/tree/d52f118ce893fa24c4ca021a0b8de46cb80e5ccf#emulator-io-registers
 
 emudbg {
     %option ignore_unused
@@ -41,7 +41,7 @@ emudbg {
                 chr = @(isoString)
                 if_z
                     break
-                EMU_CPUCLK_U = chr
+                EMU_CHROUT = chr
                 isoString++
             }
         }

compiler/res/prog8lib/cx16/floats.p8

@@ -4,12 +4,7 @@
 %import shared_floats_functions
 
 floats {
-	; ---- this block contains C-64 compatible floating point related functions ----
-
-        const float  π      = 3.141592653589793
-        const float  PI     = π
-        const float  TWOPI  = 2*π
-
+; ---- this block contains C-64 compatible floating point related functions ----
 
 ; ---- ROM float functions (same as on C128 except base page) ----
 
@@ -19,7 +14,7 @@ floats {
 ; note: fac1/2 might get clobbered even if not mentioned in the function's name.
 ; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.
 
-romsub $fe00 = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
+romsub $fe00 = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 'facmo' and 'faclo', MSB FIRST. (might throw ILLEGAL QUANTITY)  See "basic.sym" kernal symbol file for their memory locations.
 
 ; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1
 ; there is also floats.GIVUAYFAY - unsigned word in A/Y (lo/hi) to fac1
@@ -43,7 +38,7 @@ romsub $fe21 = FMULTT() clobbers(A,X,Y)                     ; fac1 *= fac2
 romsub $fe24 = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1
 romsub $fe27 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  mind the order of the operands
 romsub $fe2a = LOG() clobbers(A,X,Y)                        ; fac1 = LN(fac1)  (natural log)
-romsub $fe2d = INT() clobbers(A,X,Y)                        ; INT() truncates, use ROUND or FADDH first to round instead of trunc
+romsub $fe2d = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to integer round instead of trunc
 romsub $fe30 = SQR() clobbers(A,X,Y)                        ; fac1 = SQRT(fac1)
 romsub $fe33 = NEGOP() clobbers(A)                          ; switch the sign of fac1 (fac1 = -fac1)
 romsub $fe36 = FPWR(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = fac2 ** float in A/Y
@@ -53,7 +48,7 @@ romsub $fe3f = COS() clobbers(A,X,Y)                        ; fac1 = COS(fac1)
 romsub $fe42 = SIN() clobbers(A,X,Y)                        ; fac1 = SIN(fac1)
 romsub $fe45 = TAN() clobbers(A,X,Y)                        ; fac1 = TAN(fac1)
 romsub $fe48 = ATN() clobbers(A,X,Y)                        ; fac1 = ATN(fac1)
-romsub $fe4b = ROUND() clobbers(A,X,Y)                      ; round fac1
+romsub $fe4b = ROUND() clobbers(A,X,Y)                      ; round least significant bit of fac1
 romsub $fe4e = ABS() clobbers(A,X,Y)                        ; fac1 = ABS(fac1)
 romsub $fe51 = SIGN() clobbers(X,Y) -> ubyte @ A            ; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
 romsub $fe54 = FCOMP(uword mflpt @ AY) clobbers(X,Y) -> ubyte @ A   ; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
@@ -65,10 +60,10 @@ romsub $fe60 = MOVFRM(uword mflpt @ AY) clobbers(A,X,Y)     ; load mflpt value f
 romsub $fe63 = MOVFM(uword mflpt @ AY) clobbers(A,X,Y)      ; load mflpt value from memory in A/Y into fac1
 romsub $fe66 = MOVMF(uword mflpt @ XY) clobbers(A,X,Y)      ; store fac1 to memory  X/Y as 5-byte mflpt
 romsub $fe69 = MOVFA() clobbers(A,X)                        ; copy fac2 to fac1
-romsub $fe6c = MOVAF() clobbers(A,X)                        ; copy fac1 to fac2  (rounded)
+romsub $fe6c = MOVAF() clobbers(A,X)                        ; copy fac1 to fac2  (rounded the least significant bit)
 
 ; X16 additions
-romsub $fe6f = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for rounding- call this before INT
+romsub $fe6f = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for integer rounding- call this before INT
 romsub $fe72 = ZEROFC() clobbers(A,X,Y)                     ; fac1 = 0
 romsub $fe75 = NORMAL() clobbers(A,X,Y)                     ; normalize fac1
 romsub $fe78 = NEGFAC() clobbers(A)                         ; switch the sign of fac1 (fac1 = -fac1) (doesn't work, juse use NEGOP() instead!)
@@ -98,8 +93,8 @@ asmsub  FREADSA  (byte value @A) clobbers(A,X,Y) {
 asmsub  GIVUAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- unsigned 16 bit word in A/Y (lo/hi) to fac1
 	%asm {{
-	sty  $c4        ; facmo     ($64 on c128)
-	sta  $c5        ; facmo+1   ($65 on c128)
+	sty  $c4        ; facmo
+	sta  $c5        ; facmo+1
 	ldx  #$90
 	sec
 	jmp  FLOATC
@@ -136,14 +131,12 @@ asmsub  FREADUY (ubyte value @Y) {
 }
 
 asmsub parse(str value @AY) -> float @FAC1 {
-    ; -- parse a string value of a number to float in FAC1
-    ;    warning: on older <R47 kernals it uses an internal BASIC routine that is ROM version dependent,
-    ;    ($deb6 is inside the routine for VAL at $deb3)  See basic.sym from x16-rom
-    ;    TODO once ROM v47 is released, all the workarounds here can be removed. But probably keep the kernal VAL_1 existance check
+    ; -- Parse a string value of a number to float in FAC1.
+    ;    Requires kernal R47 or newer! (depends on val_1 working)
     %asm {{
         ldx  VAL_1
         cpx  #$4c       ; is there an implementation in VAL_1? (test for JMP)
-        bne  +          ; no, do it ourselves
+        bne  _borked    ; no, print error message
         pha             ; yes, count the length and call rom VAL_1.
         phy
         jsr  prog8_lib.strlen
@@ -151,15 +144,7 @@ asmsub parse(str value @AY) -> float @FAC1 {
         ply
         plx
         jmp  VAL_1
-+       sta  $a9    ; 'index' variable
-        sty  $aa
-        jsr  prog8_lib.strlen
-        lda  $deb6
-        cmp  #$d0   ; sanity check for kernal routine correct
-        bne  +
-        tya
-        jmp  $deb6   ; kernal version dependent...
-+       ; print error message if routine is borked in kernal, and exit program
+_borked
         ldy  #0
 -       lda  _msg,y
         beq  +
@@ -168,12 +153,12 @@ asmsub parse(str value @AY) -> float @FAC1 {
         bne  -
 +       jmp  sys.exit
 
-_msg    .text 13,"?val kaputt",13,0
+_msg    .text 13,"?rom 47+ required for val1",13,0
     }}
 }
 
 
-&uword AYINT_facmo = $c6      ; $c6/$c7 contain result of AYINT
+&uword AYINT_facmo = $c6      ; $c6/$c7 contain result of AYINT   (See "basic.sym" kernal symbol file)
 
 sub rnd() -> float {
     %asm {{

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
@@ -55,9 +56,11 @@ gfx2 {
             }
             else -> {
                 ; back to default text mode
-                cx16.r15L = cx16.VERA_DC_VIDEO & %00000111 ; retain chroma + output mode
-                cbm.CINT()
-                cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11111000) | cx16.r15L
+                if active_mode!=0 {
+                    cx16.r15L = cx16.VERA_DC_VIDEO & %00000111 ; retain chroma + output mode
+                    cbm.CINT()
+                    cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11111000) | cx16.r15L
+                }
             }
         }
 
@@ -252,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]
@@ -270,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
         }
 
     }
@@ -545,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]
@@ -624,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
@@ -639,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
@@ -702,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)
@@ -748,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/psg.p8

@@ -48,7 +48,7 @@ psg {
     sub freq(ubyte voice_num, uword vera_freq) {
         ; -- Changes the frequency of the voice's sound.
         ;    voice_num = 0-15,  vera_freq = 0-65535  calculate this via the formula given in the Vera's PSG documentation.
-        ;    (https://github.com/x16community/x16-docs/blob/master/VERA%20Programmer's%20Reference.md)
+        ;    (https://github.com/X16Community/x16-docs/blob/101759f3bfa5e6cce4e8c5a0b67cb0f2f1c6341e/X16%20Reference%20-%2009%20-%20VERA%20Programmer's%20Reference.md)
         ;    Write freq MSB first and then LSB to reduce the chance on clicks
         sys.irqsafe_set_irqd()
         cx16.r0 = $f9c1 + voice_num * 4

compiler/res/prog8lib/cx16/sprites.p8

@@ -5,6 +5,7 @@
 
 ; note: sprites z-order will be in front of all layers.
 ; note: collision mask is not supported here yet.
+; note: "palette offset" is counted as 0-15  (vera multiplies the offset by 16 to get at the actual color index)
 
 sprites {
     %option ignore_unused
@@ -21,7 +22,7 @@ sprites {
     sub init(ubyte spritenum,
              ubyte databank, uword dataaddr,
              ubyte width_flag, ubyte height_flag,
-             ubyte colors_flag, ubyte palette_offset_idx) {
+             ubyte colors_flag, ubyte palette_offset) {
         hide(spritenum)
         cx16.VERA_DC_VIDEO |= %01000000             ; enable sprites globally
         dataaddr >>= 5
@@ -30,7 +31,7 @@ sprites {
         cx16.vpoke(1, sprite_reg, lsb(dataaddr))                    ; address 12:5
         cx16.vpoke(1, sprite_reg+1, colors_flag | msb(dataaddr))    ; 4 bpp + address 16:13
         cx16.vpoke(1, sprite_reg+6, %00001100)                      ; z depth %11 = in front of both layers, no flips
-        cx16.vpoke(1, sprite_reg+7, height_flag<<6 | width_flag<<4 | palette_offset_idx>>4) ; 64x64 pixels, palette offset
+        cx16.vpoke(1, sprite_reg+7, height_flag<<6 | width_flag<<4 | palette_offset&15) ; 64x64 pixels, palette offset
     }
 
     sub data(ubyte spritenum, ubyte bank, uword addr) {
@@ -41,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)
@@ -143,7 +150,7 @@ sprites {
     }
 
     sub set_palette_offset(ubyte spritenum, ubyte offset) {
-        cx16.vpoke_mask(1, VERA_SPRITEREGS + 7 + spritenum*$0008, %11110000, offset>>4)
+        cx16.vpoke_mask(1, VERA_SPRITEREGS + 7 + spritenum*$0008, %11110000, offset&15)
     }
 
     sub set_mousepointer_hand() {
@@ -175,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
@@ -19,7 +52,7 @@ romsub $FF8D = VECTOR(uword userptr @ XY, bool dir @ Pc) clobbers(A,Y)     ; rea
 romsub $FF90 = SETMSG(ubyte value @ A)                          ; set Kernal message control flag
 romsub $FF93 = SECOND(ubyte address @ A) clobbers(A)            ; (alias: LSTNSA) send secondary address after LISTEN
 romsub $FF96 = TKSA(ubyte address @ A) clobbers(A)              ; (alias: TALKSA) send secondary address after TALK
-romsub $FF99 = MEMTOP(uword address @ XY, bool dir @ Pc) -> uword @ XY     ; read/set top of memory  pointer.   NOTE: as a Cx16 extension, also returns the number of RAM memory banks in register A !  See cx16.numbanks()
+romsub $FF99 = MEMTOP(uword address @ XY, bool dir @ Pc) -> uword @ XY, ubyte @A     ; read/set top of memory  pointer.   NOTE: on the Cx16 also returns the number of RAM memory banks in A!  Also see cx16.numbanks()
 romsub $FF9C = MEMBOT(uword address @ XY, bool dir @ Pc) -> uword @ XY     ; read/set bottom of memory  pointer
 romsub $FF9F = SCNKEY() clobbers(A,X,Y)                         ; scan the keyboard, also called  kbd_scan
 romsub $FFA2 = SETTMO(ubyte timeout @ A)                        ; set time-out flag for IEEE bus
@@ -32,7 +65,7 @@ romsub $FFB4 = TALK(ubyte device @ A) clobbers(A)               ; command serial
 romsub $FFB7 = READST() -> ubyte @ A                            ; read I/O status word  (use CLEARST to reset it to 0)
 romsub $FFBA = SETLFS(ubyte logical @ A, ubyte device @ X, ubyte secondary @ Y)   ; set logical file parameters
 romsub $FFBD = SETNAM(ubyte namelen @ A, str filename @ XY)     ; set filename parameters
-romsub $FFC0 = OPEN() clobbers(X,Y) -> bool @Pc, ubyte @A      ; (via 794 ($31A)) open a logical file
+romsub $FFC0 = OPEN() clobbers(X,Y) -> bool @Pc, ubyte @A       ; (via 794 ($31A)) open a logical file
 romsub $FFC3 = CLOSE(ubyte logical @ A) clobbers(A,X,Y)         ; (via 796 ($31C)) close a logical file
 romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X) -> bool @Pc    ; (via 798 ($31E)) define an input channel
 romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; (via 800 ($320)) define an output channel
@@ -42,37 +75,50 @@ romsub $FFD2 = CHROUT(ubyte character @ A)                           ; (via 806
 romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> bool @Pc, ubyte @ A, uword @ XY     ; (via 816 ($330)) load from device
 romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) clobbers (X, Y) -> bool @ Pc, ubyte @ A       ; (via 818 ($332)) save to a device.  See also BSAVE
 romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
-romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y       ; read the software clock (A=lo,X=mid,Y=high)
-romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A      ; (via 808 ($328)) check the STOP key (and some others in A)
-romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A    ; (via 810 ($32A)) get a character
+romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y       ; read the software clock (in little endian order: A=lo,X=mid,Y=high) , however use RDTIM_safe() instead
+romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A       ; (via 808 ($328)) check the STOP key (and some others in A)        also see STOP2
+romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A     ; (via 810 ($32A)) get a character      also see GETIN2
 romsub $FFE7 = CLALL() clobbers(A,X)                            ; (via 812 ($32C)) close all files
 romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
-romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of screen rows and columns
-romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, bool dir @ Pc) clobbers(A) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use txt.plot for a 'safe' wrapper that preserves X.
+romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; get size of text screen into X (columns) and Y (rows)
+romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, bool dir @ Pc) clobbers(A) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Also see txt.plot
 romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
 
 ; ---- utility
 
-asmsub STOP2() clobbers(X) -> bool @A  {
-    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the zero status flag.
+inline asmsub STOP2() clobbers(X,A) -> bool @Pz  {
+    ; -- just like STOP, but omits the special keys result value in A.
+    ;    just for convenience because most of the times you're only interested in the stop pressed or not status.
     %asm {{
         jsr  cbm.STOP
-        beq  +
-        lda  #0
-        rts
-+       lda  #1
-        rts
     }}
 }
 
-asmsub RDTIM16() clobbers(X) -> uword @AY {
-    ; --  like RDTIM() but only returning the lower 16 bits in AY for convenience. Also avoids ram bank issue for irqs.
+inline asmsub GETIN2() clobbers(X,Y) -> ubyte @A {
+    ; -- just like GETIN, but omits the carry flag result value.
+    ;    just for convenience because GETIN is so often used to just read keyboard input,
+    ;    where you don't have to deal with a potential error status
+    %asm {{
+        jsr  cbm.GETIN
+    }}
+}
+
+asmsub RDTIM_safe() -> ubyte @ A, ubyte @ X, ubyte @ Y {
+    ; -- read the software clock (in little endian order: A=lo,X=mid,Y=high)
+    ;    with safeguard for ram bank issue for irqs.
     %asm {{
         php
         sei
         jsr  cbm.RDTIM
         plp
-        cli
+        rts
+    }}
+}
+
+asmsub RDTIM16() clobbers(X) -> uword @AY {
+    ; --  like RDTIM_safe() but only returning the lower 16 bits in AY for convenience.
+    %asm {{
+        jsr  RDTIM_safe
         pha
         txa
         tay
@@ -104,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
@@ -295,33 +313,33 @@ cx16 {
     &ubyte  VERA_SPI_CTRL       = VERA_BASE + $001F
 
     ; Vera FX registers: (accessing depends on particular DCSEL value set in VERA_CTRL!)
-    &ubyte VERA_FX_CTRL         = VERA_BASE + $0009
-    &ubyte VERA_FX_TILEBASE     = VERA_BASE + $000a
-    &ubyte VERA_FX_MAPBASE      = VERA_BASE + $000b
-    &ubyte VERA_FX_MULT         = VERA_BASE + $000c
-    &ubyte VERA_FX_X_INCR_L     = VERA_BASE + $0009
-    &ubyte VERA_FX_X_INCR_H     = VERA_BASE + $000a
-    &uword VERA_FX_X_INCR       = VERA_BASE + $0009
-    &ubyte VERA_FX_Y_INCR_L     = VERA_BASE + $000b
-    &ubyte VERA_FX_Y_INCR_H     = VERA_BASE + $000c
-    &uword VERA_FX_Y_INCR       = VERA_BASE + $000b
-    &ubyte VERA_FX_X_POS_L      = VERA_BASE + $0009
-    &ubyte VERA_FX_X_POS_H      = VERA_BASE + $000a
-    &uword VERA_FX_X_POS        = VERA_BASE + $0009
-    &ubyte VERA_FX_Y_POS_L      = VERA_BASE + $000b
-    &ubyte VERA_FX_Y_POS_H      = VERA_BASE + $000c
-    &uword VERA_FX_Y_POS        = VERA_BASE + $000b
-    &ubyte VERA_FX_X_POS_S      = VERA_BASE + $0009
-    &ubyte VERA_FX_Y_POS_S      = VERA_BASE + $000a
-    &ubyte VERA_FX_POLY_FILL_L  = VERA_BASE + $000b
-    &ubyte VERA_FX_POLY_FILL_H  = VERA_BASE + $000c
-    &uword VERA_FX_POLY_FILL    = VERA_BASE + $000b
-    &ubyte VERA_FX_CACHE_L      = VERA_BASE + $0009
-    &ubyte VERA_FX_CACHE_M      = VERA_BASE + $000a
-    &ubyte VERA_FX_CACHE_H      = VERA_BASE + $000b
-    &ubyte VERA_FX_CACHE_U      = VERA_BASE + $000c
-    &ubyte VERA_FX_ACCUM        = VERA_BASE + $000a
-    &ubyte VERA_FX_ACCUM_RESET  = VERA_BASE + $0009
+    &ubyte  VERA_FX_CTRL        = VERA_BASE + $0009
+    &ubyte  VERA_FX_TILEBASE    = VERA_BASE + $000a
+    &ubyte  VERA_FX_MAPBASE     = VERA_BASE + $000b
+    &ubyte  VERA_FX_MULT        = VERA_BASE + $000c
+    &ubyte  VERA_FX_X_INCR_L    = VERA_BASE + $0009
+    &ubyte  VERA_FX_X_INCR_H    = VERA_BASE + $000a
+    &uword  VERA_FX_X_INCR      = VERA_BASE + $0009
+    &ubyte  VERA_FX_Y_INCR_L    = VERA_BASE + $000b
+    &ubyte  VERA_FX_Y_INCR_H    = VERA_BASE + $000c
+    &uword  VERA_FX_Y_INCR      = VERA_BASE + $000b
+    &ubyte  VERA_FX_X_POS_L     = VERA_BASE + $0009
+    &ubyte  VERA_FX_X_POS_H     = VERA_BASE + $000a
+    &uword  VERA_FX_X_POS       = VERA_BASE + $0009
+    &ubyte  VERA_FX_Y_POS_L     = VERA_BASE + $000b
+    &ubyte  VERA_FX_Y_POS_H     = VERA_BASE + $000c
+    &uword  VERA_FX_Y_POS       = VERA_BASE + $000b
+    &ubyte  VERA_FX_X_POS_S     = VERA_BASE + $0009
+    &ubyte  VERA_FX_Y_POS_S     = VERA_BASE + $000a
+    &ubyte  VERA_FX_POLY_FILL_L = VERA_BASE + $000b
+    &ubyte  VERA_FX_POLY_FILL_H = VERA_BASE + $000c
+    &uword  VERA_FX_POLY_FILL   = VERA_BASE + $000b
+    &ubyte  VERA_FX_CACHE_L     = VERA_BASE + $0009
+    &ubyte  VERA_FX_CACHE_M     = VERA_BASE + $000a
+    &ubyte  VERA_FX_CACHE_H     = VERA_BASE + $000b
+    &ubyte  VERA_FX_CACHE_U     = VERA_BASE + $000c
+    &ubyte  VERA_FX_ACCUM       = VERA_BASE + $000a
+    &ubyte  VERA_FX_ACCUM_RESET = VERA_BASE + $0009
 
 
 ; VERA_PSG_BASE     = $1F9C0
@@ -376,20 +394,16 @@ cx16 {
 ; ---- Commander X-16 additions on top of C64 kernal routines ----
 ; spelling of the names is taken from the Commander X-16 rom sources
 
-; supported C128 additions
 romsub $ff4a = CLOSE_ALL(ubyte device @A)  clobbers(A,X,Y)
 romsub $ff59 = LKUPLA(ubyte la @A)  clobbers(A,X,Y)
 romsub $ff5c = LKUPSA(ubyte sa @Y)  clobbers(A,X,Y)
-romsub $ff5f = screen_mode(ubyte mode @A, bool getCurrent @Pc)  clobbers(X, Y) -> ubyte @A, bool @Pc        ; note: X,Y size result is not supported, use SCREEN or get_screen_mode routine for that
-romsub $ff62 = screen_set_charset(ubyte charset @A, uword charsetptr @XY)  clobbers(A,X,Y)      ; incompatible with C128  dlchr()
-; not yet supported: romsub $ff65 = pfkey()  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()
 
-; It's not documented what registers are clobbered, so we assume the worst for all following kernal routines...:
-
 ; high level graphics & fonts
 romsub $ff20 = GRAPH_init(uword vectors @R0)  clobbers(A,X,Y)
 romsub $ff23 = GRAPH_clear()  clobbers(A,X,Y)
@@ -422,9 +436,11 @@ romsub $ff1a = FB_filter_pixels(uword pointer @ R0, uword count @R1)  clobbers(A
 romsub $ff1d = FB_move_pixels(uword sx @R0, uword sy @R1, uword tx @R2, uword ty @R3, uword count @R4)  clobbers(A,X,Y)
 
 ; misc
-romsub $FEBA = BSAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) clobbers (X, Y) -> bool @ Pc, ubyte @ A      ; like cbm.SAVE, but omits the 2-byte prg header
 romsub $fec6 = i2c_read_byte(ubyte device @X, ubyte offset @Y) clobbers (X,Y) -> ubyte @A, bool @Pc
 romsub $fec9 = i2c_write_byte(ubyte device @X, ubyte offset @Y, ubyte data @A) clobbers (A,X,Y) -> bool @Pc
+romsub $feb4 = i2c_batch_read(ubyte device @X, uword buffer @R0, uword length @R1, bool advance @Pc) clobbers(A,Y) -> bool @Pc
+romsub $feb7 = i2c_batch_write(ubyte device @X, uword buffer @R0, uword length @R1, bool advance @Pc) clobbers(A,Y) -> bool @Pc
+
 romsub $fef0 = sprite_set_image(uword pixels @R0, uword mask @R1, ubyte bpp @R2, ubyte number @A, ubyte width @X, ubyte height @Y, bool apply_mask @Pc)  clobbers(A,X,Y) -> bool @Pc
 romsub $fef3 = sprite_set_position(uword x @R0, uword y @R1, ubyte number @A)  clobbers(A,X,Y)
 romsub $fee4 = memory_fill(uword address @R0, uword num_bytes @R1, ubyte value @A)  clobbers(A,X,Y)
@@ -437,10 +453,13 @@ romsub $fee1 = console_get_char()  clobbers(X,Y) -> ubyte @A
 romsub $fed8 = console_put_image(uword pointer @R0, uword width @R1, uword height @R2)  clobbers(A,X,Y)
 romsub $fed5 = console_set_paging_message(uword msgptr @R0)  clobbers(A,X,Y)
 romsub $fecf = entropy_get() -> ubyte @A, ubyte @X, ubyte @Y
+;; romsub $fea8 = extapi16(ubyte callnumber @A) clobbers (A,X,Y)    ; not useful yet because is for 65816 cpu
+romsub $feab = extapi(ubyte callnumber @A) clobbers (A,X,Y)
 romsub $fecc = monitor()  clobbers(A,X,Y)
 
 romsub $ff44 = MACPTR(ubyte length @A, uword buffer @XY, bool dontAdvance @Pc)  clobbers(A) -> bool @Pc, uword @XY
 romsub $feb1 = MCIOUT(ubyte length @A, uword buffer @XY, bool dontAdvance @Pc)  clobbers(A) -> bool @Pc, uword @XY
+romsub $FEBA = BSAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) clobbers (X, Y) -> bool @ Pc, ubyte @ A      ; like cbm.SAVE, but omits the 2-byte prg header
 romsub $ff47 = enter_basic(bool cold_or_warm @Pc)  clobbers(A,X,Y)
 romsub $ff4d = clock_set_date_time(uword yearmonth @R0, uword dayhours @R1, uword minsecs @R2, uword jiffiesweekday @R3)  clobbers(A, X, Y)
 romsub $ff50 = clock_get_date_time()  clobbers(A, X, Y)  -> uword @R0, uword @R1, uword @R2, uword @R3   ; result registers see clock_set_date_time()
@@ -448,16 +467,14 @@ romsub $ff50 = clock_get_date_time()  clobbers(A, X, Y)  -> uword @R0, uword @R1
 ; keyboard, mouse, joystick
 ; note: also see the cbm.kbdbuf_clear() helper routine
 romsub $febd = kbdbuf_peek() -> ubyte @A, ubyte @X     ; key in A, queue length in X
-romsub $febd = kbdbuf_peek2() -> uword @AX             ; alternative to above to not have the hassle to deal with multiple return values
 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
+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) -> ubyte @A, ubyte @X, ubyte @Y
-romsub $ff56 = joystick_get2(ubyte joynr @A) clobbers(Y) -> uword @AX   ; alternative to above to not have the hassle to deal with multiple return values
+romsub $ff56 = joystick_get(ubyte joynr @A) -> uword @AX, bool @Y   ; note: everything is inverted
 
 ; X16Edit (rom bank 13/14 but you ideally should use the routine search_x16edit() to search for the correct bank)
 romsub $C000 = x16edit_default() clobbers(A,X,Y)
@@ -524,6 +541,28 @@ romsub $C099 = ym_getatten(ubyte channel @A) clobbers(Y) -> ubyte @X
 romsub $C09C = ym_getpan(ubyte channel @A) clobbers(Y) -> ubyte @X
 romsub $C0A5 = ym_get_chip_type() clobbers(X) -> ubyte @A
 
+; extapi call numbers
+const ubyte  EXTAPI_clear_status = $01
+const ubyte  EXTAPI_getlfs = $02
+const ubyte  EXTAPI_mouse_sprite_offset = $03
+const ubyte  EXTAPI_joystick_ps2_keycodes = $04
+const ubyte  EXTAPI_iso_cursor_char = $05
+const ubyte  EXTAPI_ps2kbd_typematic = $06
+const ubyte  EXTAPI_pfkey = $07
+const ubyte  EXTAPI_ps2data_fetch = $08
+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
+const ubyte  EXTAPI16_stack_push = $01
+const ubyte  EXTAPI16_stack_pop = $02
+const ubyte  EXTAPI16_stack_enter_kernal_stack = $03
+const ubyte  EXTAPI16_stack_leave_kernal_stack = $04
+
 
 asmsub set_screen_mode(ubyte mode @A) clobbers(A,X,Y) -> bool @Pc {
     ; -- convenience wrapper for screen_mode() to just set a new mode (and return success)
@@ -533,9 +572,8 @@ asmsub set_screen_mode(ubyte mode @A) clobbers(A,X,Y) -> bool @Pc {
     }}
 }
 
-asmsub get_screen_mode() -> byte @A, byte @X, byte @Y {
-    ; -- convenience wrapper for screen_mode() to just get the current mode in A, and size in characters in X+Y
-    ;    this does need a piece of inlined asm to call it ans store the result values if you call this from prog8 code
+asmsub get_screen_mode() -> ubyte @A, ubyte @X, ubyte @Y {
+    ; -- convenience wrapper for screen_mode() to just get the current mode in A, and size in characters in X (width) and Y (height)
     ;    Note: you can also just do the SEC yourself and simply call screen_mode() directly,
     ;          or use the existing SCREEN kernal routine for just getting the size in characters.
     %asm {{
@@ -555,15 +593,72 @@ asmsub mouse_config2(byte shape @A) clobbers (A, X, Y) {
     }}
 }
 
-asmsub mouse_pos() clobbers(X) -> ubyte @A {
+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
         jmp  cx16.mouse_get
     }}
 }
 
+; shims for the kernal routines called via the extapi call:
+
+asmsub mouse_set_pos(uword xpos @R0, uword ypos @R1) clobbers(X) {
+    ; -- sets the mouse sprite position
+    ;    Note: mouse pointer needs to be enabled for this to do anything.
+    %asm {{
+        ldx  #cx16.r0L
+        lda  #EXTAPI_mouse_set_position
+        jmp  cx16.extapi
+    }}
+}
+
+asmsub mouse_set_sprite_offset(word xoffset @R0, word yoffset @R1) clobbers(A,X,Y) {
+    %asm {{
+        clc
+        lda  #EXTAPI_mouse_sprite_offset
+        jmp  cx16.extapi
+    }}
+}
+
+asmsub mouse_get_sprite_offset() clobbers(A,X,Y) -> word @R0, word @R1 {
+    %asm {{
+        sec
+        lda  #EXTAPI_mouse_sprite_offset
+        jmp  cx16.extapi
+    }}
+}
+
+asmsub getlfs() -> ubyte @X, ubyte @A, ubyte @Y {
+    ; -- return the result of the last call to SETLFS:  A=logical, X=device, Y=secondary.
+    %asm {{
+        lda  #EXTAPI_mouse_set_position
+        jmp  cx16.extapi
+    }}
+}
+
+asmsub iso_cursor_char(ubyte character @X) clobbers(A,X,Y) {
+    ; -- set the screen code for the cursor character in ISO mode (the default is $9f).
+    %asm {{
+        clc
+        lda  #EXTAPI_iso_cursor_char
+        jmp  cx16.extapi
+    }}
+}
+
+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.
+
 
 ; ---- end of kernal routines ----
 
@@ -918,7 +1013,7 @@ asmsub restore_vera_context() clobbers(A) {
 
     asmsub set_chrin_keyhandler(ubyte handlerbank @A, uword handler @XY) clobbers(A) {
         ; Install a custom CHRIN (BASIN) key handler in a safe manner. Call this before each line you want to read.
-        ; See https://github.com/X16Community/x16-docs/blob/master/X16%20Reference%20-%2002%20-%20Editor.md#custom-basin-petscii-code-override-handler
+        ; See https://github.com/X16Community/x16-docs/blob/101759f3bfa5e6cce4e8c5a0b67cb0f2f1c6341e/X16%20Reference%20-%2003%20-%20Editor.md#custom-basin-petscii-code-override-handler
         %asm {{
             sei
             sta  P8ZP_SCRATCH_REG
@@ -980,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
 
@@ -1105,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
@@ -1158,7 +1254,7 @@ sub search_x16edit() -> ubyte {
 }
 
     asmsub cpu_is_65816() -> bool @A {
-        ; Returns true when you have a 65816 cpu, false when it's a 6502.
+        ; -- Returns true when you have a 65816 cpu, false when it's a 6502.
         %asm {{
 			php
 			clv
@@ -1174,9 +1270,9 @@ sub search_x16edit() -> ubyte {
     }
 
     sub set_program_args(uword args_ptr, ubyte args_size) {
-        ; Set the inter-program arguments.
+        ; -- Set the inter-program arguments.
         ; standardized way to pass arguments between programs is in ram bank 0, address $bf00-$bfff.
-        ; see https://github.com/X16Community/x16-docs/blob/master/X16%20Reference%20-%2007%20-%20Memory%20Map.md#bank-0
+        ; see https://github.com/X16Community/x16-docs/blob/101759f3bfa5e6cce4e8c5a0b67cb0f2f1c6341e/X16%20Reference%20-%2008%20-%20Memory%20Map.md#bank-0
         sys.push(getrambank())
         rambank(0)
         sys.memcopy(args_ptr, $bf00, args_size)
@@ -1186,9 +1282,9 @@ sub search_x16edit() -> ubyte {
     }
 
     asmsub get_program_args(uword buffer @R0, ubyte buf_size @R1, bool binary @Pc) {
-        ; Retrieve the inter-program arguments. If binary=false, it treats them as a string (stops copying at first zero).
+        ; -- Retrieve the inter-program arguments. If binary=false, it treats them as a string (stops copying at first zero).
         ; standardized way to pass arguments between programs is in ram bank 0, address $bf00-$bfff.
-        ; see https://github.com/X16Community/x16-docs/blob/master/X16%20Reference%20-%2007%20-%20Memory%20Map.md#bank-0
+        ; see https://github.com/X16Community/x16-docs/blob/101759f3bfa5e6cce4e8c5a0b67cb0f2f1c6341e/X16%20Reference%20-%2008%20-%20Memory%20Map.md#bank-0
         %asm {{
             lda  #0
             rol  a
@@ -1215,19 +1311,40 @@ _continue   iny
     }
 
     sub reset_system() {
-        ; Soft-reset the system back to initial power-on Basic prompt.
+        ; -- Soft-reset the system back to initial power-on Basic prompt.
         sys.reset_system()
     }
 
     sub poweroff_system() {
-        ; use the SMC to shutdown the computer
+        ; -- use the SMC to shutdown the computer
         void cx16.i2c_write_byte($42, $01, $00)
     }
 
-    sub set_led_brightness(ubyte brightness) {
-        void cx16.i2c_write_byte($42, $05, brightness)
+    sub set_led_state(bool on) {
+        ; -- sets the computer's activity led on/off
+        cx16.r0L = 0
+        if on
+            cx16.r0 = 255
+        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 {
@@ -1284,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
@@ -1324,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
@@ -1355,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
@@ -1384,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
 
@@ -1442,11 +1559,6 @@ asmsub  set_rasterline(uword line @AY) {
         void cx16.i2c_write_byte($42, $01, $00)
     }
 
-    sub set_leds_brightness(ubyte activity, ubyte power) {
-        void cx16.i2c_write_byte($42, $04, power)
-        void cx16.i2c_write_byte($42, $05, activity)
-    }
-
     asmsub wait(uword jiffies @AY) clobbers(X) {
         ; --- wait approximately the given number of jiffies (1/60th seconds) (N or N+1)
         ;     note: the system irq handler has to be active for this to work as it depends on the system jiffy clock

compiler/res/prog8lib/cx16/textio.p8

@@ -4,7 +4,7 @@
 
 %import syslib
 %import conv
-%import shared_textio_functions
+%import shared_cbm_textio_functions
 
 txt {
 
@@ -16,11 +16,17 @@ const ubyte DEFAULT_HEIGHT = 60
 const ubyte VERA_TEXTMATRIX_BANK = 1
 const uword VERA_TEXTMATRIX_ADDR = $b000
 
+romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse. Note: takes a PETSCII encoded character.
+
 
 sub clear_screen() {
     chrout(147)
 }
 
+sub cls() {
+    chrout(147)
+}
+
 sub home() {
     chrout(19)
 }
@@ -223,8 +229,8 @@ sub uppercase() {
 }
 
 sub iso() {
+    ; -- switch to iso-8859-15 character set
     cbm.CHROUT($0f)
-    ; This doesn't enable it completely: cx16.screen_set_charset(1, 0)  ; iso charset
 }
 
 sub iso_off() {
@@ -232,6 +238,35 @@ sub iso_off() {
     cbm.CHROUT($8f)
 }
 
+sub cp437() {
+    ; -- switch to CP-437 (ibm PC) character set
+    cbm.CHROUT($0f)                 ; iso mode
+    cx16.screen_set_charset(7, 0)   ; charset
+    %asm {{
+        clc
+        ldx  #95        ; underscore
+        lda  #cx16.EXTAPI_iso_cursor_char
+        jsr  cx16.extapi
+    }}
+}
+
+sub iso5() {
+    ; -- switch to iso-8859-5 character set (Cyrillic)
+    cbm.CHROUT($0f)                 ; iso mode
+    cx16.screen_set_charset(8, 0)   ; charset
+}
+
+sub iso16() {
+    ; -- switch to iso-8859-16 character set (Eastern Europe)
+    cbm.CHROUT($0f)                 ; iso mode
+    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
@@ -431,215 +466,6 @@ _nextline
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse. Note: takes a PETSCII encoded character.
-
-asmsub  print (str text @ AY) clobbers(A,Y)  {
-	; ---- print null terminated string, in PETSCII encoding, from A/Y
-	; note: the compiler contains an optimization that will replace
-	;       a call to this subroutine with a string argument of just one char,
-	;       by just one call to cbm.CHROUT of that single char.
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		sty  P8ZP_SCRATCH_REG
-		ldy  #0
--		lda  (P8ZP_SCRATCH_B1),y
-		beq  +
-		jsr  cbm.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
-	%asm {{
-		jsr  conv.ubyte2decimal
-		pha
-		tya
-		jsr  cbm.CHROUT
-		pla
-		jsr  cbm.CHROUT
-		txa
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in decimal form, without left padding 0s
-	%asm {{
-		jsr  conv.ubyte2decimal
-_print_byte_digits
-		pha
-		cpy  #'0'
-		beq  +
-		tya
-		jsr  cbm.CHROUT
-		pla
-		jsr  cbm.CHROUT
-		bra  _ones
-+       pla
-        cmp  #'0'
-        beq  _ones
-        jsr  cbm.CHROUT
-_ones   txa
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
-	; ---- print the byte in A in decimal form, without left padding 0s
-	%asm {{
-		pha
-		cmp  #0
-		bpl  +
-		lda  #'-'
-		jsr  cbm.CHROUT
-+		pla
-		jsr  conv.byte2decimal
-		bra  print_ub._print_byte_digits
-	}}
-}
-
-asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		bcc  +
-		pha
-		lda  #'$'
-		jsr  cbm.CHROUT
-		pla
-+		jsr  conv.ubyte2hex
-		jsr  cbm.CHROUT
-		tya
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'%'
-		jsr  cbm.CHROUT
-+		ldy  #8
--		lda  #'0'
-		asl  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'1'
-+		jsr  cbm.CHROUT
-		dey
-		bne  -
-		rts
-	}}
-}
-
-asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubbin
-		pla
-		clc
-		bra  print_ubbin
-	}}
-}
-
-asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in hexadecimal form (4 digits)
-	;      (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubhex
-		pla
-		clc
-		bra  print_ubhex
-	}}
-}
-
-asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
-	%asm {{
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-        beq  +
-		jsr  cbm.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in decimal form, without left padding 0s
-	%asm {{
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-		beq  _allzero
-		cmp  #'0'
-		bne  _gotdigit
-		iny
-		bne  -
-
-_gotdigit
-		jsr  cbm.CHROUT
-		iny
-		lda  conv.uword2decimal.decTenThousands,y
-		bne  _gotdigit
-		rts
-_allzero
-        lda  #'0'
-        jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
-	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
-	%asm {{
-		cpy  #0
-		bpl  +
-		pha
-		lda  #'-'
-		jsr  cbm.CHROUT
-		tya
-		eor  #255
-		tay
-		pla
-		eor  #255
-		ina
-		bne +
-		iny
-+		bra  print_uw
-	}}
-}
-
-asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
-	; ---- Input a string (max. 80 chars) from the keyboard, in PETSCII encoding.
-	;      Returns length in Y. (string is terminated with a 0 byte as well)
-	;      It assumes the keyboard is selected as I/O channel!
-
-	%asm {{
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0				; char counter = 0
--		jsr  cbm.CHRIN
-		cmp  #$0d			; return (ascii 13) pressed?
-		beq  +				; yes, end.
-		sta  (P8ZP_SCRATCH_W1),y	; else store char in buffer
-		iny
-		bne  -
-+		lda  #0
-		sta  (P8ZP_SCRATCH_W1),y	; finish string with 0 byte
-		rts
-
-	}}
-}
-
 asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A)  {
 	; ---- sets the character in the screen matrix at the given position
 	%asm {{
@@ -811,4 +637,35 @@ asmsub waitkey() -> ubyte @A {
         rts
     }}
 }
+
+asmsub chrout_lit(ubyte character @A) {
+    ; -- print the character always as a literal character, not as possible control code.
+    %asm {{
+        tax
+        lda  #128
+        jsr  cbm.CHROUT
+        txa
+        jmp  cbm.CHROUT
+    }}
+}
+
+asmsub print_lit(str text @ AY) clobbers(A,Y)  {
+    ; -- print zero terminated string, from A/Y, as all literal characters (no control codes)
+    %asm {{
+        sta  P8ZP_SCRATCH_W2
+        sty  P8ZP_SCRATCH_W2+1
+        ldy  #0
+-       lda  (P8ZP_SCRATCH_W2),y
+        beq  +
+        tax
+        lda  #128
+        jsr  cbm.CHROUT
+        txa
+        jsr  cbm.CHROUT
+        iny
+        bne  -
++       rts
+    }}
+}
+
 }

compiler/res/prog8lib/cx16/verafx.p8

@@ -1,6 +1,6 @@
 ; Somewhat experimental Vera FX support.
 ; Docs:
-; https://github.com/X16Community/x16-docs/blob/master/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 {
@@ -111,17 +111,15 @@ verafx {
 
     ; unsigned multiplication just passes the values as signed to muls
     ; if you do this yourself in your call to muls, it will save a few instructions.
-    sub mult(uword value1, uword value2) -> uword {
-        ; Returns the lower 16 bits of the 32 bits result,
-        ; the upper 16 bits are stored in cx16.r0 so you can access those separately.
-        ; It's not part of the subroutine's signature to avoid awkward use of multiple returnvalues.
-        return muls(value1 as word, value2 as word) as uword
+    inline asmsub mult(uword value1 @R0, uword value2 @R1) clobbers(X) -> uword @AY, uword @R0 {
+        ; Returns the 32 bits unsigned result in AY and R0  (lower word, upper word).
+        %asm {{
+            jsr  verafx.muls
+        }}
     }
 
-    asmsub muls(word value1 @R0, word value2 @R1) clobbers(X) -> word @AY {
-        ; Returns the lower 16 bits of the 32 bits result in AY,
-        ; the upper 16 bits are stored in cx16.r0 so you can access those separately.
-        ; It's not part of the subroutine's signature to avoid awkward use of multiple returnvalues.
+    asmsub muls(word value1 @R0, word value2 @R1) clobbers(X) -> word @AY, word @R0 {
+        ; Returns the 32 bits signed result in AY and R0  (lower word, upper word).
         %asm {{
             lda  #(2 << 1)
             sta  cx16.VERA_CTRL        ; $9F25
@@ -131,13 +129,13 @@ verafx {
             lda  #(6 << 1)
             sta  cx16.VERA_CTRL        ; $9F25
             lda  cx16.r0
-            ldy  cx16.r0+1
             sta  cx16.VERA_FX_CACHE_L  ; $9F29
-            sty  cx16.VERA_FX_CACHE_M  ; $9F2A
+            lda  cx16.r0+1
+            sta  cx16.VERA_FX_CACHE_M  ; $9F2A
             lda  cx16.r1
-            ldy  cx16.r1+1
             sta  cx16.VERA_FX_CACHE_H  ; $9F2B
-            sty  cx16.VERA_FX_CACHE_U  ; $9F2C
+            lda  cx16.r1+1
+            sta  cx16.VERA_FX_CACHE_U  ; $9F2C
             lda  cx16.VERA_FX_ACCUM_RESET   ; $9F29 (DCSEL=6)
 
             ; Set the ADDR0 pointer to $1f9bc and write our multiplication result there
@@ -155,12 +153,12 @@ verafx {
             stz  cx16.VERA_DATA0      ; multiply and write out result
             lda  #%00010001           ; $01 with Increment 1
             sta  cx16.VERA_ADDR_H     ; so we can read out the result
-            lda  cx16.VERA_DATA0
+            lda  cx16.VERA_DATA0      ; store the lower 16 bits of the result in AY
             ldy  cx16.VERA_DATA0
-            ldx  cx16.VERA_DATA0      ; store the upper 16 bits of the result in r0
-            stx  cx16.r0
+            ldx  cx16.VERA_DATA0      ; store the upper 16 bits of the result in R0
+            stx  cx16.r0s
             ldx  cx16.VERA_DATA0
-            stx  cx16.r0+1
+            stx  cx16.r0s+1
             stz  cx16.VERA_FX_CTRL    ; Cache write disable
             stz  cx16.VERA_CTRL       ; reset DCSEL
             rts
@@ -168,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

@@ -59,7 +59,8 @@ diskio {
             void cbm.CHRIN()     ; skip 2 bytes
             void cbm.CHRIN()
             status = cbm.READST()
-            if cbm.STOP2()
+            void cbm.STOP()
+            if_z
                 break
         }
         status = cbm.READST()
@@ -332,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
 
@@ -345,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
@@ -367,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
         }}
     }
 
@@ -404,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 {
@@ -460,6 +465,38 @@ io_error:
         goto done
     }
 
+    ; similar to above, but instead of fetching the entire string, it only fetches the status code and returns it as ubyte
+    ; in case of IO error, returns 255 (CBM-DOS itself is physically unable to return such a value)
+    sub status_code() -> ubyte {
+        if cbm.READST()==128 {
+            return 255
+        }
+
+        cbm.SETNAM(0, list_filename)
+        cbm.SETLFS(15, drivenumber, 15)
+        void cbm.OPEN()          ; open 15,8,15
+        if_cs
+            goto io_error
+        void cbm.CHKIN(15)        ; use #15 as input channel
+
+        list_filename[0] = cbm.CHRIN()
+        list_filename[1] = cbm.CHRIN()
+        list_filename[2] = 0
+
+        while cbm.READST()==0 {
+            void cbm.CHRIN()
+        }
+
+        cbm.CLRCHN()        ; restore default i/o devices
+        cbm.CLOSE(15)
+        return conv.str2ubyte(list_filename)
+
+io_error:
+        cbm.CLRCHN()
+        cbm.CLOSE(15)
+        return 255
+    }
+
     sub save(uword filenameptr, uword start_address, uword savesize) -> bool {
         cbm.SETNAM(string.length(filenameptr), filenameptr)
         cbm.SETLFS(1, drivenumber, 0)

compiler/res/prog8lib/pet32/syslib.p8

@@ -29,20 +29,26 @@ romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; define an outp
 romsub $FFCC = CLRCHN() clobbers(A,X)                           ; restore default devices
 romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A              ; input a character (for keyboard, read a whole line from the screen) A=byte read.
 romsub $FFD2 = CHROUT(ubyte character @ A)                           ; output a character
-romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A       ; check the STOP key (and some others in A)
-romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A     ; get a character
+romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A       ; check the STOP key (and some others in A)     also see STOP2
+romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A     ; get a character       also see GETIN2
 romsub $FFE7 = CLALL() clobbers(A,X)                            ; close all files
 romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
 
-asmsub STOP2() clobbers(X) -> bool @A  {
-    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
+
+inline asmsub STOP2() clobbers(X,A) -> bool @Pz  {
+    ; -- just like STOP, but omits the special keys result value in A.
+    ;    just for convenience because most of the times you're only interested in the stop pressed or not status.
     %asm {{
         jsr  cbm.STOP
-        beq  +
-        lda  #0
-        rts
-+       lda  #1
-        rts
+    }}
+}
+
+inline asmsub GETIN2() clobbers(X,Y) -> ubyte @A {
+    ; -- just like GETIN, but omits the carry flag result value.
+    ;    just for convenience because GETIN is so often used to just read keyboard input,
+    ;    where you don't have to deal with a potential error status
+    %asm {{
+        jsr  cbm.GETIN
     }}
 }
 

compiler/res/prog8lib/pet32/textio.p8

@@ -4,7 +4,7 @@
 
 %import syslib
 %import conv
-%import shared_textio_functions
+%import shared_cbm_textio_functions
 
 txt {
     %option no_symbol_prefixing, ignore_unused
@@ -12,11 +12,17 @@ txt {
 const ubyte DEFAULT_WIDTH = 40
 const ubyte DEFAULT_HEIGHT = 25
 
+romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse. Note: takes a PETSCII encoded character.
+
 
 sub  clear_screen() {
     chrout(147)
 }
 
+sub cls() {
+    chrout(147)
+}
+
 sub home() {
     chrout(19)
 }
@@ -145,216 +151,6 @@ asmsub  scroll_down  () clobbers(A,X)  {
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse. Note: takes a PETSCII encoded character.
-
-asmsub  print (str text @ AY) clobbers(A,Y)  {
-	; ---- print null terminated string, in PETSCII encoding, from A/Y
-	; note: the compiler contains an optimization that will replace
-	;       a call to this subroutine with a string argument of just one char,
-	;       by just one call to cbm.CHROUT of that single char.
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		sty  P8ZP_SCRATCH_REG
-		ldy  #0
--		lda  (P8ZP_SCRATCH_B1),y
-		beq  +
-		jsr  cbm.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
-	%asm {{
-		jsr  conv.ubyte2decimal
-		pha
-		tya
-		jsr  cbm.CHROUT
-		pla
-		jsr  cbm.CHROUT
-		txa
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in decimal form, without left padding 0s
-	%asm {{
-		jsr  conv.ubyte2decimal
-_print_byte_digits
-		pha
-		cpy  #'0'
-		beq  +
-		tya
-		jsr  cbm.CHROUT
-		pla
-		jsr  cbm.CHROUT
-		jmp  _ones
-+       pla
-        cmp  #'0'
-        beq  _ones
-        jsr  cbm.CHROUT
-_ones   txa
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
-	; ---- print the byte in A in decimal form, without left padding 0s
-	%asm {{
-		pha
-		cmp  #0
-		bpl  +
-		lda  #'-'
-		jsr  cbm.CHROUT
-+		pla
-		jsr  conv.byte2decimal
-		jmp  print_ub._print_byte_digits
-	}}
-}
-
-asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		bcc  +
-		pha
-		lda  #'$'
-		jsr  cbm.CHROUT
-		pla
-+		jsr  conv.ubyte2hex
-		jsr  cbm.CHROUT
-		tya
-		jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'%'
-		jsr  cbm.CHROUT
-+		ldy  #8
--		lda  #'0'
-		asl  P8ZP_SCRATCH_B1
-		bcc  +
-		lda  #'1'
-+		jsr  cbm.CHROUT
-		dey
-		bne  -
-		rts
-	}}
-}
-
-asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubbin
-		pla
-		clc
-		jmp  print_ubbin
-	}}
-}
-
-asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in hexadecimal form (4 digits)
-	;      (if Carry is set, a radix prefix '$' is printed as well)
-	%asm {{
-		pha
-		tya
-		jsr  print_ubhex
-		pla
-		clc
-		jmp  print_ubhex
-	}}
-}
-
-asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
-	%asm {{
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-        beq  +
-		jsr  cbm.CHROUT
-		iny
-		bne  -
-+		rts
-	}}
-}
-
-asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- print the uword in A/Y in decimal form, without left padding 0s
-	%asm {{
-		jsr  conv.uword2decimal
-		ldy  #0
--		lda  conv.uword2decimal.decTenThousands,y
-		beq  _allzero
-		cmp  #'0'
-		bne  _gotdigit
-		iny
-		bne  -
-
-_gotdigit
-		jsr  cbm.CHROUT
-		iny
-		lda  conv.uword2decimal.decTenThousands,y
-		bne  _gotdigit
-		rts
-_allzero
-        lda  #'0'
-        jmp  cbm.CHROUT
-	}}
-}
-
-asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
-	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
-	%asm {{
-		cpy  #0
-		bpl  +
-		pha
-		lda  #'-'
-		jsr  cbm.CHROUT
-		tya
-		eor  #255
-		tay
-		pla
-		eor  #255
-		clc
-		adc  #1
-		bcc  +
-		iny
-+		jmp  print_uw
-	}}
-}
-
-asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
-	; ---- Input a string (max. 80 chars) from the keyboard, in PETSCII encoding.
-	;      Returns length in Y. (string is terminated with a 0 byte as well)
-	;      It assumes the keyboard is selected as I/O channel!
-
-	%asm {{
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0				; char counter = 0
--		jsr  cbm.CHRIN
-		cmp  #$0d			; return (ascii 13) pressed?
-		beq  +				; yes, end.
-		sta  (P8ZP_SCRATCH_W1),y	; else store char in buffer
-		iny
-		bne  -
-+		lda  #0
-		sta  (P8ZP_SCRATCH_W1),y	; finish string with 0 byte
-		rts
-
-	}}
-}
-
 asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A, Y)  {
 	; ---- sets the character in the screen matrix at the given position
 	%asm {{

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_cbm_textio_functions.p8

@@ -0,0 +1,251 @@
+txt {
+    ; the textio functions common across CBM-compatible compiler targets (c64, c128, pet32 and cx16)
+
+    %option merge, no_symbol_prefixing, ignore_unused
+
+    asmsub  print (str text @ AY) clobbers(A,Y)  {
+    	; ---- print zero terminated string, in PETSCII encoding, from A/Y
+    	; note: the compiler contains an optimization that will replace
+    	;       a call to this subroutine with a string argument of just one char,
+    	;       by just one call to cbm.CHROUT of that single char.
+    	%asm {{
+    		sta  P8ZP_SCRATCH_W2
+    		sty  P8ZP_SCRATCH_W2+1
+    		ldy  #0
+-	    	lda  (P8ZP_SCRATCH_W2),y
+    		beq  +
+    		jsr  cbm.CHROUT
+    		iny
+    		bne  -
++	    	rts
+    	}}
+    }
+
+    asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
+        ; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
+        %asm {{
+            bcc  +
+            pha
+            lda  #'$'
+            jsr  cbm.CHROUT
+            pla
++           jsr  conv.internal_ubyte2hex
+            jsr  cbm.CHROUT
+            tya
+            jmp  cbm.CHROUT
+        }}
+    }
+
+    asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
+        ; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
+        %asm {{
+            sta  P8ZP_SCRATCH_B1
+            bcc  +
+            lda  #'%'
+            jsr  cbm.CHROUT
++           ldy  #8
+-           lda  #'0'
+            asl  P8ZP_SCRATCH_B1
+            bcc  +
+            lda  #'1'
++           jsr  cbm.CHROUT
+            dey
+            bne  -
+            rts
+        }}
+    }
+
+    asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
+        ; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
+        %asm {{
+            pha
+            tya
+            jsr  print_ubbin
+            pla
+            clc
+            jmp  print_ubbin
+        }}
+    }
+
+    asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
+        ; ---- print the uword in A/Y in hexadecimal form (4 digits)
+        ;      (if Carry is set, a radix prefix '$' is printed as well)
+        %asm {{
+            pha
+            tya
+            jsr  print_ubhex
+            pla
+            clc
+            jmp  print_ubhex
+        }}
+    }
+
+    asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
+        ; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
+        %asm {{
+            jsr  conv.internal_uword2decimal
+            ldy  #0
+-           lda  conv.internal_uword2decimal.decTenThousands,y
+            beq  +
+            jsr  cbm.CHROUT
+            iny
+            bne  -
++           rts
+        }}
+    }
+
+    asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
+        ; ---- print the uword in A/Y in decimal form, without left padding 0s
+        %asm {{
+            jsr  conv.internal_uword2decimal
+            ldy  #0
+-           lda  conv.internal_uword2decimal.decTenThousands,y
+            beq  _allzero
+            cmp  #'0'
+            bne  _gotdigit
+            iny
+            bne  -
+_gotdigit   jsr  cbm.CHROUT
+            iny
+            lda  conv.internal_uword2decimal.decTenThousands,y
+            bne  _gotdigit
+            rts
+_allzero    lda  #'0'
+            jmp  cbm.CHROUT
+        }}
+    }
+
+    asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
+        ; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
+        %asm {{
+            cpy  #0
+            bpl  +
+            pha
+            lda  #'-'
+            jsr  cbm.CHROUT
+            tya
+            eor  #255
+            tay
+            pla
+            eor  #255
+            clc
+            adc  #1
+            bcc  +
+            iny
++           jmp  print_uw
+        }}
+    }
+
+    asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
+        ; ---- Input a string (max. 80 chars) from the keyboard, in PETSCII encoding.
+        ;      Returns length in Y. (string is terminated with a 0 byte as well)
+        ;      It assumes the keyboard is selected as I/O channel!
+
+        %asm {{
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            ldy  #0				; char counter = 0
+-           jsr  cbm.CHRIN
+            cmp  #$0d			; return (ascii 13) pressed?
+            beq  +				; yes, end.
+            sta  (P8ZP_SCRATCH_W1),y	; else store char in buffer
+            iny
+            bne  -
++           lda  #0
+            sta  (P8ZP_SCRATCH_W1),y	; finish string with 0 byte
+            rts
+        }}
+    }
+
+    asmsub petscii2scr(ubyte petscii_char @A) -> ubyte @A {
+        ; -- convert petscii character to screencode
+        %asm {{
+            sta  P8ZP_SCRATCH_REG
+            lsr  a
+            lsr  a
+            lsr  a
+            lsr  a
+            lsr  a
+            tax
+            lda  _offsets,x
+            eor  P8ZP_SCRATCH_REG
+            rts
+_offsets    .byte  128, 0, 64, 32, 64, 192, 128, 128
+        }}
+    }
+
+    asmsub petscii2scr_str(str petscii_string @AY) {
+        ; -- convert petscii string to screencodes string
+        %asm {{
+            sta  P8ZP_SCRATCH_W1
+            sty  P8ZP_SCRATCH_W1+1
+            ldy  #0
+-           lda  (P8ZP_SCRATCH_W1),y
+            beq  +
+            jsr  petscii2scr
+            sta  (P8ZP_SCRATCH_W1),y
+            iny
+            bne  -
++           rts
+        }}
+}
+
+
+    sub print_bool(bool value) {
+        if value
+            txt.print("true")
+        else
+            txt.print("false")
+    }
+
+    asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
+        ; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
+        %asm {{
+            jsr  conv.internal_ubyte2decimal
+            pha
+            tya
+            jsr  cbm.CHROUT
+            txa
+            jsr  cbm.CHROUT
+            pla
+            jmp  cbm.CHROUT
+        }}
+    }
+
+    asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
+        ; ---- print the ubyte in A in decimal form, without left padding 0s
+        %asm {{
+            jsr  conv.internal_ubyte2decimal
+_print_byte_digits
+            pha
+            cpy  #'0'
+            beq  +
+            tya
+            jsr  cbm.CHROUT
+            txa
+            jsr  cbm.CHROUT
+            jmp  _ones
++           cpx  #'0'
+            beq  _ones
+            txa
+            jsr  cbm.CHROUT
+_ones       pla
+            jmp  cbm.CHROUT
+        }}
+    }
+
+    asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
+        ; ---- print the byte in A in decimal form, without left padding 0s
+        %asm {{
+            pha
+            cmp  #0
+            bpl  +
+            lda  #'-'
+            jsr  cbm.CHROUT
++		    pla
+            jsr  conv.internal_byte2decimal
+            jmp  print_ub._print_byte_digits
+        }}
+    }
+
+}

compiler/res/prog8lib/shared_floats_functions.p8

@@ -2,6 +2,11 @@ floats {
     ; the floating point functions shared across compiler targets
     %option merge, no_symbol_prefixing, ignore_unused
 
+    const float  π      = 3.141592653589793
+    const float  PI     = π
+    const float  TWOPI  = 2*π
+
+
 asmsub print(float value @FAC1) clobbers(A,X,Y) {
 	; ---- prints the floating point value (without a newline). No leading space (unlike BASIC)!
 	%asm {{
@@ -88,6 +93,29 @@ 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
+    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
+}
+
+; reciprocal functions
+sub secant(float value) -> float { return 1.0 / cos(value) }
+sub csc(float value)    -> float { return 1.0 / sin(value) }
+sub cot(float value)    -> float { return 1.0 / tan(value) }
+
 sub ln(float value) -> float {
     %asm {{
         lda  #<value

compiler/res/prog8lib/shared_string_functions.p8

@@ -76,4 +76,44 @@ string {
         return s+cx16.r0L
     }
 
+    sub startswith(str st, str prefix) -> bool {
+        ubyte prefix_len = string.length(prefix)
+        ubyte str_len = string.length(st)
+        if prefix_len > str_len
+            return false
+        cx16.r9L = st[prefix_len]
+        st[prefix_len] = 0
+        cx16.r9H = string.compare(st, prefix) as ubyte
+        st[prefix_len] = cx16.r9L
+        return cx16.r9H==0
+    }
+
+    sub endswith(str st, str suffix) -> bool {
+        ubyte suffix_len = string.length(suffix)
+        ubyte str_len = string.length(st)
+        if suffix_len > str_len
+            return false
+        return string.compare(st + str_len - suffix_len, suffix) == 0
+    }
+
+    sub findstr(str haystack, str needle) -> ubyte {
+        ; searches for needle in haystack.
+        ; returns index in haystack where it first occurs, and Carry set,
+        ; or if needle doesn't occur in haystack it returns Carry clear and 255 (an invalid index.)
+        cx16.r2L = string.length(haystack)
+        cx16.r3L = string.length(needle)
+        if cx16.r3L <= cx16.r2L {
+            cx16.r2L = cx16.r2L-cx16.r3L+1
+            cx16.r3 = haystack
+            repeat cx16.r2L {
+                if string.startswith(cx16.r3, needle) {
+                    sys.set_carry()
+                    return cx16.r3-haystack as ubyte
+                }
+                cx16.r3++
+            }
+        }
+        sys.clear_carry()
+        return 255
+    }
 }

compiler/res/prog8lib/shared_textio_functions.p8

@@ -1,46 +0,0 @@
-txt {
-    ; the textio functions shared across compiler targets
-    %option merge, no_symbol_prefixing, ignore_unused
-
-    asmsub petscii2scr(ubyte petscii_char @A) -> ubyte @A {
-        ; -- convert petscii character to screencode
-        %asm {{
-            sta  P8ZP_SCRATCH_REG
-            lsr  a
-            lsr  a
-            lsr  a
-            lsr  a
-            lsr  a
-            tax
-            lda  _offsets,x
-            eor  P8ZP_SCRATCH_REG
-            rts
-_offsets    .byte  128, 0, 64, 32, 64, 192, 128, 128
-        }}
-    }
-
-    asmsub petscii2scr_str(str petscii_string @AY) {
-        ; -- convert petscii string to screencodes string
-        %asm {{
-            sta  P8ZP_SCRATCH_W1
-            sty  P8ZP_SCRATCH_W1+1
-            ldy  #0
--           lda  (P8ZP_SCRATCH_W1),y
-            beq  +
-            jsr  petscii2scr
-            sta  (P8ZP_SCRATCH_W1),y
-            iny
-            bne  -
-+           rts
-        }}
-}
-
-
-    sub print_bool(bool value) {
-        if value
-            txt.print("true")
-        else
-            txt.print("false")
-    }
-
-}

compiler/res/prog8lib/string.p8

@@ -129,7 +129,7 @@ _startloop	dey
 
     asmsub find(uword string @AY, ubyte character @X) -> ubyte @A, bool @Pc {
         ; Locates the first position of the given character in the string,
-        ; returns Carry set if found + index in A, or A=0 + Carry clear if not found.
+        ; returns Carry set if found + index in A, or Carry clear if not found (and A will be 255, an invalid index).
         %asm {{
 		; need to copy the the cx16 virtual registers to zeropage to make this run on C64...
 		sta  P8ZP_SCRATCH_W1
@@ -142,7 +142,7 @@ _startloop	dey
 		beq  _found
 		iny
 		bne  -
-_notfound	lda  #0
+_notfound	lda  #255
         clc
 		rts
 _found	tya
@@ -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
@@ -277,26 +308,6 @@ _done       rts
         }}
     }
 
-    sub startswith(str st, str prefix) -> bool {
-        ubyte prefix_len = length(prefix)
-        ubyte str_len = length(st)
-        if prefix_len > str_len
-            return false
-        cx16.r9L = st[prefix_len]
-        st[prefix_len] = 0
-        cx16.r9H = compare(st, prefix) as ubyte
-        st[prefix_len] = cx16.r9L
-        return cx16.r9H==0
-    }
-
-    sub endswith(str st, str suffix) -> bool {
-        ubyte suffix_len = length(suffix)
-        ubyte str_len = length(st)
-        if suffix_len > str_len
-            return false
-        return compare(st + str_len - suffix_len, suffix) == 0
-    }
-
     asmsub pattern_match(str string @AY, str pattern @R0) clobbers(Y) -> bool @A {
 		%asm {{
 ; pattern matching of a string.
@@ -366,7 +377,6 @@ fail    clc             ; yes, no match found, return with c=0
 		}}
 	}
 
-
     asmsub hash(str string @R0) -> ubyte @A {
         ; experimental 8 bit hashing function.
         ; hash(-1)=179;  clear carry;  hash(i) = ROL hash(i-1)  XOR  string[i]

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
     }
@@ -145,13 +147,19 @@ diskio {
         return "unknown"
     }
 
+    sub status_code() -> ubyte {
+        ; -- return status code instead of whole CBM-DOS status string. (in this case always 255, which means 'unable to return sensible value')
+        return 255
+    }
+
+
     sub save(uword filenameptr, uword start_address, uword savesize) -> bool {
         %ir {{
             load.b r65532,0
             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
         }}
     }
@@ -163,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
         }}
     }
@@ -178,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
         }}
     }
@@ -190,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
         }}
     }
@@ -199,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)
         }}
     }
 
@@ -208,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/emudbg.p8

@@ -1,5 +1,5 @@
 ; Emulator debug interface. (reflecting the Commander X16 emudbg library module)
-; Docs: https://github.com/X16Community/x16-emulator#emulator-io-registers
+; Docs: https://github.com/X16Community/x16-emulator/tree/d52f118ce893fa24c4ca021a0b8de46cb80e5ccf#emulator-io-registers
 
 %import textio