fix chained assignment and multi-vardecl RHS evaluation

add check for memory() args to be const

.idea/kotlinc.xml

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

.idea/libraries/KotlinJavaRuntime.xml

@@ -1,19 +1,26 @@
 <component name="libraryTable">
-  <library name="KotlinJavaRuntime">
-    <CLASSES>
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib.jar!/" />
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect.jar!/" />
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test.jar!/" />
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk7.jar!/" />
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk8.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES>
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-sources.jar!/" />
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect-sources.jar!/" />
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test-sources.jar!/" />
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk7-sources.jar!/" />
-      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-jdk8-sources.jar!/" />
-    </SOURCES>
-  </library>
+    <library name="KotlinJavaRuntime" type="repository">
+        <properties maven-id="org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.0" />
+        <CLASSES>
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.0/kotlin-stdlib-jdk8-1.9.0.jar!/" />
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.0/kotlin-stdlib-1.9.0.jar!/" />
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.9.0/kotlin-stdlib-common-1.9.0.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.0/kotlin-stdlib-jdk7-1.9.0.jar!/" />
+        </CLASSES>
+        <JAVADOC>
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.0/kotlin-stdlib-jdk8-1.9.0-javadoc.jar!/" />
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.0/kotlin-stdlib-1.9.0-javadoc.jar!/" />
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.9.0/kotlin-stdlib-common-1.9.0-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.0/kotlin-stdlib-jdk7-1.9.0-javadoc.jar!/" />
+        </JAVADOC>
+        <SOURCES>
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.0/kotlin-stdlib-jdk8-1.9.0-sources.jar!/" />
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.0/kotlin-stdlib-1.9.0-sources.jar!/" />
+            <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.9.0/kotlin-stdlib-common-1.9.0-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.0/kotlin-stdlib-jdk7-1.9.0-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.12.0">
+    <properties maven-id="org.antlr:antlr4:4.13.1">
       <exclude>
         <dependency maven-id="com.ibm.icu:icu4j" />
       </exclude>
     </properties>
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.12.0/antlr4-4.12.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.12.0/antlr4-runtime-4.12.0.jar!/" />
+      <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/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,19 +1,19 @@
 <component name="libraryTable">
   <library name="io.kotest.assertions.core.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.6.2" />
+    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.8.0" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.6.2/kotest-assertions-core-jvm-5.6.2.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/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.6.2/kotest-assertions-shared-jvm-5.6.2.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/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-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/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.6.2/kotest-common-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.6.2/kotest-assertions-api-jvm-5.6.2.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!/" />
     </CLASSES>

.idea/libraries/io_kotest_runner_junit5_jvm.xml

@@ -1,29 +1,29 @@
 <component name="libraryTable">
   <library name="io.kotest.runner.junit5.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.6.2" />
+    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.8.0" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.6.2/kotest-runner-junit5-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.6.2/kotest-framework-api-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.6.2/kotest-assertions-shared-jvm-5.6.2.jar!/" />
+      <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/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.6.2/kotest-common-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.6.2/kotest-framework-engine-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.157/classgraph-4.8.157.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$/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.2.0/opentest4j-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$/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.6.2/kotest-framework-discovery-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.6.2/kotest-assertions-core-jvm-5.6.2.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.6.2/kotest-assertions-api-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.6.2/kotest-extensions-jvm-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.6.2/kotest-framework-concurrency-jvm-5.6.2.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$/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!/" />

.idea/libraries/jetbrains_kotlinx_cli_jvm.xml

@@ -1,8 +1,8 @@
 <component name="libraryTable">
   <library name="jetbrains.kotlinx.cli.jvm" type="repository">
-    <properties include-transitive-deps="false" maven-id="org.jetbrains.kotlinx:kotlinx-cli-jvm:0.3.5" />
+    <properties include-transitive-deps="false" maven-id="org.jetbrains.kotlinx:kotlinx-cli-jvm:0.3.6" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-cli-jvm/0.3.5/kotlinx-cli-jvm-0.3.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-cli-jvm/0.3.6/kotlinx-cli-jvm-0.3.6.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/slf4j_simple.xml

@@ -1,9 +1,9 @@
 <component name="libraryTable">
   <library name="slf4j.simple" type="repository">
-    <properties maven-id="org.slf4j:slf4j-simple:2.0.7" />
+    <properties maven-id="org.slf4j:slf4j-simple:2.0.9" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-simple/2.0.7/slf4j-simple-2.0.7.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-api/2.0.7/slf4j-api-2.0.7.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-simple/2.0.9/slf4j-simple-2.0.9.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-api/2.0.9/slf4j-api-2.0.9.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/misc.xml

@@ -16,6 +16,9 @@
       </list>
     </option>
   </component>
+  <component name="Black">
+    <option name="sdkName" value="Python 3.11" />
+  </component>
   <component name="FrameworkDetectionExcludesConfiguration">
     <type id="Python" />
   </component>

codeCore/build.gradle

@@ -32,10 +32,10 @@ dependencies {
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
 }

codeCore/src/prog8/code/SymbolTable.kt

@@ -196,13 +196,10 @@ class StStaticVariable(name: String,
         }
         if(onetimeInitializationNumericValue!=null) {
             require(dt in NumericDatatypes)
-            require(onetimeInitializationNumericValue!=0.0) { "zero as init value should just remain uninitialized"}
         }
         if(onetimeInitializationArrayValue!=null) {
             require(dt in ArrayDatatypes)
-            if(onetimeInitializationArrayValue.all { it.number!=null} ) {
-                require(onetimeInitializationArrayValue.any { it.number != 0.0 }) { "array of all zerors as init value should just remain uninitialized" }
-            }
+            require(length==onetimeInitializationArrayValue.size)
         }
         if(onetimeInitializationStringValue!=null) {
             require(dt == DataType.STR)

codeCore/src/prog8/code/SymbolTableMaker.kt

@@ -74,10 +74,9 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
                             numElements = value.value.length + 1   // include the terminating 0-byte
                         }
                         is PtArray -> {
-                            val array = makeInitialArray(value)
-                            initialArray = if(array.all { it.number==0.0 }) null else array            // all 0 as init value -> just uninitialized
+                            initialArray = makeInitialArray(value)
                             initialString = null
-                            numElements = array.size
+                            numElements = initialArray.size
                             require(node.arraySize?.toInt()==numElements)
                         }
                         else -> {
@@ -126,7 +125,11 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
     private fun makeInitialArray(value: PtArray): List<StArrayElement> {
         return value.children.map {
             when(it) {
-                is PtAddressOf -> StArrayElement(null, it.identifier.name)
+                is PtAddressOf -> {
+                    if(it.isFromArrayElement)
+                        TODO("address-of array element $it in initial array value")
+                    StArrayElement(null, it.identifier.name)
+                }
                 is PtIdentifier -> StArrayElement(null, it.name)
                 is PtNumber -> StArrayElement(it.number, null)
                 else -> throw AssemblyError("invalid array element $it")

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

@@ -75,6 +75,7 @@ class PtBlock(name: String,
               val library: Boolean,
               val forceOutput: Boolean,
               val noSymbolPrefixing: Boolean,
+              val veraFxMuls: Boolean,
               val alignment: BlockAlignment,
               val source: SourceCode,       // taken from the module the block is defined in.
               position: Position

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

@@ -24,7 +24,17 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
 
     infix fun isSameAs(other: PtExpression): Boolean {
         return when(this) {
-            is PtAddressOf -> other is PtAddressOf && other.type==type && other.identifier isSameAs identifier
+            is PtAddressOf -> {
+                if(other !is PtAddressOf)
+                    return false
+                if (other.type!==type || !(other.identifier isSameAs identifier))
+                    return false
+                if(other.children.size!=children.size)
+                    return false
+                if(children.size==1)
+                    return true
+                return arrayIndexExpr!! isSameAs other.arrayIndexExpr!!
+            }
             is PtArrayIndexer -> other is PtArrayIndexer && other.type==type && other.variable isSameAs variable && other.index isSameAs index && other.splitWords==splitWords
             is PtBinaryExpression -> other is PtBinaryExpression && other.left isSameAs left && other.right isSameAs right
             is PtContainmentCheck -> other is PtContainmentCheck && other.type==type && other.element isSameAs element && other.iterable isSameAs iterable
@@ -105,7 +115,12 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
 
 class PtAddressOf(position: Position) : PtExpression(DataType.UWORD, position) {
     val identifier: PtIdentifier
-        get() = children.single() as PtIdentifier
+        get() = children[0] as PtIdentifier
+    val arrayIndexExpr: PtExpression?
+        get() = if(children.size==2) children[1] as PtExpression else null
+
+    val isFromArrayElement: Boolean
+        get() = children.size==2
 }
 
 

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

@@ -70,6 +70,8 @@ class FSignature(val pure: Boolean,      // does it have side effects?
 
 val BuiltinFunctions: Map<String, FSignature> = mapOf(
     // this set of function have no return value and operate in-place:
+    "setlsb"    to FSignature(false, listOf(FParam("variable", arrayOf(DataType.WORD, DataType.UWORD)), FParam("value", arrayOf(DataType.BYTE, DataType.UBYTE))), null),
+    "setmsb"    to FSignature(false, listOf(FParam("variable", arrayOf(DataType.WORD, DataType.UWORD)), FParam("value", arrayOf(DataType.BYTE, DataType.UBYTE))), null),
     "rol"       to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
     "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),
@@ -118,9 +120,11 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "max__uword" to FSignature(true, listOf(FParam("val1", arrayOf(DataType.UWORD)), FParam("val2", arrayOf(DataType.UWORD))), DataType.UWORD),
     "peek"      to FSignature(true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UBYTE),
     "peekw"     to FSignature(true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UWORD),
+    "peekf"     to FSignature(true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.FLOAT),
     "poke"      to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), null),
-    "pokemon"   to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), null),
     "pokew"     to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UWORD))), null),
+    "pokef"     to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.FLOAT))), null),
+    "pokemon"   to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), DataType.UBYTE),
     "pop"       to FSignature(false, listOf(FParam("target", ByteDatatypes)), null),
     "popw"      to FSignature(false, listOf(FParam("target", WordDatatypes)), null),
     "push"      to FSignature(false, listOf(FParam("value", ByteDatatypes)), null),
@@ -131,4 +135,4 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "callfar"   to FSignature(false, listOf(FParam("bank", arrayOf(DataType.UBYTE)), FParam("address", arrayOf(DataType.UWORD)), FParam("arg", arrayOf(DataType.UWORD))), DataType.UWORD),
 )
 
-val InplaceModifyingBuiltinFunctions = setOf("rol", "ror", "rol2", "ror2", "sort", "reverse")
+val InplaceModifyingBuiltinFunctions = setOf("setlsb", "setmsb", "rol", "ror", "rol2", "ror2", "sort", "reverse")

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

@@ -8,6 +8,7 @@ class CompilationOptions(val output: OutputType,
                          val launcher: CbmPrgLauncherType,
                          val zeropage: ZeropageType,
                          val zpReserved: List<UIntRange>,
+                         val zpAllowed: List<UIntRange>,
                          val floats: Boolean,
                          val noSysInit: Boolean,
                          val compTarget: ICompilationTarget,
@@ -21,10 +22,15 @@ class CompilationOptions(val output: OutputType,
                          var experimentalCodegen: Boolean = false,
                          var varsHighBank: Int? = null,
                          var splitWordArrays: Boolean = false,
+                         var breakpointCpuInstruction: Boolean = false,
                          var outputDir: Path = Path(""),
                          var symbolDefs: Map<String, String> = emptyMap()
 ) {
     init {
         compTarget.machine.initializeMemoryAreas(this)
     }
+
+    companion object {
+        val AllZeropageAllowed: List<UIntRange> = listOf(0u..255u)
+    }
 }

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

@@ -1,12 +1,13 @@
 package prog8.code.core
 
 enum class DataType {
-    UBYTE,              // pass by value
-    BYTE,               // pass by value
-    UWORD,              // pass by value
-    WORD,               // pass by value
-    FLOAT,              // pass by value
-    BOOL,               // pass by value
+    UBYTE,              // pass by value            8 bits unsigned
+    BYTE,               // pass by value            8 bits signed
+    UWORD,              // pass by value            16 bits unsigned
+    WORD,               // pass by value            16 bits signed
+    LONG,               // pass by value            32 bits signed
+    FLOAT,              // pass by value            machine dependent
+    BOOL,               // pass by value            bit 0 of a 8 bit byte
     STR,                // pass by reference
     ARRAY_UB,           // pass by reference
     ARRAY_B,            // pass by reference
@@ -23,11 +24,12 @@ enum class DataType {
      */
     infix fun isAssignableTo(targetType: DataType) =
         when(this) {
-            BOOL -> targetType.oneOf(BOOL, BYTE, UBYTE, WORD, UWORD, FLOAT)
-            UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT, BOOL)
-            BYTE -> targetType.oneOf(BYTE, WORD, FLOAT)
-            UWORD -> targetType.oneOf(UWORD, FLOAT)
-            WORD -> targetType.oneOf(WORD, FLOAT)
+            BOOL -> targetType.oneOf(BOOL, BYTE, UBYTE, WORD, UWORD, LONG, FLOAT)
+            UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, LONG, FLOAT, BOOL)
+            BYTE -> targetType.oneOf(BYTE, WORD, LONG, FLOAT)
+            UWORD -> targetType.oneOf(UWORD, LONG, FLOAT)
+            WORD -> targetType.oneOf(WORD, LONG, FLOAT)
+            LONG -> targetType.oneOf(LONG, FLOAT)
             FLOAT -> targetType.oneOf(FLOAT)
             STR -> targetType.oneOf(STR, UWORD)
             in ArrayDatatypes -> targetType == this
@@ -41,7 +43,8 @@ enum class DataType {
             this == other -> false
             this in ByteDatatypes -> false
             this in WordDatatypes -> other in ByteDatatypes
-            this== STR && other== UWORD || this== UWORD && other== STR -> false
+            this == LONG -> other in ByteDatatypes+WordDatatypes
+            this == STR && other == UWORD || this == UWORD && other == STR -> false
             else -> true
         }
 
@@ -76,6 +79,13 @@ enum class RegisterOrPair {
 
     companion object {
         val names by lazy { values().map { it.toString()} }
+        fun fromCpuRegister(cpu: CpuRegister): RegisterOrPair {
+            return when(cpu) {
+                CpuRegister.A -> A
+                CpuRegister.X -> X
+                CpuRegister.Y -> Y
+            }
+        }
     }
 
     fun asCpuRegister(): CpuRegister = when(this) {
@@ -116,11 +126,11 @@ enum class BranchCondition {
 
 val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.BOOL)
 val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD)
-val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.BOOL)
-val IntegerDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
-val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT, DataType.BOOL)
-val NumericDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
-val SignedDatatypes =  arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT)
+val IntegerDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.LONG)
+val IntegerDatatypes = IntegerDatatypesNoBool + DataType.BOOL
+val NumericDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.LONG, DataType.FLOAT)
+val NumericDatatypes = NumericDatatypesNoBool + DataType.BOOL
+val SignedDatatypes =  arrayOf(DataType.BYTE, DataType.WORD, DataType.LONG, DataType.FLOAT)
 val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_UW_SPLIT, DataType.ARRAY_W, DataType.ARRAY_W_SPLIT, DataType.ARRAY_F, DataType.ARRAY_BOOL)
 val StringlyDatatypes = arrayOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD)
 val SplitWordArrayTypes = arrayOf(DataType.ARRAY_UW_SPLIT, DataType.ARRAY_W_SPLIT)
@@ -152,6 +162,7 @@ val ElementToArrayTypes = mapOf(
     DataType.FLOAT to DataType.ARRAY_F,
     DataType.BOOL to DataType.ARRAY_BOOL
 )
+
 val Cx16VirtualRegisters = arrayOf(
     RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3,
     RegisterOrPair.R4, RegisterOrPair.R5, RegisterOrPair.R6, RegisterOrPair.R7,
@@ -159,6 +170,10 @@ val Cx16VirtualRegisters = arrayOf(
     RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15
 )
 
+val CpuRegisters = setOf(
+    RegisterOrPair.A, RegisterOrPair.X, RegisterOrPair.Y,
+    RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY
+)
 
 
 enum class OutputType {

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

@@ -3,8 +3,6 @@ package prog8.code.core
 interface ICompilationTarget: IStringEncoding, IMemSizer {
     val name: String
     val machine: IMachineDefinition
-    val supportedEncodings: Set<Encoding>
-    val defaultEncoding: Encoding
 
     override fun encodeString(str: String, encoding: Encoding): List<UByte>
     override fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String

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

@@ -9,6 +9,8 @@ enum class Encoding(val prefix: String) {
 }
 
 interface IStringEncoding {
+    val defaultEncoding: Encoding
+
     fun encodeString(str: String, encoding: Encoding): List<UByte>
     fun decodeString(bytes: Iterable<UByte>, encoding: Encoding): String
 }

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

@@ -42,6 +42,13 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
         }
     }
 
+    fun retainAllowed() {
+        synchronized(this) {
+            for(allowed in options.zpAllowed)
+                free.retainAll { it in allowed }
+        }
+    }
+
     fun availableBytes() = if(options.zeropage== ZeropageType.DONTUSE) 0 else free.size
     fun hasByteAvailable() = if(options.zeropage== ZeropageType.DONTUSE) false else free.isNotEmpty()
     fun hasWordAvailable(): Boolean {

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

@@ -3,6 +3,7 @@ package prog8.code.core
 import java.io.File
 import java.io.IOException
 import java.nio.file.Path
+import java.text.Normalizer
 import kotlin.io.path.Path
 import kotlin.io.path.readText
 
@@ -94,7 +95,7 @@ sealed class SourceCode {
             val normalized = path.normalize()
             origin = relative(normalized).toString()
             try {
-                text = normalized.readText()
+                text = Normalizer.normalize(normalized.readText(), Normalizer.Form.NFC)
                 name = normalized.toFile().nameWithoutExtension
             } catch (nfx: java.nio.file.NoSuchFileException) {
                 throw NoSuchFileException(normalized.toFile()).also { it.initCause(nfx) }
@@ -126,7 +127,7 @@ sealed class SourceCode {
                 )
             }
             val stream = object {}.javaClass.getResourceAsStream(normalized)
-            text = stream!!.reader().use { it.readText() }
+            text = stream!!.reader().use { Normalizer.normalize(it.readText(), Normalizer.Form.NFC) }
             name = Path(pathString).toFile().nameWithoutExtension
         }
     }

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

@@ -7,7 +7,6 @@ import prog8.code.target.atari.AtariMachineDefinition
 class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
     override val name = NAME
     override val machine = AtariMachineDefinition()
-    override val supportedEncodings = setOf(Encoding.ATASCII)
     override val defaultEncoding = Encoding.ATASCII
 
     companion object {

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

@@ -11,7 +11,6 @@ import prog8.code.target.cbm.CbmMemorySizer
 class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
     override val name = NAME
     override val machine = C128MachineDefinition()
-    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES)
     override val defaultEncoding = Encoding.PETSCII
 
     companion object {

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

@@ -11,7 +11,6 @@ import prog8.code.target.cbm.CbmMemorySizer
 class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
     override val name = NAME
     override val machine = C64MachineDefinition()
-    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES)
     override val defaultEncoding = Encoding.PETSCII
 
     companion object {

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

@@ -11,7 +11,6 @@ import prog8.code.target.cx16.CX16MachineDefinition
 class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
     override val name = NAME
     override val machine = CX16MachineDefinition()
-    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES, Encoding.ISO)
     override val defaultEncoding = Encoding.PETSCII
 
     companion object {

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

@@ -10,6 +10,8 @@ import prog8.code.target.cbm.PetsciiEncoding
 
 
 object Encoder: IStringEncoding {
+    override val defaultEncoding: Encoding = Encoding.ISO
+
     override fun encodeString(str: String, encoding: Encoding): List<UByte> {
         val coded = when(encoding) {
             Encoding.PETSCII -> PetsciiEncoding.encodePetscii(str, true)

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

@@ -11,7 +11,6 @@ import prog8.code.target.pet.PETMachineDefinition
 class PETTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
     override val name = NAME
     override val machine = PETMachineDefinition()
-    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES)
     override val defaultEncoding = Encoding.PETSCII
 
     companion object {

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

@@ -6,7 +6,6 @@ import prog8.code.target.virtual.VirtualMachineDefinition
 class VMTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
     override val name = NAME
     override val machine = VirtualMachineDefinition()
-    override val supportedEncodings = setOf(Encoding.ISO)
     override val defaultEncoding = Encoding.ISO
 
     companion object {

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

@@ -48,6 +48,7 @@ class AtariZeropage(options: CompilationOptions) : Zeropage(options) {
         free.addAll(distinctFree)
 
         removeReservedFromFreePool()
+        retainAllowed()
     }
 
     override fun allocateCx16VirtualRegisters() {

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

@@ -69,6 +69,7 @@ class C128Zeropage(options: CompilationOptions) : Zeropage(options) {
         free.addAll(distinctFree)
 
         removeReservedFromFreePool()
+        retainAllowed()
     }
 
     override fun allocateCx16VirtualRegisters() {

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

@@ -53,11 +53,11 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
                 ).map{it.toUInt()})
             }
 
-            if(options.zeropage!= ZeropageType.DONTUSE) {
+            if(options.zeropage != ZeropageType.DONTUSE) {
                 // add the free Zp addresses
                 // these are valid for the C-64 but allow BASIC to keep running fully *as long as you don't use tape I/O*
                 free.addAll(listOf(0x02, 0x03, 0x04, 0x05, 0x06, 0x0a, 0x0e,
-                        0x92, 0x96, 0x9b, 0x9c, 0x9e, 0x9f, 0xa5, 0xa6,
+                        0x92, 0x96, 0x9b, 0x9c, 0x9e, 0x9f, 0xa6,
                         0xb0, 0xb1, 0xbe, 0xbf, 0xf9).map{it.toUInt()})
             } else {
                 // don't use the zeropage at all
@@ -75,6 +75,8 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
             // in these cases there is enough space on the zero page to stick the cx16 virtual registers in there as well.
             allocateCx16VirtualRegisters()
         }
+
+        retainAllowed()
     }
 
     override fun allocateCx16VirtualRegisters() {

codeCore/src/prog8/code/target/cbm/PetsciiEncoding.kt

@@ -24,7 +24,7 @@ object PetsciiEncoding {
         '\ufffe',    //       0x0A -> UNDEFINED
         '\ufffe',    //       0x0B -> UNDEFINED
         '\ufffe',    //       0x0C -> UNDEFINED
-        '\r'    ,    //       0x0D -> CARRIAGE RETURN
+        '\n'    ,    //       0x0D -> LINE FEED (RETURN)
         '\u000e',    //       0x0E -> SHIFT OUT
         '\ufffe',    //       0x0F -> UNDEFINED
         '\ufffe',    //       0x10 -> UNDEFINED
@@ -152,7 +152,7 @@ object PetsciiEncoding {
         '\uf113',    //      0x8A -> FUNCTION KEY 4 (CUS)
         '\uf115',    //      0x8B -> FUNCTION KEY 6 (CUS)
         '\uf117',    //      0x8C -> FUNCTION KEY 8 (CUS)
-        '\n'    ,    //       0x8D -> LINE FEED
+        '\r'    ,    //       0x8D -> CARRIAGE RETURN (SHIFT-RETURN)
         '\u000f',    //      0x8E -> SHIFT IN
         '\ufffe',    //       0x8F -> UNDEFINED
         '\uf105',    //       0x90 -> BLACK COLOR SWITCH (CUS)
@@ -283,7 +283,7 @@ object PetsciiEncoding {
         '\ufffe',    //       0x0A -> UNDEFINED
         '\ufffe',    //       0x0B -> UNDEFINED
         '\ufffe',    //       0x0C -> UNDEFINED
-        '\r'    ,    //       0x0D -> CARRIAGE RETURN
+        '\n'    ,    //       0x0D -> LINE FEED (RETURN)
         '\u000e',    //       0x0E -> SHIFT OUT
         '\ufffe',    //       0x0F -> UNDEFINED
         '\ufffe',    //       0x10 -> UNDEFINED
@@ -411,7 +411,7 @@ object PetsciiEncoding {
         '\uf113',    //       0x8A -> FUNCTION KEY 4 (CUS)
         '\uf115',    //       0x8B -> FUNCTION KEY 6 (CUS)
         '\uf117',    //       0x8C -> FUNCTION KEY 8 (CUS)
-        '\n'    ,    //       0x8D -> LINE FEED
+        '\r'    ,    //       0x8D -> CARRIAGE RETURN (SHIFT-RETURN)
         '\u000f',    //       0x8E -> SHIFT IN
         '\ufffe',    //       0x8F -> UNDEFINED
         '\uf105',    //       0x90 -> BLACK COLOR SWITCH (CUS)
@@ -1061,6 +1061,7 @@ object PetsciiEncoding {
             '}' -> '├'
             '|' -> '│'
             '\\' -> '╲'
+            '\r' -> '\n'        // to make \r (carriage returrn) equivalent to \n (line feed): RETURN ($0d)
             else -> chr
         }
 
@@ -1076,7 +1077,10 @@ object PetsciiEncoding {
                 }
                 else -> {
                     val case = if (lowercase) "lower" else "upper"
-                    throw CharConversionException("no ${case}Petscii character for '${chr}' (${chr.code})")
+                    if(chr.isISOControl())
+                        throw CharConversionException("no ${case}Petscii character for char #${chr.code}")
+                    else
+                        throw CharConversionException("no ${case}Petscii character for char #${chr.code} '${chr}'")
                 }
             }
         }
@@ -1119,7 +1123,10 @@ object PetsciiEncoding {
                 }
                 else -> {
                     val case = if (lowercase) "lower" else "upper"
-                    throw CharConversionException("no ${case}Screencode character for '${chr}' (${chr.code})")
+                    if(chr.isISOControl())
+                        throw CharConversionException("no ${case}Screencode character for char #${chr.code}")
+                    else
+                        throw CharConversionException("no ${case}Screencode character for char #${chr.code} '${chr}'")
                 }
             }
         }

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

@@ -47,8 +47,8 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
             free.addAll(distinctFree)
 
             removeReservedFromFreePool()
-
             allocateCx16VirtualRegisters()
+            retainAllowed()
         }
     }
 

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

@@ -50,6 +50,7 @@ class PETZeropage(options: CompilationOptions) : Zeropage(options) {
         free.addAll(distinctFree)
 
         removeReservedFromFreePool()
+        retainAllowed()
     }
 
     override fun allocateCx16VirtualRegisters() {

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

@@ -12,7 +12,7 @@ class VirtualMachineDefinition: IMachineDefinition {
 
     override val FLOAT_MAX_POSITIVE = Float.MAX_VALUE.toDouble()
     override val FLOAT_MAX_NEGATIVE = -Float.MAX_VALUE.toDouble()
-    override val FLOAT_MEM_SIZE = 4             // 32-bits floating point
+    override val FLOAT_MEM_SIZE = 8             // 64-bits double
     override val PROGRAM_LOAD_ADDRESS = 0u      // not actually used
 
     override val BSSHIGHRAM_START = 0u          // not actually used
@@ -22,8 +22,8 @@ class VirtualMachineDefinition: IMachineDefinition {
 
     override fun getFloatAsmBytes(num: Number): String {
         // little endian binary representation
-        val bits = num.toFloat().toBits().toUInt()
-        val hexStr = bits.toString(16).padStart(8, '0')
+        val bits = num.toDouble().toBits().toULong()
+        val hexStr = bits.toString(16).padStart(16, '0')
         val parts = hexStr.chunked(2).map { "\$" + it }
         return parts.joinToString(", ")
     }

codeGenCpu6502/build.gradle

@@ -30,16 +30,16 @@ dependencies {
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
     implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.6.2'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
 }
 
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
     test {

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

@@ -503,24 +503,18 @@ class AsmGen6502Internal (
             return
         }
 
-        val indexVar = expr.index as? PtIdentifier
-            ?: throw AssemblyError("array indexer should have been replaced with a temp var @ ${expr.index.position}")
-
-        val indexName = asmVariableName(indexVar)
-
         if(expr.splitWords) {
-            when (register) {
-                CpuRegister.A -> out("  lda  $indexName")
-                CpuRegister.X -> out("  ldx  $indexName")
-                CpuRegister.Y -> out("  ldy  $indexName")
-            }
+            assignExpressionToRegister(expr.index, RegisterOrPair.fromCpuRegister(register), false)
             return
         }
 
         when (elementDt) {
-            in ByteDatatypes -> out("  ld$reg  $indexName")
+            in ByteDatatypes -> {
+                assignExpressionToRegister(expr.index, RegisterOrPair.fromCpuRegister(register), false)
+            }
             in WordDatatypes -> {
-                out("  lda  $indexName |  asl  a")
+                assignExpressionToRegister(expr.index, RegisterOrPair.A, false)
+                out("  asl  a")
                 when (register) {
                     CpuRegister.A -> {}
                     CpuRegister.X -> out(" tax")
@@ -529,12 +523,13 @@ class AsmGen6502Internal (
             }
             DataType.FLOAT -> {
                 require(options.compTarget.memorySize(DataType.FLOAT) == 5) {"invalid float size ${expr.position}"}
+                assignExpressionToRegister(expr.index, RegisterOrPair.A, false)
                 out("""
-                    lda  $indexName
+                    sta  P8ZP_SCRATCH_REG
                     asl  a
                     asl  a
                     clc
-                    adc  $indexName"""
+                    adc  P8ZP_SCRATCH_REG"""
                 )
                 when (register) {
                     CpuRegister.A -> {}
@@ -568,7 +563,7 @@ class AsmGen6502Internal (
         when(reg) {
             RegisterOrPair.A,
             RegisterOrPair.X,
-            RegisterOrPair.Y -> assignmentAsmGen.assignRegisterByte(target, reg.asCpuRegister(), target.datatype in SignedDatatypes)
+            RegisterOrPair.Y -> assignmentAsmGen.assignRegisterByte(target, reg.asCpuRegister(), target.datatype in SignedDatatypes, true)
             RegisterOrPair.AX,
             RegisterOrPair.AY,
             RegisterOrPair.XY,
@@ -582,6 +577,34 @@ class AsmGen6502Internal (
     internal fun assignExpressionTo(value: PtExpression, target: AsmAssignTarget) {
         when (target.datatype) {
             in ByteDatatypes -> {
+                if (value.asConstInteger()==0) {
+                    when(target.kind) {
+                        TargetStorageKind.VARIABLE -> {
+                            if (isTargetCpu(CpuType.CPU6502))
+                                out("lda  #0 |  sta  ${target.asmVarname}")
+                            else
+                                out("stz  ${target.asmVarname}")
+                        }
+                        TargetStorageKind.MEMORY -> {
+                            val address = target.memory!!.address.asConstInteger()
+                            if(address!=null) {
+                                if (isTargetCpu(CpuType.CPU6502))
+                                    out("lda  #0 |  sta  ${address.toHex()}")
+                                else
+                                    out("  stz  ${address.toHex()}")
+                                return
+                            }
+                        }
+                        TargetStorageKind.REGISTER -> {
+                            val zero = PtNumber(DataType.UBYTE, 0.0, value.position)
+                            zero.parent = value
+                            assignExpressionToRegister(zero, target.register!!, false)
+                            return
+                        }
+                        else -> { }
+                    }
+                }
+
                 assignExpressionToRegister(value, RegisterOrPair.A)
                 assignRegister(RegisterOrPair.A, target)
             }
@@ -1026,6 +1049,15 @@ $repeatLabel""")
         val label = "_prog8_breakpoint_${breakpointLabels.size+1}"
         breakpointLabels.add(label)
         out(label)
+        if(options.breakpointCpuInstruction) {
+            val instruction =
+                when(options.compTarget.machine.cpu) {
+                    CpuType.CPU6502 -> "brk"
+                    CpuType.CPU65c02 -> "stp"
+                    else -> throw AssemblyError("invalid cpu type")
+                }
+            out("  $instruction")
+        }
     }
 
     internal fun signExtendAYlsb(valueDt: DataType) {
@@ -2417,8 +2449,7 @@ $repeatLabel""")
                     cmp  #<$number
                     bne  $jumpIfFalseLabel
                     cpy  #>$number
-                    bne  $jumpIfFalseLabel
-                    """)
+                    bne  $jumpIfFalseLabel""")
             }
             is PtIdentifier -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
@@ -2426,18 +2457,21 @@ $repeatLabel""")
                     cmp  ${asmVariableName(right)}
                     bne  $jumpIfFalseLabel
                     cpy  ${asmVariableName(right)}+1
-                    bne  $jumpIfFalseLabel
-                    """)
+                    bne  $jumpIfFalseLabel""")
             }
             is PtAddressOf -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
                 val name = asmSymbolName(right.identifier)
-                out("""
-                    cmp  #<$name
-                    bne  $jumpIfFalseLabel
-                    cpy  #>$name
-                    bne  $jumpIfFalseLabel
-                    """)
+                if(right.isFromArrayElement) {
+                    TODO("address-of array element $name at ${right.position}")
+                    // assignmentAsmGen.assignAddressOf(target, name, right.arrayIndexExpr)
+                } else {
+                    out("""
+                        cmp  #<$name
+                        bne  $jumpIfFalseLabel
+                        cpy  #>$name
+                        bne  $jumpIfFalseLabel""")
+                }
             }
             else -> {
                 if(left.isSimple()) {
@@ -2518,12 +2552,16 @@ $repeatLabel""")
             is PtAddressOf -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
                 val name = asmSymbolName(right.identifier)
-                out("""
-                    cmp  #<$name
-                    bne  +
-                    cpy  #>$name
-                    beq  $jumpIfFalseLabel
-+""")
+                if(right.isFromArrayElement) {
+                    TODO("address-of array element $name at ${right.position}")
+                } else {
+                    out("""
+                        cmp  #<$name
+                        bne  +
+                        cpy  #>$name
+                        beq  $jumpIfFalseLabel
+    +""")
+                }
             }
             else -> {
                 if(left.isSimple()) {
@@ -2849,8 +2887,12 @@ $repeatLabel""")
             is PtAddressOf -> {
                 assignExpressionToRegister(right, RegisterOrPair.AY)
                 val name = asmSymbolName(left.identifier)
-                code("#>$name", "#<$name")
-                return true
+                if(left.isFromArrayElement) {
+                    TODO("address-of array element $name at ${left.position}")
+                } else {
+                    code("#>$name", "#<$name")
+                    return true
+                }
             }
             is PtIdentifier -> {
                 assignExpressionToRegister(right, RegisterOrPair.AY)
@@ -2898,8 +2940,12 @@ $repeatLabel""")
             is PtAddressOf -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
                 val name = asmSymbolName(right.identifier)
-                code("#>$name", "#<$name")
-                return true
+                if(right.isFromArrayElement) {
+                    TODO("address-of array element $name at ${right.position}")
+                } else {
+                    code("#>$name", "#<$name")
+                    return true
+                }
             }
             is PtIdentifier -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
@@ -3061,6 +3107,17 @@ $repeatLabel""")
         return "prog8_label_asm_${generatedLabelSequenceNumber}_$postfix"
     }
 
+    fun assignConstFloatToPointerAY(number: PtNumber) {
+        val floatConst = allocator.getFloatAsmConst(number.number)
+        out("""
+            pha
+            lda  #<$floatConst
+            sta  P8ZP_SCRATCH_W1
+            lda  #>$floatConst
+            sta  P8ZP_SCRATCH_W1+1
+            pla
+            jsr  floats.copy_float""")
+    }
 }
 
 /**

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

@@ -1,9 +1,8 @@
 package prog8.codegen.cpu6502
 
-import prog8.code.ast.*
+import prog8.code.ast.PtAsmSub
 import prog8.code.core.Cx16VirtualRegisters
 import prog8.code.core.RegisterOrPair
-import prog8.code.core.RegisterOrStatusflag
 
 
 fun asmsub6502ArgsEvalOrder(sub: PtAsmSub): List<Int> {
@@ -11,50 +10,19 @@ fun asmsub6502ArgsEvalOrder(sub: PtAsmSub): List<Int> {
     // order is:
     //  1) cx16 virtual word registers,
     //  2) paired CPU registers,
-    //  3) single CPU registers (X last), except A,
+    //  3) single CPU registers (order Y,X,A),
     //  4) CPU Carry status flag
-    //  5) the A register itself last   (so everything before it can use the accumulator without having to save its value)
     val args = sub.parameters.withIndex()
     val (cx16regs, args2) = args.partition { it.value.first.registerOrPair in Cx16VirtualRegisters }
     val pairedRegisters = arrayOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)
     val (pairedRegs , args3) = args2.partition { it.value.first.registerOrPair in pairedRegisters }
-    val (regsWithoutA, args4) = args3.partition { it.value.first.registerOrPair != RegisterOrPair.A }
-    val (regA, rest) = args4.partition { it.value.first.registerOrPair != null }
+    val (singleRegs, rest) = args3.partition { it.value.first.registerOrPair != null }
 
     cx16regs.forEach { order += it.index }
     pairedRegs.forEach { order += it.index }
-    regsWithoutA.forEach {
-        if(it.value.first.registerOrPair != RegisterOrPair.X)
-            order += it.index
-    }
-    regsWithoutA.firstOrNull { it.value.first.registerOrPair==RegisterOrPair.X } ?.let { order += it.index}
+    singleRegs.sortedBy { it.value.first.registerOrPair!!.asCpuRegister() }.asReversed().forEach { order += it.index }
+    require(rest.all { it.value.first.registerOrPair==null && it.value.first.statusflag!=null})
     rest.forEach { order += it.index }
-    regA.forEach { order += it.index }
     require(order.size==sub.parameters.size)
     return order
 }
-
-fun asmsub6502ArgsHaveRegisterClobberRisk(
-    args: List<PtExpression>,
-    params: List<Pair<RegisterOrStatusflag, PtSubroutineParameter>>
-): Boolean {
-    fun isClobberRisk(expr: PtExpression): Boolean {
-        when (expr) {
-            is PtArrayIndexer -> {
-                return params.any {
-                    it.first.registerOrPair in listOf(RegisterOrPair.Y, RegisterOrPair.AY, RegisterOrPair.XY)
-                }
-            }
-            is PtBuiltinFunctionCall -> {
-                if (expr.name == "lsb" || expr.name == "msb")
-                    return isClobberRisk(expr.args[0])
-                if (expr.name == "mkword")
-                    return isClobberRisk(expr.args[0]) && isClobberRisk(expr.args[1])
-                return !expr.isSimple()
-            }
-            else -> return !expr.isSimple()
-        }
-    }
-
-    return args.size>1 && args.any { isClobberRisk(it) }
-}

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

@@ -41,13 +41,26 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "rol2" -> funcRol2(fcall)
             "ror" -> funcRor(fcall)
             "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)
             "peek" -> throw AssemblyError("peek() should have been replaced by @()")
             "pokew" -> funcPokeW(fcall)
-            "pokemon" -> { /* meme function */ }
+            "pokef" -> funcPokeF(fcall)
+            "pokemon" -> {
+                val memread = PtMemoryByte(fcall.position)
+                memread.add(fcall.args[0])
+                memread.parent = fcall
+                asmgen.assignExpressionToRegister(memread, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                val memtarget = AsmAssignTarget(TargetStorageKind.MEMORY, asmgen, DataType.UBYTE, fcall.definingISub(), fcall.position, memory=memread)
+                asmgen.assignExpressionTo(fcall.args[1], memtarget)
+                asmgen.out("  pla")
+            }
             "poke" -> throw AssemblyError("poke() should have been replaced by @()")
             "push" -> asmgen.pushCpuStack(DataType.UBYTE, fcall.args[0])
             "pushw" -> asmgen.pushCpuStack(DataType.UWORD, fcall.args[0])
@@ -70,26 +83,32 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "rsave" -> funcRsave()
             "rrestore" -> funcRrestore()
             "cmp" -> funcCmp(fcall)
-            "callfar" -> funcCallFar(fcall)
-            "prog8_lib_stringcompare" -> funcStringCompare(fcall)
-            "prog8_lib_square_byte" -> funcSquare(fcall, DataType.UBYTE)
-            "prog8_lib_square_word" -> funcSquare(fcall, DataType.UWORD)
+            "callfar" -> funcCallFar(fcall, resultRegister)
+            "prog8_lib_stringcompare" -> funcStringCompare(fcall, resultRegister)
+            "prog8_lib_square_byte" -> funcSquare(fcall, DataType.UBYTE, resultRegister)
+            "prog8_lib_square_word" -> funcSquare(fcall, DataType.UWORD, resultRegister)
             else -> throw AssemblyError("missing asmgen for builtin func ${fcall.name}")
         }
 
         return BuiltinFunctions.getValue(fcall.name).returnType
     }
 
-    private fun funcSquare(fcall: PtBuiltinFunctionCall, resultType: DataType) {
+    private fun funcSquare(fcall: PtBuiltinFunctionCall, resultType: DataType, resultRegister: RegisterOrPair?) {
         // square of word value is faster with dedicated routine, square of byte just use the regular multiplication routine.
         when (resultType) {
             DataType.UBYTE -> {
                 asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A)
                 asmgen.out("  tay  |  jsr  math.multiply_bytes")
+                if(resultRegister!=null)  {
+                    assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister, false, fcall.position, null, asmgen), CpuRegister.A, false, false)
+                }
             }
             DataType.UWORD -> {
                 asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
                 asmgen.out("  jsr  math.square")
+                if(resultRegister!=null)  {
+                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister, false, fcall.position, null, asmgen), RegisterOrPair.AY)
+                }
             }
             else -> {
                 throw AssemblyError("optimized square only for integer types")
@@ -108,8 +127,8 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         val var3name = asmgen.asmVariableName(fcall.args[3] as PtIdentifier)
         val divisionTarget = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UBYTE, fcall.definingISub(), fcall.args[2].position, var2name)
         val remainderTarget = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UBYTE, fcall.definingISub(), fcall.args[3].position, var3name)
-        assignAsmGen.assignRegisterByte(remainderTarget, CpuRegister.A, false)
-        assignAsmGen.assignRegisterByte(divisionTarget, CpuRegister.Y, false)
+        assignAsmGen.assignRegisterByte(remainderTarget, CpuRegister.A, false, false)
+        assignAsmGen.assignRegisterByte(divisionTarget, CpuRegister.Y, false, false)
     }
 
     private fun funcDivmodW(fcall: PtBuiltinFunctionCall) {
@@ -129,9 +148,12 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             sty  $remainderVar+1""")
     }
 
-    private fun funcStringCompare(fcall: PtBuiltinFunctionCall) {
+    private fun funcStringCompare(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         asmgen.assignWordOperandsToAYAndVar(fcall.args[0], fcall.args[1], "P8ZP_SCRATCH_W2")
         asmgen.out("  jsr  prog8_lib.strcmp_mem")
+        if(resultRegister!=null)  {
+            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister, false, fcall.position, null, asmgen), CpuRegister.A, false, false)
+        }
     }
 
     private fun funcRsave() {
@@ -171,7 +193,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 plp""")
     }
 
-    private fun funcCallFar(fcall: PtBuiltinFunctionCall) {
+    private fun funcCallFar(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         if(asmgen.options.compTarget.name != "cx16")
             throw AssemblyError("callfar only works on cx16 target at this time")
 
@@ -181,10 +203,13 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         asmgen.out("  sta  (+)+0 |  sty  (+)+1")
         asmgen.assignExpressionToRegister(fcall.args[2], RegisterOrPair.AY)     // uword argument
         asmgen.out("""
-            jsr  cx16.jsrfar
+            jsr  cx16.JSRFAR
 +           .word  0
 +           .byte  0""")
         // note that by convention the values in A+Y registers are now the return value of the call.
+        if(resultRegister!=null)  {
+            assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister, false, fcall.position, null, asmgen), RegisterOrPair.AY)
+        }
     }
 
     private fun funcCmp(fcall: PtBuiltinFunctionCall) {
@@ -271,11 +296,11 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         when(fcall.args[0].type) {
             DataType.UBYTE -> {
                 asmgen.out("  ldy  #0 |  jsr  prog8_lib.func_sqrt16_into_A")
-                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false)
+                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false, false)
             }
             DataType.UWORD -> {
                 asmgen.out("  jsr  prog8_lib.func_sqrt16_into_A")
-                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false)
+                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false, false)
             }
             DataType.FLOAT -> {
                 asmgen.out("  jsr  floats.func_sqrt_into_FAC1")
@@ -609,6 +634,85 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         asmgen.assignExpressionToVariable(indexer.index, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE)
     }
 
+    private fun funcSetLsbMsb(fcall: PtBuiltinFunctionCall, msb: Boolean) {
+        val target: AsmAssignTarget
+        when(fcall.args[0]) {
+            is PtIdentifier -> {
+                val varname = asmgen.asmVariableName(fcall.args[0] as PtIdentifier) + if(msb) "+1" else ""
+                target = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UBYTE, fcall.definingSub(), fcall.position, variableAsmName = varname)
+            }
+            is PtNumber -> {
+                val num = (fcall.args[0] as PtNumber).number + if(msb) 1 else 0
+                val mem = PtMemoryByte(fcall.position)
+                mem.add(PtNumber(DataType.UBYTE, num, fcall.position))
+                target = AsmAssignTarget(TargetStorageKind.MEMORY, asmgen, DataType.UBYTE, fcall.definingSub(), fcall.position, memory = mem)
+            }
+            is PtAddressOf -> {
+                val mem = PtMemoryByte(fcall.position)
+                if(msb) {
+                    val address = PtBinaryExpression("+", DataType.UWORD, fcall.args[0].position)
+                    address.add(fcall.args[0])
+                    address.add(PtNumber(address.type, 1.0, fcall.args[0].position))
+                    mem.add(address)
+                } else {
+                    mem.add(fcall.args[0])
+                }
+                target = AsmAssignTarget(TargetStorageKind.MEMORY, asmgen, DataType.UBYTE, fcall.definingSub(), fcall.position, memory = mem)
+            }
+            is PtArrayIndexer -> {
+                val indexer = fcall.args[0] as PtArrayIndexer
+                require(!indexer.usesPointerVariable)
+                val elementSize: Int
+                val msbAdd: Int
+                if(indexer.splitWords) {
+                    val arrayVariable = indexer.variable
+                    indexer.children[0] = PtIdentifier(arrayVariable.name + if(msb) "_msb" else "_lsb", DataType.ARRAY_UB, arrayVariable.position)
+                    indexer.children[0].parent = indexer
+                    elementSize = 1
+                    msbAdd = 0
+                } else {
+                    elementSize = 2
+                    msbAdd = if(msb) 1 else 0
+                }
+
+                // double the index because of word array (if not split), add one if msb (if not split)
+                val constIndexNum = (indexer.index as? PtNumber)?.number
+                if(constIndexNum!=null) {
+                    indexer.children[1] = PtNumber(indexer.index.type, constIndexNum*elementSize + msbAdd, indexer.position)
+                    indexer.children[1].parent = indexer
+                } else {
+                    val multipliedIndex: PtExpression
+                    if(elementSize==1) {
+                        multipliedIndex = indexer.index
+                    } else {
+                        multipliedIndex = PtBinaryExpression("<<", indexer.index.type, indexer.position)
+                        multipliedIndex.add(indexer.index)
+                        multipliedIndex.add(PtNumber(DataType.UBYTE, 1.0, indexer.position))
+                    }
+                    if(msbAdd>0) {
+                        val msbIndex = PtBinaryExpression("+", indexer.index.type, indexer.position)
+                        msbIndex.add(multipliedIndex)
+                        msbIndex.add(PtNumber(DataType.UBYTE, msbAdd.toDouble(), indexer.position))
+                        indexer.children[1] = msbIndex
+                        msbIndex.parent = indexer
+                    } else {
+                        indexer.children[1] = multipliedIndex
+                        multipliedIndex.parent=indexer
+                    }
+                }
+                target = AsmAssignTarget(TargetStorageKind.ARRAY, asmgen, DataType.UBYTE, fcall.definingSub(), fcall.position, array = indexer)
+            }
+            else -> throw AssemblyError("setlsb/setmsb on weird target ${fcall.args[0]}")
+        }
+
+        if(fcall.args[1].asConstInteger() == 0) {
+            assignAsmGen.assignConstantByte(target, 0)
+        } else {
+            asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A, false)
+            assignAsmGen.assignRegisterByte(target, CpuRegister.A, false, false)
+        }
+    }
+
     private fun funcSgn(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
         translateArguments(fcall, scope)
         val dt = fcall.args.single().type
@@ -620,7 +724,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             DataType.FLOAT -> asmgen.out("  jsr  floats.func_sign_f_into_A")
             else -> throw AssemblyError("weird type $dt")
         }
-        assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, true)
+        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?) {
@@ -633,7 +737,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             in SplitWordArrayTypes -> TODO("split word any/all")
             else -> throw AssemblyError("weird type $dt")
         }
-        assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, dt in SignedDatatypes)
+        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?) {
@@ -642,7 +746,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         when (dt) {
             DataType.BYTE -> {
                 asmgen.out("  jsr  prog8_lib.abs_b_into_A")
-                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A,false)
+                assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A,false, true)
             }
             DataType.WORD -> {
                 asmgen.out("  jsr  prog8_lib.abs_w_into_AY")
@@ -662,6 +766,41 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         }
     }
 
+    private fun funcPokeF(fcall: PtBuiltinFunctionCall) {
+        when(val number = fcall.args[1]) {
+            is PtIdentifier -> {
+                val varName = asmgen.asmVariableName(number)
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
+                asmgen.out("""
+                    pha
+                    lda  #<$varName
+                    sta  P8ZP_SCRATCH_W1
+                    lda  #>$varName
+                    sta  P8ZP_SCRATCH_W1+1
+                    pla
+                    jsr  floats.copy_float""")
+            }
+            is PtNumber -> {
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
+                asmgen.assignConstFloatToPointerAY(number)
+            }
+            else -> {
+                val tempvar = asmgen.getTempVarName(DataType.FLOAT)
+                asmgen.assignExpressionTo(fcall.args[1],
+                    AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.FLOAT, fcall.definingISub(), fcall.position, tempvar, null, null, null, null))
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
+                asmgen.out("""
+                    pha
+                    lda  #<$tempvar
+                    sta  P8ZP_SCRATCH_W1
+                    lda  #>$tempvar
+                    sta  P8ZP_SCRATCH_W1+1
+                    pla
+                    jsr  floats.copy_float""")
+            }
+        }
+    }
+
     private fun funcPokeW(fcall: PtBuiltinFunctionCall) {
         when(val addrExpr = fcall.args[0]) {
             is PtNumber -> {
@@ -718,6 +857,15 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         asmgen.out("  jsr  prog8_lib.func_pokew")
     }
 
+    private fun funcPeekF(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
+        asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
+        asmgen.out("  jsr  floats.MOVFM")
+        if(resultRegister!=null) {
+            assignAsmGen.assignFAC1float(
+                AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, DataType.FLOAT, fcall.definingISub(), fcall.position, null, null, null, resultRegister, null))
+        }
+    }
+
     private fun funcPeekW(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         fun fallback() {
             asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
@@ -790,7 +938,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 assignAsmGen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A, signed)    // value
                 asmgen.out("  jsr  prog8_lib.func_clamp_${fcall.type.toString().lowercase()}")
                 val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
-                assignAsmGen.assignRegisterByte(targetReg, CpuRegister.A, signed)
+                assignAsmGen.assignRegisterByte(targetReg, CpuRegister.A, signed, true)
             }
             in WordDatatypes -> {
                 assignAsmGen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W1", fcall.args[1].type)  // minimum
@@ -806,55 +954,59 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
 
     private fun funcMin(fcall: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?) {
         val signed = fcall.type in SignedDatatypes
-        if(fcall.type in ByteDatatypes) {
-            asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_B1", fcall.type)     // right
-            asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A)          // left
-            asmgen.out("  cmp  P8ZP_SCRATCH_B1")
-            if(signed) asmgen.out("  bmi  +") else asmgen.out("  bcc  +")
-            asmgen.out("""
-                lda  P8ZP_SCRATCH_B1
-+""")
-            val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
-            asmgen.assignRegister(RegisterOrPair.A, targetReg)
-        } else if(fcall.type in WordDatatypes) {
-            asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", fcall.type)     // left
-            asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W2", fcall.type)     // right
-            if(signed) {
+        when (fcall.type) {
+            in ByteDatatypes -> {
+                asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_B1", fcall.type)     // right
+                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A)          // left
+                asmgen.out("  cmp  P8ZP_SCRATCH_B1")
+                if(signed) asmgen.out("  bmi  +") else asmgen.out("  bcc  +")
                 asmgen.out("""
-                    lda  P8ZP_SCRATCH_W1
-                    ldy  P8ZP_SCRATCH_W1+1
-                    cmp  P8ZP_SCRATCH_W2
-                    tya
-                    sbc  P8ZP_SCRATCH_W2+1
-                    bvc  +
-                    eor  #$80
-+                   bpl  +
-                    lda  P8ZP_SCRATCH_W1                   
-                    ldy  P8ZP_SCRATCH_W1+1
-                    jmp  ++
-+                   lda  P8ZP_SCRATCH_W2
-                    ldy  P8ZP_SCRATCH_W2+1
-+""")
-            } else {
-                asmgen.out("""
-                    lda  P8ZP_SCRATCH_W1+1
-                    cmp  P8ZP_SCRATCH_W2+1
-                    bcc  ++
-                    bne  +
-                    lda  P8ZP_SCRATCH_W1
-                    cmp  P8ZP_SCRATCH_W2
-                    bcc  ++
-+                   lda  P8ZP_SCRATCH_W2
-                    ldy  P8ZP_SCRATCH_W2+1
-                    jmp  ++
-+                   lda  P8ZP_SCRATCH_W1
-                    ldy  P8ZP_SCRATCH_W1+1
-+""")
+                    lda  P8ZP_SCRATCH_B1
+    +""")
+                val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, signed, fcall.position, fcall.definingISub(), asmgen)
+                asmgen.assignRegister(RegisterOrPair.A, targetReg)
+            }
+            in WordDatatypes -> {
+                asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", fcall.type)     // left
+                asmgen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W2", fcall.type)     // right
+                if(signed) {
+                    asmgen.out("""
+                        lda  P8ZP_SCRATCH_W1
+                        ldy  P8ZP_SCRATCH_W1+1
+                        cmp  P8ZP_SCRATCH_W2
+                        tya
+                        sbc  P8ZP_SCRATCH_W2+1
+                        bvc  +
+                        eor  #$80
+    +                   bpl  +
+                        lda  P8ZP_SCRATCH_W1                   
+                        ldy  P8ZP_SCRATCH_W1+1
+                        jmp  ++
+    +                   lda  P8ZP_SCRATCH_W2
+                        ldy  P8ZP_SCRATCH_W2+1
+    +""")
+                } else {
+                    asmgen.out("""
+                        lda  P8ZP_SCRATCH_W1+1
+                        cmp  P8ZP_SCRATCH_W2+1
+                        bcc  ++
+                        bne  +
+                        lda  P8ZP_SCRATCH_W1
+                        cmp  P8ZP_SCRATCH_W2
+                        bcc  ++
+    +                   lda  P8ZP_SCRATCH_W2
+                        ldy  P8ZP_SCRATCH_W2+1
+                        jmp  ++
+    +                   lda  P8ZP_SCRATCH_W1
+                        ldy  P8ZP_SCRATCH_W1+1
+    +""")
+                }
+                val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
+                asmgen.assignRegister(RegisterOrPair.AY, targetReg)
+            }
+            else -> {
+                throw AssemblyError("min float not supported")
             }
-            val targetReg = AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, signed, fcall.position, fcall.definingISub(), asmgen)
-            asmgen.assignRegister(RegisterOrPair.AY, targetReg)
-        } else {
-            throw AssemblyError("min float not supported")
         }
     }
 
@@ -986,17 +1138,17 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         } else {
             when(resultRegister) {
                 null, RegisterOrPair.A -> {
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.AY)
                     asmgen.out("  tya")
                 }
                 RegisterOrPair.X -> {
                     asmgen.out("  pha")
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AX)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.AX)
                     asmgen.out("  pla")
                 }
                 RegisterOrPair.Y -> {
                     asmgen.out("  pha")
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.AY)
                     asmgen.out("  pla")
                 }
                 else -> throw AssemblyError("invalid reg")
@@ -1030,37 +1182,55 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 else -> throw AssemblyError("invalid reg")
             }
         } else {
-            when(resultRegister) {
+            if(arg is PtArrayIndexer && resultRegister in setOf(null, RegisterOrPair.A, RegisterOrPair.Y, RegisterOrPair.X)) {
+                // just read the lsb byte out of the word array
+                val arrayVar = if(arg.splitWords) asmgen.asmVariableName(arg.variable)+"_lsb" else asmgen.asmVariableName(arg.variable)
+                when(resultRegister) {
+                    null, RegisterOrPair.A -> {
+                        asmgen.loadScaledArrayIndexIntoRegister(arg, arg.type, CpuRegister.Y)
+                        asmgen.out("  lda  $arrayVar,y")
+                    }
+                    RegisterOrPair.Y -> {
+                        asmgen.loadScaledArrayIndexIntoRegister(arg, arg.type, CpuRegister.X)
+                        asmgen.out("  lda  $arrayVar,x")
+                    }
+                    RegisterOrPair.X -> {
+                        asmgen.loadScaledArrayIndexIntoRegister(arg, arg.type, CpuRegister.Y)
+                        asmgen.out("  ldx  $arrayVar,y")
+                    }
+                    else -> throw AssemblyError("invalid reg")
+                }
+            } else  when(resultRegister) {
                 null, RegisterOrPair.A -> {
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.AY)
                     // NOTE: we rely on the fact that the above assignment to AY, assigns the Lsb to A as the last instruction.
                     //       this is required because the compiler assumes the status bits are set according to what A is (lsb)
                     //       and will not generate another cmp when lsb() is directly used inside a comparison expression.
                 }
                 RegisterOrPair.X -> {
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.XY)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.XY)
                     // NOTE: we rely on the fact that the above assignment to XY, assigns the Lsb to X as the last instruction.
                     //       this is required because the compiler assumes the status bits are set according to what X is (lsb)
                     //       and will not generate another cmp when lsb() is directly used inside a comparison expression.
                 }
                 RegisterOrPair.Y -> {
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.AY)
                     asmgen.out("  tay |  cpy  #0")
                 }
                 RegisterOrPair.AY -> {
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AY)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.AY)
                     asmgen.out("  ldy  #0 |  cmp  #0")
                 }
                 RegisterOrPair.AX -> {
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.AX)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.AX)
                     asmgen.out("  ldx  #0 |  cmp  #0")
                 }
                 RegisterOrPair.XY -> {
-                    asmgen.assignExpressionToRegister(fcall.args.single(), RegisterOrPair.XY)
+                    asmgen.assignExpressionToRegister(arg, RegisterOrPair.XY)
                     asmgen.out("  ldy  #0 |  cpx  #0")
                 }
                 in Cx16VirtualRegisters -> {
-                    asmgen.assignExpressionToRegister(fcall.args.single(), resultRegister)
+                    asmgen.assignExpressionToRegister(arg, resultRegister)
                     val zero = PtNumber(DataType.UBYTE, 0.0, Position.DUMMY)
                     zero.parent=fcall
                     assignAsmGen.assignExpressionToVariable(zero, "cx16.${resultRegister.toString().lowercase()}H", DataType.UBYTE)

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

@@ -69,37 +69,59 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         // remember: dealing with the X register and/or dealing with return values is the responsibility of the caller
     }
 
-    private fun argumentsViaRegisters(sub: PtAsmSub, call: PtFunctionCall) {
-        if(sub.parameters.size==1) {
-            argumentViaRegister(sub, IndexedValue(0, sub.parameters.single().second), call.args[0])
-        } else {
-            if(asmsub6502ArgsHaveRegisterClobberRisk(call.args, sub.parameters)) {
-                registerArgsViaCpuStackEvaluation(call, sub)
-            } else {
-                asmsub6502ArgsEvalOrder(sub).forEach {
-                    val param = sub.parameters[it]
-                    val arg = call.args[it]
-                    argumentViaRegister(sub, IndexedValue(it, param.second), arg)
-                }
+
+    private fun usesOtherRegistersWhileEvaluating(arg: PtExpression): Boolean {
+        return when(arg) {
+            is PtBuiltinFunctionCall -> {
+                if (arg.name == "lsb" || arg.name == "msb")
+                    return usesOtherRegistersWhileEvaluating(arg.args[0])
+                if (arg.name == "mkword")
+                    return usesOtherRegistersWhileEvaluating(arg.args[0]) || usesOtherRegistersWhileEvaluating(arg.args[1])
+                return !arg.isSimple()
             }
+            is PtAddressOf -> false
+            is PtIdentifier -> false
+            is PtMachineRegister -> false
+            is PtMemoryByte -> false
+            is PtNumber -> false
+            else -> true
         }
     }
 
-    private fun registerArgsViaCpuStackEvaluation(call: PtFunctionCall, callee: PtAsmSub) {
-        // this is called when one or more of the arguments are 'complex' and
-        // cannot be assigned to a register easily or risk clobbering other registers.
+    private fun argumentsViaRegisters(sub: PtAsmSub, call: PtFunctionCall) {
+        val registersUsed = mutableListOf<RegisterOrStatusflag>();
 
-        if(callee.parameters.isEmpty())
-            return
+        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}
+        fun usedY() = registersUsed.any {it.registerOrPair==RegisterOrPair.Y || it.registerOrPair==RegisterOrPair.AY || it.registerOrPair==RegisterOrPair.XY}
 
-        // use the cpu hardware stack as intermediate storage for the arguments.
-        val argOrder = asmsub6502ArgsEvalOrder(callee)
-        argOrder.reversed().forEach {
-            asmgen.pushCpuStack(callee.parameters[it].second.type, call.args[it])
-        }
-        argOrder.forEach {
-            val param = callee.parameters[it]
-            asmgen.popCpuStack(callee, param.second, param.first)
+        if(sub.parameters.size==1) {
+            argumentViaRegister(sub, IndexedValue(0, sub.parameters.single().second), call.args[0])
+        } else {
+            val optimalEvalOrder = asmsub6502ArgsEvalOrder(sub)
+            optimalEvalOrder.forEach {
+                val param = sub.parameters[it]
+                val arg = call.args[it]
+                registersUsed += if(usesOtherRegistersWhileEvaluating(arg)) {
+                    if(!registersUsed.any{it.statusflag!=null || it.registerOrPair in CpuRegisters})
+                        argumentViaRegister(sub, IndexedValue(it, param.second), arg)
+                    else if(registersUsed.any {it.statusflag!=null}) {
+                        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)
+                        val used = argumentViaRegister(sub, IndexedValue(it, param.second), arg)
+                        if(usedA()) asmgen.restoreRegisterStack(CpuRegister.A, false)
+                        if(usedY()) asmgen.restoreRegisterStack(CpuRegister.Y, true)
+                        if(usedX()) asmgen.restoreRegisterStack(CpuRegister.X, true)
+                        used
+                    }
+                } else {
+                    argumentViaRegister(sub, IndexedValue(it, param.second), arg)
+                }
+            }
         }
     }
 
@@ -112,7 +134,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         asmgen.assignExpressionToVariable(value, varName, parameter.type)
     }
 
-    private fun argumentViaRegister(sub: IPtSubroutine, parameter: IndexedValue<PtSubroutineParameter>, value: PtExpression, registerOverride: RegisterOrPair? = null) {
+    private fun argumentViaRegister(sub: IPtSubroutine, parameter: IndexedValue<PtSubroutineParameter>, value: PtExpression, registerOverride: RegisterOrPair? = null): RegisterOrStatusflag {
         // pass argument via a register parameter
         if(!isArgumentTypeCompatible(value.type, parameter.value.type))
             throw AssemblyError("argument type incompatible")
@@ -141,13 +163,14 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                     }
                     is PtIdentifier -> {
                         val sourceName = asmgen.asmVariableName(value)
+                        // note: cannot use X register here to store A because it might be used for other arguments
                         asmgen.out("""
-                            tax
+                            pha
                             clc
                             lda  $sourceName
                             beq  +
                             sec  
-+                           txa""")
++                           pla""")
                     }
                     else -> {
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
@@ -155,6 +178,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                     }
                 }
             } else throw AssemblyError("can only use Carry as status flag parameter")
+            return RegisterOrStatusflag(null, statusflag)
         }
         else {
             // via register or register pair
@@ -187,6 +211,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                 }
                 asmgen.translateNormalAssignment(AsmAssignment(src, target, program.memsizer, Position.DUMMY), scope)
             }
+            return RegisterOrStatusflag(register, null)
         }
     }
 
@@ -208,3 +233,5 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         return false
     }
 }
+
+

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

@@ -497,7 +497,15 @@ internal class ProgramAndVarsGen(
         for ((scopedName, zpvar) in zpVariables) {
             if (scopedName.startsWith("cx16.r"))
                 continue        // The 16 virtual registers of the cx16 are not actual variables in zp, they're memory mapped
-            asmgen.out("${scopedName.substringAfterLast('.')} \t= ${zpvar.address} \t; zp ${zpvar.dt}")
+            val variable = symboltable.flat.getValue(scopedName) as StStaticVariable
+            if(variable.dt in SplitWordArrayTypes) {
+                val lsbAddr = zpvar.address
+                val msbAddr = zpvar.address + (zpvar.size/2).toUInt()
+                asmgen.out("${scopedName.substringAfterLast('.')}_lsb \t= $lsbAddr \t; zp ${zpvar.dt} (lsbs)")
+                asmgen.out("${scopedName.substringAfterLast('.')}_msb \t= $msbAddr \t; zp ${zpvar.dt} (msbs)")
+            } else {
+                asmgen.out("${scopedName.substringAfterLast('.')} \t= ${zpvar.address} \t; zp ${zpvar.dt}")
+            }
         }
     }
 

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

@@ -23,13 +23,13 @@ internal class AnyExprAsmGen(
                     return assignByteBinExpr(expr, assign)
                 if (expr.left.type in WordDatatypes && expr.right.type in WordDatatypes) {
                     require(expr.operator in ComparisonOperators)
-                    TODO("words operands comparison -> byte")
+                    throw AssemblyError("words operands comparison -> byte, should have been handled by assignOptimizedComparisonWords()")
                 }
                 if (expr.left.type==DataType.FLOAT && expr.right.type==DataType.FLOAT) {
                     require(expr.operator in ComparisonOperators)
                     return assignFloatBinExpr(expr, assign)
                 }
-                TODO("weird expr operand types")
+                throw AssemblyError("weird expr operand types: ${expr.left.type} and {${expr.right.type}")
             }
             in WordDatatypes -> {
                 require(expr.left.type in WordDatatypes && expr.right.type in WordDatatypes) {

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

@@ -83,19 +83,20 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                         }
                     }
                     in WordDatatypes -> {
+                        val block = target.origAstTarget?.definingBlock()
                         when(value.kind) {
-                            SourceStorageKind.LITERALNUMBER -> inplacemodificationWordWithLiteralval(target.asmVarname, target.datatype, operator, value.number!!.number.toInt())
-                            SourceStorageKind.VARIABLE -> inplacemodificationWordWithVariable(target.asmVarname, target.datatype, operator, value.asmVarname, value.datatype)
-                            SourceStorageKind.REGISTER -> inplacemodificationWordWithVariable(target.asmVarname, target.datatype, operator, regName(value), value.datatype)
+                            SourceStorageKind.LITERALNUMBER -> inplacemodificationWordWithLiteralval(target.asmVarname, target.datatype, operator, value.number!!.number.toInt(), block)
+                            SourceStorageKind.VARIABLE -> inplacemodificationWordWithVariable(target.asmVarname, target.datatype, operator, value.asmVarname, value.datatype, block)
+                            SourceStorageKind.REGISTER -> inplacemodificationWordWithVariable(target.asmVarname, target.datatype, operator, regName(value), value.datatype, block)
                             SourceStorageKind.MEMORY -> inplacemodificationWordWithMemread(target.asmVarname, target.datatype, operator, value.memory!!)
-                            SourceStorageKind.ARRAY -> inplacemodificationWordWithValue(target.asmVarname, target.datatype, operator, value.array!!)
+                            SourceStorageKind.ARRAY -> inplacemodificationWordWithValue(target.asmVarname, target.datatype, operator, value.array!!, block)
                             SourceStorageKind.EXPRESSION -> {
                                 if(value.expression is PtTypeCast) {
                                     if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
-                                    inplacemodificationWordWithValue(target.asmVarname, target.datatype, operator, value.expression)
+                                    inplacemodificationWordWithValue(target.asmVarname, target.datatype, operator, value.expression, block)
                                 }
                                 else {
-                                    inplacemodificationWordWithValue(target.asmVarname, target.datatype, operator, value.expression!!)
+                                    inplacemodificationWordWithValue(target.asmVarname, target.datatype, operator, value.expression!!, block)
                                 }
                             }
                         }
@@ -204,237 +205,251 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
             }
             TargetStorageKind.ARRAY -> {
                 val indexNum = target.array!!.index as? PtNumber
-                val indexVar = target.array.index as? PtIdentifier
-                when {
-                    indexNum!=null -> {
-                        val targetVarName = if(target.array.splitWords)
-                            "${target.asmVarname} + ${indexNum.number.toInt()}"
-                        else
-                            "${target.asmVarname} + ${indexNum.number.toInt()*program.memsizer.memorySize(target.datatype)}"
-                        when (target.datatype) {
-                            in ByteDatatypes -> {
-                                when(value.kind) {
-                                    SourceStorageKind.LITERALNUMBER -> inplacemodificationByteVariableWithLiteralval(targetVarName, target.datatype, operator, value.number!!.number.toInt())
-                                    SourceStorageKind.VARIABLE -> inplacemodificationByteVariableWithVariable(targetVarName, target.datatype, operator, value.asmVarname)
-                                    SourceStorageKind.REGISTER -> inplacemodificationByteVariableWithVariable(targetVarName, target.datatype, operator, regName(value))
-                                    SourceStorageKind.MEMORY -> inplacemodificationByteVariableWithValue(targetVarName, target.datatype, operator, value.memory!!)
-                                    SourceStorageKind.ARRAY -> inplacemodificationByteVariableWithValue(targetVarName, target.datatype, operator, value.array!!)
-                                    SourceStorageKind.EXPRESSION -> {
-                                        if(value.expression is PtTypeCast) {
-                                            if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
-                                            inplacemodificationByteVariableWithValue(targetVarName, target.datatype, operator, value.expression)
-                                        } else {
-                                            inplacemodificationByteVariableWithValue(targetVarName, target.datatype, operator, value.expression!!)
-                                        }
+                if (indexNum!=null) {
+                    val targetVarName = if(target.array.splitWords)
+                        "${target.asmVarname} + ${indexNum.number.toInt()}"
+                    else
+                        "${target.asmVarname} + ${indexNum.number.toInt()*program.memsizer.memorySize(target.datatype)}"
+                    when (target.datatype) {
+                        in ByteDatatypes -> {
+                            when(value.kind) {
+                                SourceStorageKind.LITERALNUMBER -> inplacemodificationByteVariableWithLiteralval(targetVarName, target.datatype, operator, value.number!!.number.toInt())
+                                SourceStorageKind.VARIABLE -> inplacemodificationByteVariableWithVariable(targetVarName, target.datatype, operator, value.asmVarname)
+                                SourceStorageKind.REGISTER -> inplacemodificationByteVariableWithVariable(targetVarName, target.datatype, operator, regName(value))
+                                SourceStorageKind.MEMORY -> inplacemodificationByteVariableWithValue(targetVarName, target.datatype, operator, value.memory!!)
+                                SourceStorageKind.ARRAY -> inplacemodificationByteVariableWithValue(targetVarName, target.datatype, operator, value.array!!)
+                                SourceStorageKind.EXPRESSION -> {
+                                    if(value.expression is PtTypeCast) {
+                                        if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
+                                        inplacemodificationByteVariableWithValue(targetVarName, target.datatype, operator, value.expression)
+                                    } else {
+                                        inplacemodificationByteVariableWithValue(targetVarName, target.datatype, operator, value.expression!!)
                                     }
                                 }
                             }
-                            in WordDatatypes -> {
-                                when(value.kind) {
-                                    SourceStorageKind.LITERALNUMBER -> inplacemodificationWordWithLiteralval(targetVarName, target.datatype, operator, value.number!!.number.toInt())
-                                    SourceStorageKind.VARIABLE -> inplacemodificationWordWithVariable(targetVarName, target.datatype, operator, value.asmVarname, value.datatype)
-                                    SourceStorageKind.REGISTER -> inplacemodificationWordWithVariable(targetVarName, target.datatype, operator, regName(value), value.datatype)
-                                    SourceStorageKind.MEMORY -> inplacemodificationWordWithMemread(targetVarName, target.datatype, operator, value.memory!!)
-                                    SourceStorageKind.ARRAY -> inplacemodificationWordWithValue(targetVarName, target.datatype, operator, value.array!!)
-                                    SourceStorageKind.EXPRESSION -> {
-                                        if(value.expression is PtTypeCast) {
-                                            if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
-                                            inplacemodificationWordWithValue(targetVarName, target.datatype, operator, value.expression)
-                                        } else {
-                                            inplacemodificationWordWithValue(targetVarName, target.datatype, operator, value.expression!!)
-                                        }
-                                    }
-                                }
-                            }
-                            DataType.FLOAT -> {
-                                when(value.kind) {
-                                    SourceStorageKind.LITERALNUMBER -> inplacemodificationFloatWithLiteralval(targetVarName, operator, value.number!!.number)
-                                    SourceStorageKind.VARIABLE -> inplacemodificationFloatWithVariable(targetVarName, operator, value.asmVarname)
-                                    SourceStorageKind.REGISTER -> inplacemodificationFloatWithVariable(targetVarName, operator, regName(value))
-                                    SourceStorageKind.MEMORY -> TODO("memread into float array")
-                                    SourceStorageKind.ARRAY -> inplacemodificationFloatWithValue(targetVarName, operator, value.array!!)
-                                    SourceStorageKind.EXPRESSION -> {
-                                        if(value.expression is PtTypeCast) {
-                                            if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
-                                            inplacemodificationFloatWithValue(targetVarName, operator, value.expression)
-                                        } else {
-                                            inplacemodificationFloatWithValue(targetVarName, operator, value.expression!!)
-                                        }
-                                    }
-                                }
-                            }
-                            else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
                         }
+
+                        in WordDatatypes -> {
+                            val block = target.origAstTarget?.definingBlock()
+                            when(value.kind) {
+                                SourceStorageKind.LITERALNUMBER -> inplacemodificationWordWithLiteralval(targetVarName, target.datatype, operator, value.number!!.number.toInt(), block)
+                                SourceStorageKind.VARIABLE -> inplacemodificationWordWithVariable(targetVarName, target.datatype, operator, value.asmVarname, value.datatype, block)
+                                SourceStorageKind.REGISTER -> inplacemodificationWordWithVariable(targetVarName, target.datatype, operator, regName(value), value.datatype, block)
+                                SourceStorageKind.MEMORY -> inplacemodificationWordWithMemread(targetVarName, target.datatype, operator, value.memory!!)
+                                SourceStorageKind.ARRAY -> inplacemodificationWordWithValue(targetVarName, target.datatype, operator, value.array!!, block)
+                                SourceStorageKind.EXPRESSION -> {
+                                    if(value.expression is PtTypeCast) {
+                                        if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
+                                        inplacemodificationWordWithValue(targetVarName, target.datatype, operator, value.expression, block)
+                                    } else {
+                                        inplacemodificationWordWithValue(targetVarName, target.datatype, operator, value.expression!!, block)
+                                    }
+                                }
+                            }
+                        }
+
+                        DataType.FLOAT -> {
+                            when(value.kind) {
+                                SourceStorageKind.LITERALNUMBER -> inplacemodificationFloatWithLiteralval(targetVarName, operator, value.number!!.number)
+                                SourceStorageKind.VARIABLE -> inplacemodificationFloatWithVariable(targetVarName, operator, value.asmVarname)
+                                SourceStorageKind.REGISTER -> inplacemodificationFloatWithVariable(targetVarName, operator, regName(value))
+                                SourceStorageKind.MEMORY -> TODO("memread into float array")
+                                SourceStorageKind.ARRAY -> inplacemodificationFloatWithValue(targetVarName, operator, value.array!!)
+                                SourceStorageKind.EXPRESSION -> {
+                                    if(value.expression is PtTypeCast) {
+                                        if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator)) return
+                                        inplacemodificationFloatWithValue(targetVarName, operator, value.expression)
+                                    } else {
+                                        inplacemodificationFloatWithValue(targetVarName, operator, value.expression!!)
+                                    }
+                                }
+                            }
+                        }
+
+                        else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
                     }
-                    indexVar!=null -> {
-                        when (target.datatype) {
-                            in ByteDatatypes -> {
-                                if(value.kind==SourceStorageKind.EXPRESSION
-                                    && value.expression is PtTypeCast
-                                    && tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator))
-                                    return
-                                asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UBYTE, CpuRegister.Y)
-                                asmgen.saveRegisterStack(CpuRegister.Y, false)
+                }
+                else {
+                    when (target.datatype) {
+                        in ByteDatatypes -> {
+                            if(value.kind==SourceStorageKind.EXPRESSION
+                                && value.expression is PtTypeCast
+                                && tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator))
+                                return
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UBYTE, CpuRegister.Y)
+                            asmgen.saveRegisterStack(CpuRegister.Y, false)
+                            asmgen.out("  lda  ${target.array.variable.name},y")
+                            when(value.kind) {
+                                SourceStorageKind.LITERALNUMBER -> {
+                                    inplacemodificationRegisterAwithVariable(operator, "#${value.number!!.number.toInt()}", target.datatype in SignedDatatypes)
+                                    asmgen.restoreRegisterStack(CpuRegister.Y, true)
+                                }
+
+                                SourceStorageKind.VARIABLE -> {
+                                    inplacemodificationRegisterAwithVariable(operator, value.asmVarname, target.datatype in SignedDatatypes)
+                                    asmgen.restoreRegisterStack(CpuRegister.Y, true)
+                                }
+
+                                SourceStorageKind.REGISTER -> {
+                                    inplacemodificationRegisterAwithVariable(operator, regName(value), target.datatype in SignedDatatypes)
+                                    asmgen.restoreRegisterStack(CpuRegister.Y, true)
+                                }
+
+                                SourceStorageKind.MEMORY -> {
+                                    asmgen.out("  sta  P8ZP_SCRATCH_B1")
+                                    inplacemodificationByteVariableWithValue("P8ZP_SCRATCH_B1", target.datatype, operator, value.memory!!)
+                                    asmgen.restoreRegisterStack(CpuRegister.Y, false)
+                                    asmgen.out("  lda  P8ZP_SCRATCH_B1")
+                                }
+
+                                SourceStorageKind.ARRAY -> {
+                                    asmgen.out("  sta  P8ZP_SCRATCH_B1")
+                                    inplacemodificationByteVariableWithValue("P8ZP_SCRATCH_B1", target.datatype, operator, value.array!!)
+                                    asmgen.restoreRegisterStack(CpuRegister.Y, false)
+                                    asmgen.out("  lda  P8ZP_SCRATCH_B1")
+                                }
+
+                                SourceStorageKind.EXPRESSION -> {
+                                    asmgen.out("  sta  P8ZP_SCRATCH_B1")
+                                    if(value.expression is PtTypeCast)
+                                        inplacemodificationByteVariableWithValue("P8ZP_SCRATCH_B1", target.datatype, operator, value.expression)
+                                    else
+                                        inplacemodificationByteVariableWithValue("P8ZP_SCRATCH_B1", target.datatype, operator, value.expression!!)
+                                    asmgen.restoreRegisterStack(CpuRegister.Y, false)
+                                    asmgen.out("  lda  P8ZP_SCRATCH_B1")
+                                }
+                            }
+                            asmgen.out("  sta  ${target.array.variable.name},y")
+                        }
+
+                        in WordDatatypes -> {
+                            if(value.kind==SourceStorageKind.EXPRESSION
+                                && value.expression is PtTypeCast
+                                && tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator))
+                                return
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UWORD, CpuRegister.Y)
+                            asmgen.saveRegisterStack(CpuRegister.Y, false)
+                            if(target.array.splitWords) {
+                                asmgen.out("  lda  ${target.array.variable.name}_lsb,y")
+                                asmgen.out("  ldx  ${target.array.variable.name}_msb,y")
+                            } else {
                                 asmgen.out("  lda  ${target.array.variable.name},y")
-                                when(value.kind) {
-                                    SourceStorageKind.LITERALNUMBER -> {
-                                        inplacemodificationRegisterAwithVariable(operator, "#${value.number!!.number.toInt()}", target.datatype in SignedDatatypes)
-                                        asmgen.restoreRegisterStack(CpuRegister.Y, true)
-                                    }
-                                    SourceStorageKind.VARIABLE -> {
-                                        inplacemodificationRegisterAwithVariable(operator, value.asmVarname, target.datatype in SignedDatatypes)
-                                        asmgen.restoreRegisterStack(CpuRegister.Y, true)
-                                    }
-                                    SourceStorageKind.REGISTER -> {
-                                        inplacemodificationRegisterAwithVariable(operator, regName(value), target.datatype in SignedDatatypes)
-                                        asmgen.restoreRegisterStack(CpuRegister.Y, true)
-                                    }
-                                    SourceStorageKind.MEMORY -> {
-                                        asmgen.out("  sta  P8ZP_SCRATCH_B1")
-                                        inplacemodificationByteVariableWithValue("P8ZP_SCRATCH_B1", target.datatype, operator, value.memory!!)
-                                        asmgen.restoreRegisterStack(CpuRegister.Y, false)
-                                        asmgen.out("  lda  P8ZP_SCRATCH_B1")
-                                    }
-                                    SourceStorageKind.ARRAY -> {
-                                        asmgen.out("  sta  P8ZP_SCRATCH_B1")
-                                        inplacemodificationByteVariableWithValue("P8ZP_SCRATCH_B1", target.datatype, operator, value.array!!)
-                                        asmgen.restoreRegisterStack(CpuRegister.Y, false)
-                                        asmgen.out("  lda  P8ZP_SCRATCH_B1")
-                                    }
-                                    SourceStorageKind.EXPRESSION -> {
-                                        asmgen.out("  sta  P8ZP_SCRATCH_B1")
-                                        if(value.expression is PtTypeCast)
-                                            inplacemodificationByteVariableWithValue("P8ZP_SCRATCH_B1", target.datatype, operator, value.expression)
-                                        else
-                                            inplacemodificationByteVariableWithValue("P8ZP_SCRATCH_B1", target.datatype, operator, value.expression!!)
-                                        asmgen.restoreRegisterStack(CpuRegister.Y, false)
-                                        asmgen.out("  lda  P8ZP_SCRATCH_B1")
-                                    }
-                                }
-                                asmgen.out("  sta  ${target.array.variable.name},y")
+                                asmgen.out("  ldx  ${target.array.variable.name}+1,y")
                             }
-                            in WordDatatypes -> {
-                                if(value.kind==SourceStorageKind.EXPRESSION
-                                    && value.expression is PtTypeCast
-                                    && tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator))
-                                    return
-                                asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.UWORD, CpuRegister.Y)
-                                asmgen.saveRegisterStack(CpuRegister.Y, false)
-                                if(target.array.splitWords) {
-                                    asmgen.out("  lda  ${target.array.variable.name}_lsb,y")
-                                    asmgen.out("  ldx  ${target.array.variable.name}_msb,y")
-                                } else {
-                                    asmgen.out("  lda  ${target.array.variable.name},y")
-                                    asmgen.out("  ldx  ${target.array.variable.name}+1,y")
-                                }
-                                when(value.kind) {
-                                    SourceStorageKind.LITERALNUMBER -> {
-                                        val number = value.number!!.number.toInt()
-                                        if(!inplacemodificationRegisterAXwithLiteralval(operator, number)) {
-                                            asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
-                                            inplacemodificationWordWithLiteralval("P8ZP_SCRATCH_W1", target.datatype, operator, number)
-                                            asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
-                                        }
-                                    }
-                                    SourceStorageKind.VARIABLE -> {
-                                        if(!inplacemodificationRegisterAXwithVariable(
-                                                operator,
-                                                value.asmVarname,
-                                                value.datatype
-                                            )) {
-                                            asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
-                                            inplacemodificationWordWithVariable("P8ZP_SCRATCH_W1", target.datatype, operator, value.asmVarname, value.datatype)
-                                            asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
-                                        }
-                                    }
-                                    SourceStorageKind.REGISTER -> {
-                                        if(!inplacemodificationRegisterAXwithVariable(
-                                                operator,
-                                                regName(value),
-                                                value.datatype
-                                            )) {
-                                            asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
-                                            inplacemodificationWordWithVariable("P8ZP_SCRATCH_W1", target.datatype, operator, regName(value), value.datatype)
-                                            asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
-                                        }
-                                    }
-                                    SourceStorageKind.MEMORY -> {
+                            val block = target.origAstTarget?.definingBlock()
+                            when(value.kind) {
+                                SourceStorageKind.LITERALNUMBER -> {
+                                    val number = value.number!!.number.toInt()
+                                    if(!inplacemodificationRegisterAXwithLiteralval(operator, number)) {
                                         asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
-                                        inplacemodificationWordWithMemread("P8ZP_SCRATCH_W1", target.datatype, operator, value.memory!!)
+                                        inplacemodificationWordWithLiteralval("P8ZP_SCRATCH_W1", target.datatype, operator, number, block)
                                         asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
                                     }
-                                    SourceStorageKind.ARRAY -> {
-                                        asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
-                                        inplacemodificationWordWithValue("P8ZP_SCRATCH_W1", target.datatype, operator, value.array!!)
-                                        asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
-                                    }
-                                    SourceStorageKind.EXPRESSION -> {
-                                        asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
-                                        if(value.expression is PtTypeCast)
-                                            inplacemodificationWordWithValue("P8ZP_SCRATCH_W1", target.datatype, operator, value.expression)
-                                        else
-                                            inplacemodificationWordWithValue("P8ZP_SCRATCH_W1", target.datatype, operator, value.expression!!)
-                                        asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
-                                    }
-                                }
-                                asmgen.restoreRegisterStack(CpuRegister.Y, true)
-                                if(target.array.splitWords)
-                                    asmgen.out("  sta  ${target.array.variable.name}_lsb,y |  txa |  sta  ${target.array.variable.name}_msb,y")
-                                else
-                                    asmgen.out("  sta  ${target.array.variable.name},y |  txa |  sta  ${target.array.variable.name}+1,y")
-                            }
-                            DataType.FLOAT -> {
-                                // copy array value into tempvar
-                                val tempvar = asmgen.getTempVarName(DataType.FLOAT)
-                                asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.FLOAT, CpuRegister.A)
-                                asmgen.out("""
-                                    ldy  #>${target.asmVarname}
-                                    clc
-                                    adc  #<${target.asmVarname}
-                                    bcc  +
-                                    iny
-+                                   sta  P8ZP_SCRATCH_W1
-                                    sty  P8ZP_SCRATCH_W1+1
-                                    pha  ; save array ptr lsb
-                                    tya
-                                    pha  ; save array ptr msb
-                                    lda  #<$tempvar
-                                    ldy  #>$tempvar
-                                    jsr  floats.copy_float""")
-
-                                // calculate on tempvar
-                                when(value.kind) {
-                                    SourceStorageKind.LITERALNUMBER -> inplacemodificationFloatWithLiteralval(tempvar, operator, value.number!!.number)
-                                    SourceStorageKind.VARIABLE -> inplacemodificationFloatWithVariable(tempvar, operator, value.asmVarname)
-                                    SourceStorageKind.REGISTER -> inplacemodificationFloatWithVariable(tempvar, operator, regName(value))
-                                    SourceStorageKind.MEMORY -> TODO("memread into float")
-                                    SourceStorageKind.ARRAY -> inplacemodificationFloatWithValue(tempvar, operator, value.array!!)
-                                    SourceStorageKind.EXPRESSION -> {
-                                        if(value.expression is PtTypeCast) {
-                                            if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator))
-                                                return
-                                            inplacemodificationFloatWithValue(tempvar, operator, value.expression)
-                                        } else {
-                                            inplacemodificationFloatWithValue(tempvar, operator, value.expression!!)
-                                        }
-                                    }
                                 }
 
-                                // copy tempvar back into array
-                                asmgen.out("""
-                                    lda  #<$tempvar
-                                    ldy  #>$tempvar
-                                    sta  P8ZP_SCRATCH_W1
-                                    sty  P8ZP_SCRATCH_W1+1
-                                    pla  ; restore array ptr msb
-                                    tay
-                                    pla  ; restore array ptr lsb
-                                    jsr  floats.copy_float""")
+                                SourceStorageKind.VARIABLE -> {
+                                    if(!inplacemodificationRegisterAXwithVariable(
+                                            operator,
+                                            value.asmVarname,
+                                            value.datatype
+                                        )) {
+                                        asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
+                                        inplacemodificationWordWithVariable("P8ZP_SCRATCH_W1", target.datatype, operator, value.asmVarname, value.datatype, block)
+                                        asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
+                                    }
+                                }
+
+                                SourceStorageKind.REGISTER -> {
+                                    if(!inplacemodificationRegisterAXwithVariable(
+                                            operator,
+                                            regName(value),
+                                            value.datatype
+                                        )) {
+                                        asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
+                                        inplacemodificationWordWithVariable("P8ZP_SCRATCH_W1", target.datatype, operator, regName(value), value.datatype, block)
+                                        asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
+                                    }
+                                }
+
+                                SourceStorageKind.MEMORY -> {
+                                    asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
+                                    inplacemodificationWordWithMemread("P8ZP_SCRATCH_W1", target.datatype, operator, value.memory!!)
+                                    asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
+                                }
+
+                                SourceStorageKind.ARRAY -> {
+                                    asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
+                                    inplacemodificationWordWithValue("P8ZP_SCRATCH_W1", target.datatype, operator, value.array!!, block)
+                                    asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
+                                }
+
+                                SourceStorageKind.EXPRESSION -> {
+                                    asmgen.out("  sta  P8ZP_SCRATCH_W1 |  stx  P8ZP_SCRATCH_W1+1")
+                                    if(value.expression is PtTypeCast)
+                                        inplacemodificationWordWithValue("P8ZP_SCRATCH_W1", target.datatype, operator, value.expression, block)
+                                    else
+                                        inplacemodificationWordWithValue("P8ZP_SCRATCH_W1", target.datatype, operator, value.expression!!, block)
+                                    asmgen.out("  lda  P8ZP_SCRATCH_W1 |  ldx  P8ZP_SCRATCH_W1+1")
+                                }
                             }
-                            else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
+                            asmgen.restoreRegisterStack(CpuRegister.Y, true)
+                            if(target.array.splitWords)
+                                asmgen.out("  sta  ${target.array.variable.name}_lsb,y |  txa |  sta  ${target.array.variable.name}_msb,y")
+                            else
+                                asmgen.out("  sta  ${target.array.variable.name},y |  txa |  sta  ${target.array.variable.name}+1,y")
                         }
+
+                        DataType.FLOAT -> {
+                            // copy array value into tempvar
+                            val tempvar = asmgen.getTempVarName(DataType.FLOAT)
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array, DataType.FLOAT, CpuRegister.A)
+                            asmgen.out("""
+                                                ldy  #>${target.asmVarname}
+                                                clc
+                                                adc  #<${target.asmVarname}
+                                                bcc  +
+                                                iny
+            +                                   sta  P8ZP_SCRATCH_W1
+                                                sty  P8ZP_SCRATCH_W1+1
+                                                pha  ; save array ptr lsb
+                                                tya
+                                                pha  ; save array ptr msb
+                                                lda  #<$tempvar
+                                                ldy  #>$tempvar
+                                                jsr  floats.copy_float""")
+
+                            // calculate on tempvar
+                            when(value.kind) {
+                                SourceStorageKind.LITERALNUMBER -> inplacemodificationFloatWithLiteralval(tempvar, operator, value.number!!.number)
+                                SourceStorageKind.VARIABLE -> inplacemodificationFloatWithVariable(tempvar, operator, value.asmVarname)
+                                SourceStorageKind.REGISTER -> inplacemodificationFloatWithVariable(tempvar, operator, regName(value))
+                                SourceStorageKind.MEMORY -> TODO("memread into float")
+                                SourceStorageKind.ARRAY -> inplacemodificationFloatWithValue(tempvar, operator, value.array!!)
+                                SourceStorageKind.EXPRESSION -> {
+                                    if(value.expression is PtTypeCast) {
+                                        if (tryInplaceModifyWithRemovedRedundantCast(value.expression, target, operator))
+                                            return
+                                        inplacemodificationFloatWithValue(tempvar, operator, value.expression)
+                                    } else {
+                                        inplacemodificationFloatWithValue(tempvar, operator, value.expression!!)
+                                    }
+                                }
+                            }
+
+                            // copy tempvar back into array
+                            asmgen.out("""
+                                                lda  #<$tempvar
+                                                ldy  #>$tempvar
+                                                sta  P8ZP_SCRATCH_W1
+                                                sty  P8ZP_SCRATCH_W1+1
+                                                pla  ; restore array ptr msb
+                                                tay
+                                                pla  ; restore array ptr lsb
+                                                jsr  floats.copy_float""")
+                        }
+
+                        else -> throw AssemblyError("weird type to do in-place modification on ${target.datatype}")
                     }
-                    else -> throw AssemblyError("indexer expression should have been replaced by auto indexer var")
                 }
             }
             TargetStorageKind.REGISTER -> throw AssemblyError("no asm gen for reg in-place modification")
@@ -442,7 +457,6 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
     }
 
     private fun inplacemodificationRegisterAXwithVariable(operator: String, variable: String, varDt: DataType): Boolean {
-        // note: we only optimize addition and subtraction, and these are the same for unsigned or signed.
         when(operator) {
             "+" -> {
                 return if(varDt in WordDatatypes) {
@@ -492,12 +506,44 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     true
                 }
             }
-            else -> return false        // TODO optimize more operators, such as the bitwise logical ones? Might need to know if signed
+            "|" -> {
+                asmgen.out("""
+                    ora  $variable
+                    tay
+                    txa
+                    ora  $variable+1
+                    tax
+                    tya
+                """)
+                return true
+            }
+            "&" -> {
+                asmgen.out("""
+                    and  $variable
+                    tay
+                    txa
+                    and  $variable+1
+                    tax
+                    tya
+                """)
+                return true
+            }
+            "^" -> {
+                asmgen.out("""
+                    eor  $variable
+                    tay
+                    txa
+                    eor  $variable+1
+                    tax
+                    tya
+                """)
+                return true
+            }
+            else -> return false
         }
     }
 
     private fun inplacemodificationRegisterAXwithLiteralval(operator: String, number: Int): Boolean {
-        // note: we only optimize addition and subtraction, and these are the same for unsigned or signed.
         when(operator) {
             "+" -> {
                 return if(number in -128..255) {
@@ -541,7 +587,40 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     true
                 }
             }
-            else -> return false        // TODO optimize more operators, such as the bitwise logical ones? Might need to know if signed
+            "|" -> {
+                asmgen.out("""
+                    ora  #<$number
+                    tay
+                    txa
+                    ora  #>$number
+                    tax
+                    tya
+                """)
+                return true
+            }
+            "&" -> {
+                asmgen.out("""
+                    and  #<$number
+                    tay
+                    txa
+                    and  #>$number
+                    tax
+                    tya
+                """)
+                return true
+            }
+            "^" -> {
+                asmgen.out("""
+                    eor  #<$number
+                    tay
+                    txa
+                    eor  #>$number
+                    tax
+                    tya
+                """)
+                return true
+            }
+            else -> return false
         }
     }
 
@@ -915,8 +994,9 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
             "<<" -> {
                 asmgen.out("""
                     tay
-                    beq  +
                     lda  $variable
+                    cpy  #0
+                    beq  +
 -                   asl  a
                     dey
                     bne  -
@@ -926,8 +1006,9 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                 if(!signed) {
                     asmgen.out("""
                         tay
-                        beq  +
                         lda  $variable
+                        cpy  #0
+                        beq  +
 -                       lsr  a
                         dey
                         bne  -
@@ -935,8 +1016,9 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                 } else {
                     asmgen.out("""
                         tay
-                        beq  +
                         lda  $variable
+                        cpy  #0
+                        beq  +
                         sta  P8ZP_SCRATCH_B1
 -                       asl  a
                         ror  P8ZP_SCRATCH_B1
@@ -1110,8 +1192,8 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     }
                 }
             }
-            "&" -> asmgen.out(" lda  $name |  and  #$value |  sta  $name")
-            "|" -> asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
+            "&" -> immediateAndInplace(name, value)
+            "|" -> immediateOrInplace(name, value)
             "^" -> asmgen.out(" lda  $name |  eor  #$value |  sta  $name")
             "==" -> {
                 asmgen.out("""
@@ -1232,6 +1314,22 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
         }
     }
 
+    private fun immediateAndInplace(name: String, value: Int) {
+        if(asmgen.isTargetCpu(CpuType.CPU65c02)) {
+            asmgen.out(" lda  #${value xor 255} |  trb  $name")     // reset bit
+        } else  {
+            asmgen.out(" lda  $name |  and  #$value |  sta  $name")
+        }
+    }
+
+    private fun immediateOrInplace(name: String, value: Int) {
+        if(asmgen.isTargetCpu(CpuType.CPU65c02) && ((value and (value-1))==0)) {
+            asmgen.out(" lda  #$value |  tsb  $name")       // set bit
+        } else  {
+            asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
+        }
+    }
+
     private fun inplacemodificationWordWithMemread(name: String, dt: DataType, operator: String, memread: PtMemoryByte) {
         when (operator) {
             "+" -> {
@@ -1277,12 +1375,12 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                 asmgen.out("  eor  $name  |  sta  $name")
             }
             else -> {
-                inplacemodificationWordWithValue(name, dt, operator, memread)
+                inplacemodificationWordWithValue(name, dt, operator, memread, memread.definingBlock())
             }
         }
     }
 
-    private fun inplacemodificationWordWithLiteralval(name: String, dt: DataType, operator: String, value: Int) {
+    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.
         when (operator) {
             "+" -> {
@@ -1342,16 +1440,31 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                 if(value in asmgen.optimizedWordMultiplications) {
                     asmgen.out("  lda  $name |  ldy  $name+1 |  jsr  math.mul_word_$value |  sta  $name |  sty  $name+1")
                 } else {
-                    asmgen.out("""
-                        lda  $name
-                        sta  math.multiply_words.multiplier
-                        lda  $name+1
-                        sta  math.multiply_words.multiplier+1
-                        lda  #<$value
-                        ldy  #>$value
-                        jsr  math.multiply_words
-                        sta  $name
-                        sty  $name+1""")
+                    if(block?.veraFxMuls==true)
+                        // cx16 verafx hardware mul
+                        asmgen.out("""
+                            lda  $name
+                            ldy  $name+1
+                            sta  cx16.r0
+                            sty  cx16.r0+1
+                            lda  #<$value
+                            ldy  #>$value
+                            sta  cx16.r1
+                            sty  cx16.r1+1
+                            jsr  verafx.muls
+                            sta  $name
+                            sty  $name+1""")
+                    else
+                        asmgen.out("""
+                            lda  $name
+                            sta  math.multiply_words.multiplier
+                            lda  $name+1
+                            sta  math.multiply_words.multiplier+1
+                            lda  #<$value
+                            ldy  #>$value
+                            jsr  math.multiply_words
+                            sta  $name
+                            sty  $name+1""")
                 }
             }
             "/" -> {
@@ -1514,7 +1627,7 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                         asmgen.out("  lda  $name+1 |  and  #>$value |  sta  $name+1")
                     }
                     value < 0x0100 -> {
-                        asmgen.out("  lda  $name |  and  #$value |  sta  $name")
+                        immediateAndInplace(name, value)
                         if(asmgen.isTargetCpu(CpuType.CPU65c02))
                             asmgen.out("  stz  $name+1")
                         else
@@ -1527,7 +1640,7 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                 when {
                     value == 0 -> {}
                     value and 255 == 0 -> asmgen.out("  lda  $name+1 |  ora  #>$value |  sta  $name+1")
-                    value < 0x0100 -> asmgen.out("  lda  $name |  ora  #$value |  sta  $name")
+                    value < 0x0100 -> immediateOrInplace(name, value)
                     else -> asmgen.out("  lda  $name |  ora  #<$value |  sta  $name |  lda  $name+1 |  ora  #>$value |  sta  $name+1")
                 }
             }
@@ -1741,7 +1854,7 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
         }
     }
 
-    private fun inplacemodificationWordWithVariable(name: String, dt: DataType, operator: String, otherName: String, valueDt: DataType) {
+    private fun inplacemodificationWordWithVariable(name: String, dt: DataType, operator: String, otherName: String, valueDt: DataType, block: PtBlock?) {
         when (valueDt) {
             in ByteDatatypes -> {
                 // the other variable is a BYTE type so optimize for that
@@ -1794,23 +1907,46 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                                 sta  $name+1""")
                     }
                     "*" -> {
-                        if(valueDt==DataType.UBYTE) {
-                            asmgen.out("  lda  $otherName |  sta  math.multiply_words.multiplier")
-                            if(asmgen.isTargetCpu(CpuType.CPU65c02))
-                                asmgen.out("  stz  math.multiply_words.multiplier+1")
-                            else
-                                asmgen.out("  lda  #0 |  sta  math.multiply_words.multiplier+1")
-                        } else {
-                            asmgen.out("  lda  $otherName")
-                            asmgen.signExtendAYlsb(valueDt)
-                            asmgen.out("  sta  math.multiply_words.multiplier |  sty  math.multiply_words.multiplier+1")
-                        }
-                        asmgen.out("""
+                        if(block?.veraFxMuls==true) {
+                            // cx16 verafx hardware muls
+                            if(valueDt==DataType.UBYTE) {
+                                asmgen.out("  lda  $otherName |  sta  cx16.r1")
+                                if(asmgen.isTargetCpu(CpuType.CPU65c02))
+                                    asmgen.out("  stz  cx16.r1+1")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  cx16.r1+1")
+                            } else {
+                                asmgen.out("  lda  $otherName")
+                                asmgen.signExtendAYlsb(valueDt)
+                                asmgen.out("  sta  cx16.r1 |  sty  cx16.r1+1")
+                            }
+                            asmgen.out("""
                                 lda  $name
                                 ldy  $name+1
-                                jsr  math.multiply_words
+                                sta  cx16.r0
+                                sty  cx16.r0+1
+                                jsr  verafx.muls
                                 sta  $name
                                 sty  $name+1""")
+                        } else {
+                            if(valueDt==DataType.UBYTE) {
+                                asmgen.out("  lda  $otherName |  sta  math.multiply_words.multiplier")
+                                if(asmgen.isTargetCpu(CpuType.CPU65c02))
+                                    asmgen.out("  stz  math.multiply_words.multiplier+1")
+                                else
+                                    asmgen.out("  lda  #0 |  sta  math.multiply_words.multiplier+1")
+                            } else {
+                                asmgen.out("  lda  $otherName")
+                                asmgen.signExtendAYlsb(valueDt)
+                                asmgen.out("  sta  math.multiply_words.multiplier |  sty  math.multiply_words.multiplier+1")
+                            }
+                            asmgen.out("""
+                                    lda  $name
+                                    ldy  $name+1
+                                    jsr  math.multiply_words
+                                    sta  $name
+                                    sty  $name+1""")
+                        }
                     }
                     "/" -> {
                         if(dt==DataType.UWORD) {
@@ -1858,12 +1994,12 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     }
                     "<<" -> {
                         asmgen.out("""
-                        ldy  $otherName
-                        beq  +
--                       asl  $name
-                        rol  $name+1
-                        dey
-                        bne  -
+                            ldy  $otherName
+                            beq  +
+-                           asl  $name
+                            rol  $name+1
+                            dey
+                            bne  -
 +""")
                     }
                     ">>" -> {
@@ -1939,16 +2075,31 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
                     "+" -> asmgen.out("  lda  $name |  clc |  adc  $otherName |  sta  $name |  lda  $name+1 |  adc  $otherName+1 |  sta  $name+1")
                     "-" -> asmgen.out("  lda  $name |  sec |  sbc  $otherName |  sta  $name |  lda  $name+1 |  sbc  $otherName+1 |  sta  $name+1")
                     "*" -> {
-                        asmgen.out("""
-                            lda  $otherName
-                            ldy  $otherName+1
-                            sta  math.multiply_words.multiplier
-                            sty  math.multiply_words.multiplier+1
-                            lda  $name
-                            ldy  $name+1
-                            jsr  math.multiply_words
-                            sta  $name
-                            sty  $name+1""")
+                        if(block?.veraFxMuls==true)
+                            // cx16 verafx hardware muls
+                            asmgen.out("""
+                                lda  $name
+                                ldy  $name+1
+                                sta  cx16.r0
+                                sty  cx16.r0+1
+                                lda  $otherName
+                                ldy  $otherName+1
+                                sta  cx16.r1
+                                sty  cx16.r1+1
+                                jsr  verafx.muls
+                                sta  $name
+                                sty  $name+1""")
+                        else
+                            asmgen.out("""
+                                lda  $otherName
+                                ldy  $otherName+1
+                                sta  math.multiply_words.multiplier
+                                sty  math.multiply_words.multiplier+1
+                                lda  $name
+                                ldy  $name+1
+                                jsr  math.multiply_words
+                                sta  $name
+                                sty  $name+1""")
                     }
                     "/" -> {
                         if(dt==DataType.WORD) {
@@ -2126,17 +2277,31 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
         }
     }
 
-    private fun inplacemodificationWordWithValue(name: String, dt: DataType, operator: String, value: PtExpression) {
+    private fun inplacemodificationWordWithValue(name: String, dt: DataType, operator: String, value: PtExpression, block: PtBlock?) {
         fun multiplyVarByWordInAY() {
-            asmgen.out("""
-                sta  math.multiply_words.multiplier
-                sty  math.multiply_words.multiplier+1
-                lda  $name
-                ldy  $name+1
-                jsr  math.multiply_words
-                sta  $name
-                sty  $name+1
-            """)
+            if(block?.veraFxMuls==true)
+                // cx16 verafx hardware muls
+                asmgen.out("""
+                    sta  cx16.r1
+                    sty  cx16.r1+1
+                    lda  $name
+                    ldy  $name+1
+                    sta  cx16.r0
+                    sty  cx16.r0+1
+                    jsr  verafx.muls
+                    sta  $name
+                    sty  $name+1
+                """)
+            else
+                asmgen.out("""
+                    sta  math.multiply_words.multiplier
+                    sty  math.multiply_words.multiplier+1
+                    lda  $name
+                    ldy  $name+1
+                    jsr  math.multiply_words
+                    sta  $name
+                    sty  $name+1
+                """)
         }
 
         fun divideVarByWordInAY() {
@@ -2579,16 +2744,23 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
         val constValueName = allocator.getFloatAsmConst(value)
         when (operator) {
             "+" -> {
-                if (value == 0.0)
-                    return
-                asmgen.out("""
-                    lda  #<$name
-                    ldy  #>$name
-                    jsr  floats.MOVFM
-                    lda  #<$constValueName
-                    ldy  #>$constValueName
-                    jsr  floats.FADD
-                """)
+                when (value) {
+                    0.0 -> return
+                    0.5 -> asmgen.out("""
+                        lda  #<$name
+                        ldy  #>$name
+                        jsr  floats.MOVFM
+                        jsr  floats.FADDH
+                    """)
+                    else -> asmgen.out("""
+                        lda  #<$name
+                        ldy  #>$name
+                        jsr  floats.MOVFM
+                        lda  #<$constValueName
+                        ldy  #>$constValueName
+                        jsr  floats.FADD
+                    """)
+                }
             }
             "-" -> {
                 if (value == 0.0)
@@ -2604,14 +2776,23 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
             }
             "*" -> {
                 // assume that code optimization is already done on the AST level for special cases such as 0, 1, 2...
-                asmgen.out("""
-                    lda  #<$name
-                    ldy  #>$name
-                    jsr  floats.MOVFM
-                    lda  #<$constValueName
-                    ldy  #>$constValueName
-                    jsr  floats.FMULT
-                """)
+                if(value==10.0) {
+                    asmgen.out("""
+                        lda  #<$name
+                        ldy  #>$name
+                        jsr  floats.MOVFM
+                        jsr  floats.MUL10
+                    """)
+                } else {
+                    asmgen.out("""
+                        lda  #<$name
+                        ldy  #>$name
+                        jsr  floats.MOVFM
+                        lda  #<$constValueName
+                        ldy  #>$constValueName
+                        jsr  floats.FMULT
+                    """)
+                }
             }
             "/" -> {
                 if (value == 0.0)

codeGenCpu6502/test/Dummies.kt

@@ -18,6 +18,8 @@ internal object DummyMemsizer : IMemSizer {
 }
 
 internal object DummyStringEncoder : IStringEncoding {
+    override val defaultEncoding: Encoding = Encoding.ISO
+
     override fun encodeString(str: String, encoding: Encoding): List<UByte> {
         return emptyList()
     }

codeGenCpu6502/test/TestCodegen.kt

@@ -22,6 +22,7 @@ class TestCodegen: FunSpec({
             CbmPrgLauncherType.NONE,
             ZeropageType.DONTUSE,
             zpReserved = emptyList(),
+            zpAllowed = CompilationOptions.AllZeropageAllowed,
             floats = true,
             noSysInit = false,
             compTarget = target,
@@ -44,7 +45,7 @@ class TestCodegen: FunSpec({
 //}
         val codegen = AsmGen6502(prefixSymbols = false)
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("pi", DataType.UBYTE, ZeropageWish.DONTCARE, PtNumber(DataType.UBYTE, 0.0, Position.DUMMY), null, Position.DUMMY))
         sub.add(PtVariable("particleX", DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, 3u, Position.DUMMY))
@@ -94,7 +95,7 @@ class TestCodegen: FunSpec({
         program.add(block)
 
         // define the "cx16.r0" virtual register
-        val cx16block = PtBlock("cx16", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val cx16block = PtBlock("cx16", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         cx16block.add(PtMemMapped("r0", DataType.UWORD, 100u, null, Position.DUMMY))
         program.add(cx16block)
 

codeGenExperimental/build.gradle

@@ -36,10 +36,10 @@ dependencies {
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
 }

codeGenIntermediate/build.gradle

@@ -30,16 +30,16 @@ dependencies {
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
     implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.6.2'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
 }
 
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
     test {

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

@@ -29,17 +29,21 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             "msb" -> funcMsb(call)
             "lsb" -> funcLsb(call)
             "memory" -> funcMemory(call)
-            "peek" -> funcPeek(call)
-            "peekw" -> funcPeekW(call)
-            "poke" -> funcPoke(call)
-            "pokew" -> funcPokeW(call)
-            "pokemon" -> ExpressionCodeResult.EMPTY     // easter egg function
+            "peek" -> funcPeek(call, IRDataType.BYTE)
+            "peekw" -> funcPeek(call, IRDataType.WORD)
+            "peekf" -> funcPeek(call, IRDataType.FLOAT)
+            "poke" -> funcPoke(call, IRDataType.BYTE)
+            "pokew" -> funcPoke(call, IRDataType.WORD)
+            "pokef" -> funcPoke(call, IRDataType.FLOAT)
+            "pokemon" -> funcPokemon(call)
             "mkword" -> funcMkword(call)
             "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(Opcode.ROXL, call)
             "ror" -> funcRolRor(Opcode.ROXR, call)
             "rol2" -> funcRolRor(Opcode.ROL, call)
@@ -69,6 +73,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
     private fun funcCallfar(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
         val bankTr = exprGen.translateExpression(call.args[0])
         val addressTr = exprGen.translateExpression(call.args[1])
         val argumentwordTr = exprGen.translateExpression(call.args[2])
@@ -110,6 +115,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
     private fun funcStringCompare(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
         val left  = exprGen.translateExpression(call.args[0])
         val right = exprGen.translateExpression(call.args[1])
         addToResult(result, left, left.resultReg, -1)
@@ -144,6 +150,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type")
             }
         val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
         val tr = exprGen.translateExpression(call.args[0])
         addToResult(result, tr, tr.resultReg, -1)
         val lengthReg = codeGen.registers.nextFree()
@@ -165,6 +172,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type")
             }
         val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
         val tr = exprGen.translateExpression(call.args[0])
         addToResult(result, tr, tr.resultReg, -1)
         val lengthReg = codeGen.registers.nextFree()
@@ -308,6 +316,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type to reverse")
             }
         val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
         val tr = exprGen.translateExpression(call.args[0])
         addToResult(result, tr, tr.resultReg, -1)
         val lengthReg = codeGen.registers.nextFree()
@@ -331,6 +340,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type to sort")
             }
         val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
         val tr = exprGen.translateExpression(call.args[0])
         addToResult(result, tr, tr.resultReg, -1)
         val lengthReg = codeGen.registers.nextFree()
@@ -341,19 +351,25 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
     private fun funcMkword(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        val msbTr = exprGen.translateExpression(call.args[0])
-        addToResult(result, msbTr, msbTr.resultReg, -1)
-        val lsbTr = exprGen.translateExpression(call.args[1])
-        addToResult(result, lsbTr, lsbTr.resultReg, -1)
         val resultReg = codeGen.registers.nextFree()
-        result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=resultReg, reg2 = lsbTr.resultReg, reg3 = msbTr.resultReg)
+        if((call.args[0] as? PtNumber)?.number == 0.0) {
+            // msb is 0, use EXT
+            val lsbTr = exprGen.translateExpression(call.args[1])
+            addToResult(result, lsbTr, lsbTr.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=resultReg, reg2 = lsbTr.resultReg), null)
+        } else {
+            val msbTr = exprGen.translateExpression(call.args[0])
+            addToResult(result, msbTr, msbTr.resultReg, -1)
+            val lsbTr = exprGen.translateExpression(call.args[1])
+            addToResult(result, lsbTr, lsbTr.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=resultReg, reg2 = msbTr.resultReg, reg3 = lsbTr.resultReg), null)
         }
         return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
     }
 
     private fun funcClamp(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
         val type = irType(call.type)
         val valueTr = exprGen.translateExpression(call.args[0])
         val minimumTr = exprGen.translateExpression(call.args[1])
@@ -426,118 +442,148 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, type, leftTr.resultReg, -1)
     }
 
-    private fun funcPokeW(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcPoke(call: PtBuiltinFunctionCall, dt: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         if(codeGen.isZero(call.args[1])) {
             if (call.args[0] is PtNumber) {
                 val address = (call.args[0] as PtNumber).number.toInt()
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZM, IRDataType.WORD, address = address)
+                    it += IRInstruction(Opcode.STOREZM, dt, address = address)
                 }
             } else {
                 val tr = exprGen.translateExpression(call.args[0])
                 addToResult(result, tr, tr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZI, IRDataType.WORD, reg1 = tr.resultReg)
+                    it += IRInstruction(Opcode.STOREZI, dt, reg1 = tr.resultReg)
                 }
             }
         } else {
             if (call.args[0] is PtNumber) {
                 val address = (call.args[0] as PtNumber).number.toInt()
                 val tr = exprGen.translateExpression(call.args[1])
-                addToResult(result, tr, tr.resultReg, -1)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREM, IRDataType.WORD, reg1 = tr.resultReg, address = address)
+                if(dt==IRDataType.FLOAT) {
+                    addToResult(result, tr, -1, tr.resultFpReg)
+                    result += IRCodeChunk(null, null).also {
+                        it += IRInstruction(Opcode.STOREM, dt, fpReg1 = tr.resultFpReg, address = address)
+                    }
+                } else {
+                    addToResult(result, tr, tr.resultReg, -1)
+                    result += IRCodeChunk(null, null).also {
+                        it += IRInstruction(Opcode.STOREM, dt, reg1 = tr.resultReg, address = address)
+                    }
                 }
             } else {
                 val addressTr = exprGen.translateExpression(call.args[0])
                 addToResult(result, addressTr, addressTr.resultReg, -1)
                 val valueTr = exprGen.translateExpression(call.args[1])
-                addToResult(result, valueTr, valueTr.resultReg, -1)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREI, IRDataType.WORD, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
+                if(dt==IRDataType.FLOAT) {
+                    addToResult(result, valueTr, -1, valueTr.resultFpReg)
+                    result += IRCodeChunk(null, null).also {
+                        it += IRInstruction(Opcode.STOREI, IRDataType.FLOAT, reg1 = addressTr.resultReg, fpReg1 = valueTr.resultFpReg)
+                    }
+                } else {
+                    addToResult(result, valueTr, valueTr.resultReg, -1)
+                    result += IRCodeChunk(null, null).also {
+                        it += IRInstruction(Opcode.STOREI, dt, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
+                    }
                 }
             }
         }
         return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcPoke(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcPeek(call: PtBuiltinFunctionCall, dt: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        if(codeGen.isZero(call.args[1])) {
-            if (call.args[0] is PtNumber) {
+        return if(dt==IRDataType.FLOAT) {
+            if(call.args[0] is PtNumber) {
+                val resultFpRegister = codeGen.registers.nextFreeFloat()
                 val address = (call.args[0] as PtNumber).number.toInt()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = resultFpRegister, address = address)
+                }
+                ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpRegister)
+            } else {
+                val tr = exprGen.translateExpression(call.args.single())
+                addToResult(result, tr, tr.resultReg, -1)
+                val resultFpReg = codeGen.registers.nextFreeFloat()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADI, IRDataType.FLOAT, reg1 = tr.resultReg, fpReg1 = resultFpReg)
+                }
+                ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpReg)
+            }
+        } else {
+            if (call.args[0] is PtNumber) {
+                val resultRegister = codeGen.registers.nextFree()
+                val address = (call.args[0] as PtNumber).number.toInt()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADM, dt, reg1 = resultRegister, address = address)
+                }
+                ExpressionCodeResult(result, dt, resultRegister, -1)
+            } else {
+                val tr = exprGen.translateExpression(call.args.single())
+                addToResult(result, tr, tr.resultReg, -1)
+                val resultReg = codeGen.registers.nextFree()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADI, dt, reg1 = resultReg, reg2 = tr.resultReg)
+                }
+                ExpressionCodeResult(result, dt, resultReg, -1)
+            }
+        }
+    }
+
+    private fun funcPokemon(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val address = call.args[0]
+
+        fun pokeM(result: MutableList<IRCodeChunkBase>, address: Int, value: PtExpression) {
+            if(codeGen.isZero(value)) {
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.STOREZM, IRDataType.BYTE, address = address)
                 }
             } else {
-                val tr = exprGen.translateExpression(call.args[0])
-                addToResult(result, tr, tr.resultReg, -1)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = tr.resultReg)
-                }
-            }
-        } else {
-            if (call.args[0] is PtNumber) {
-                val address = (call.args[0] as PtNumber).number.toInt()
-                val tr = exprGen.translateExpression(call.args[1])
+                val tr = exprGen.translateExpression(value)
                 addToResult(result, tr, tr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = tr.resultReg, address = address)
                 }
+            }
+        }
+
+        fun pokeI(result: MutableList<IRCodeChunkBase>, register: Int, value: PtExpression) {
+            if(codeGen.isZero(value)) {
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = register)
+                }
             } else {
-                val addressTr = exprGen.translateExpression(call.args[0])
-                addToResult(result, addressTr, addressTr.resultReg, -1)
-                val valueTr = exprGen.translateExpression(call.args[1])
+                val valueTr = exprGen.translateExpression(value)
                 addToResult(result, valueTr, valueTr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
+                    it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = register)
                 }
             }
         }
-        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
-    }
 
-    private fun funcPeekW(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val result = mutableListOf<IRCodeChunkBase>()
-        return if(call.args[0] is PtNumber) {
+        return if(address is PtNumber) {
             val resultRegister = codeGen.registers.nextFree()
-            val address = (call.args[0] as PtNumber).number.toInt()
+            val addressNum = address.number.toInt()
             result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADM, IRDataType.WORD, reg1 = resultRegister, address = address)
+                it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1 = resultRegister, address = addressNum)
             }
+            pokeM(result, addressNum, call.args[1])
             ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
         } else {
-            val tr = exprGen.translateExpression(call.args.single())
-            addToResult(result, tr, tr.resultReg, -1)
+            val addressTr = exprGen.translateExpression(address)
+            addToResult(result, addressTr, addressTr.resultReg, -1)
             val resultReg = codeGen.registers.nextFree()
             result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADI, IRDataType.WORD, reg1 = resultReg, reg2 = tr.resultReg)
-            }
-            ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
-        }
-    }
-
-    private fun funcPeek(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val result = mutableListOf<IRCodeChunkBase>()
-        return if(call.args[0] is PtNumber) {
-            val resultRegister = codeGen.registers.nextFree()
-            val address = (call.args[0] as PtNumber).number.toInt()
-            result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1 = resultRegister, address = address)
-            }
-            ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
-        } else {
-            val tr = exprGen.translateExpression(call.args.single())
-            addToResult(result, tr, tr.resultReg, -1)
-            val resultReg = codeGen.registers.nextFree()
-            result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADI, IRDataType.BYTE, reg1 = resultReg, reg2 = tr.resultReg)
+                it += IRInstruction(Opcode.LOADI, IRDataType.BYTE, reg1 = resultReg, reg2 = addressTr.resultReg)
             }
+            pokeI(result, addressTr.resultReg, call.args[1])
             ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
         }
     }
 
+
     private fun funcMemory(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val name = (call.args[0] as PtString).value
         val code = IRCodeChunk(null, null)
@@ -576,6 +622,122 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return ExpressionCodeResult(result, vmDt, -1, -1)
     }
 
+    private fun funcSetLsbMsb(call: PtBuiltinFunctionCall, msb: Boolean): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val target = call.args[0]
+        val isConstZeroValue = call.args[1].asConstInteger()==0
+        when(target) {
+            is PtIdentifier -> {
+                if(isConstZeroValue) {
+                    result += IRCodeChunk(null, null).also {
+                        val pointerReg = codeGen.registers.nextFree()
+                        it += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1 = pointerReg, labelSymbol = target.name)
+                        if (msb)
+                            it += IRInstruction(Opcode.INC, IRDataType.WORD, reg1 = pointerReg)
+                        it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = pointerReg)
+                    }
+                } else {
+                    val valueTr = exprGen.translateExpression(call.args[1])
+                    addToResult(result, valueTr, valueTr.resultReg, -1)
+                    result += IRCodeChunk(null, null).also {
+                        val pointerReg = codeGen.registers.nextFree()
+                        it += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1 = pointerReg, labelSymbol = target.name)
+                        if (msb)
+                            it += IRInstruction(Opcode.INC, IRDataType.WORD, reg1 = pointerReg)
+                        it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = pointerReg)
+                    }
+                }
+            }
+            is PtArrayIndexer -> {
+                require(!target.usesPointerVariable)
+                if(target.splitWords) {
+                    // lsb/msb in split arrays, element index 'size' is always 1
+                    val constIndex = target.index.asConstInteger()
+                    val varName = target.variable.name + if(msb) "_msb" else "_lsb"
+                    if(isConstZeroValue) {
+                        if(constIndex!=null) {
+                            val offsetReg = codeGen.registers.nextFree()
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=offsetReg, immediate = constIndex)
+                                it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1=offsetReg, labelSymbol = varName)
+                            }
+                        } else {
+                            val indexTr = exprGen.translateExpression(target.index)
+                            addToResult(result, indexTr, indexTr.resultReg, -1)
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1=indexTr.resultReg, labelSymbol = varName)
+                            }
+                        }
+                    } else {
+                        val valueTr = exprGen.translateExpression(call.args[1])
+                        addToResult(result, valueTr, valueTr.resultReg, -1)
+                        if(constIndex!=null) {
+                            val offsetReg = codeGen.registers.nextFree()
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=offsetReg, immediate = constIndex)
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1=valueTr.resultReg, reg2=offsetReg, labelSymbol = varName)
+                            }
+                        } else {
+                            val indexTr = exprGen.translateExpression(target.index)
+                            addToResult(result, indexTr, indexTr.resultReg, -1)
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1=valueTr.resultReg, reg2=indexTr.resultReg, labelSymbol = varName)
+                            }
+                        }
+                    }
+                }
+                else {
+                    val eltSize = codeGen.program.memsizer.memorySize(target.type)
+                    val constIndex = target.index.asConstInteger()
+                    if(isConstZeroValue) {
+                        if(constIndex!=null) {
+                            val offsetReg = codeGen.registers.nextFree()
+                            val offset = eltSize*constIndex + if(msb) 1 else 0
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=offsetReg, immediate = offset)
+                                it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1=offsetReg, labelSymbol = target.variable.name)
+                            }
+                        } else {
+                            val indexTr = exprGen.translateExpression(target.index)
+                            addToResult(result, indexTr, indexTr.resultReg, -1)
+                            result += IRCodeChunk(null, null).also {
+                                if(eltSize>1)
+                                    it += codeGen.multiplyByConst(IRDataType.BYTE, indexTr.resultReg, eltSize)
+                                if(msb)
+                                    it += IRInstruction(Opcode.INC, IRDataType.BYTE, reg1=indexTr.resultReg)
+                                it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1=indexTr.resultReg, labelSymbol = target.variable.name)
+                            }
+                        }
+                    } else {
+                        val valueTr = exprGen.translateExpression(call.args[1])
+                        addToResult(result, valueTr, valueTr.resultReg, -1)
+                        if(constIndex!=null) {
+                            val offsetReg = codeGen.registers.nextFree()
+                            val offset = eltSize*constIndex + if(msb) 1 else 0
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=offsetReg, immediate = offset)
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1=valueTr.resultReg, reg2=offsetReg, labelSymbol = target.variable.name)
+                            }
+                        } else {
+                            val indexTr = exprGen.translateExpression(target.index)
+                            addToResult(result, indexTr, indexTr.resultReg, -1)
+                            result += IRCodeChunk(null, null).also {
+                                if(eltSize>1)
+                                    it += codeGen.multiplyByConst(IRDataType.BYTE, indexTr.resultReg, eltSize)
+                                if(msb)
+                                    it += IRInstruction(Opcode.INC, IRDataType.BYTE, reg1=indexTr.resultReg)
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1=valueTr.resultReg, reg2=indexTr.resultReg, labelSymbol = target.variable.name)
+                            }
+                        }
+                    }
+                }
+            }
+            else -> throw AssemblyError("weird target for setlsb/setmsb: $target")
+        }
+        return ExpressionCodeResult(result, IRDataType.WORD, -1, -1)
+    }
+
+
     private fun assignRegisterTo(target: PtExpression, register: Int): IRCodeChunks {
         val assignment = PtAssignment(target.position)
         val assignTarget = PtAssignTarget(target.position)

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

@@ -3,10 +3,7 @@ package prog8.codegen.intermediate
 import prog8.code.StRomSub
 import prog8.code.StSub
 import prog8.code.ast.*
-import prog8.code.core.AssemblyError
-import prog8.code.core.DataType
-import prog8.code.core.PassByValueDatatypes
-import prog8.code.core.SignedDatatypes
+import prog8.code.core.*
 import prog8.intermediate.*
 
 internal class ExpressionCodeResult(val chunks: IRCodeChunks, val dt: IRDataType, val resultReg: Int, val resultFpReg: Int) {
@@ -20,6 +17,8 @@ internal class ExpressionCodeResult(val chunks: IRCodeChunks, val dt: IRDataType
         if(resultReg!=-1) require(resultFpReg==-1)
         if(resultFpReg!=-1) require(resultReg==-1)
     }
+
+    fun lastInstruction() = chunks.last().instructions.last()
 }
 
 internal class ExpressionGen(private val codeGen: IRCodeGen) {
@@ -34,7 +33,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val code = IRCodeChunk(null, null)
                 if(vmDt==IRDataType.FLOAT) {
                     val resultFpRegister = codeGen.registers.nextFreeFloat()
-                    code += IRInstruction(Opcode.LOAD, vmDt, fpReg1 = resultFpRegister, immediateFp = expr.number.toFloat())
+                    code += IRInstruction(Opcode.LOAD, vmDt, fpReg1 = resultFpRegister, immediateFp = expr.number)
                     ExpressionCodeResult(code, vmDt,-1, resultFpRegister)
                 }
                 else {
@@ -69,10 +68,28 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val vmDt = irType(expr.type)
                 val symbol = expr.identifier.name
                 // note: LOAD <symbol>  gets you the address of the symbol, whereas LOADM <symbol> would get you the value stored at that location
-                val code = IRCodeChunk(null, null)
+                val result = mutableListOf<IRCodeChunkBase>()
                 val resultRegister = codeGen.registers.nextFree()
-                code += IRInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, labelSymbol = symbol)
-                ExpressionCodeResult(code, vmDt, resultRegister, -1)
+                addInstr(result, IRInstruction(Opcode.LOAD, vmDt, reg1 = resultRegister, labelSymbol = symbol), null)
+                if(expr.isFromArrayElement) {
+                    val indexTr = translateExpression(expr.arrayIndexExpr!!)
+                    addToResult(result, indexTr, indexTr.resultReg, -1)
+                    if(expr.identifier.type in SplitWordArrayTypes) {
+                        result += IRCodeChunk(null, null).also {
+                            // multiply indexTr resultreg by the eltSize and add this to the resultRegister.
+                            it += IRInstruction(Opcode.ADDR, IRDataType.BYTE, reg1=resultRegister, reg2=indexTr.resultReg)
+                        }
+                    } else {
+                        val eltSize = codeGen.program.memsizer.memorySize(expr.identifier.type, 1)
+                        result += IRCodeChunk(null, null).also {
+                            // multiply indexTr resultreg by the eltSize and add this to the resultRegister.
+                            if(eltSize>1)
+                                it += IRInstruction(Opcode.MUL, IRDataType.BYTE, reg1=indexTr.resultReg, immediate = eltSize)
+                            it += IRInstruction(Opcode.ADDR, IRDataType.BYTE, reg1=resultRegister, reg2=indexTr.resultReg)
+                        }
+                    }
+                }
+                ExpressionCodeResult(result, vmDt, resultRegister, -1)
             }
             is PtMemoryByte -> {
                 val result = mutableListOf<IRCodeChunkBase>()
@@ -107,6 +124,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val result = mutableListOf<IRCodeChunkBase>()
         when(check.iterable.type) {
             DataType.STR -> {
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
                 val elementTr = translateExpression(check.element)
                 addToResult(result, elementTr, elementTr.resultReg, -1)
                 val iterableTr = translateExpression(check.iterable)
@@ -115,6 +133,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1)
             }
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
                 val elementTr = translateExpression(check.element)
                 addToResult(result, elementTr, elementTr.resultReg, -1)
                 val iterableTr = translateExpression(check.iterable)
@@ -126,6 +145,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1)
             }
             DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
                 val elementTr = translateExpression(check.element)
                 addToResult(result, elementTr, elementTr.resultReg, -1)
                 val iterableTr = translateExpression(check.iterable)
@@ -170,18 +190,18 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val memOffset = (arrayIx.index as PtNumber).number.toInt()
                 result += IRCodeChunk(null, null).also {
                     val tmpRegMsb = codeGen.registers.nextFree()
-                    it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1=resultRegister, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_lsb+$memOffset")
                     it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1=tmpRegMsb, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_msb+$memOffset")
-                    it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=finalResultReg, reg2=resultRegister, reg3=tmpRegMsb)
+                    it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1=resultRegister, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_lsb+$memOffset")
+                    it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=finalResultReg, reg2=tmpRegMsb, reg3=resultRegister)
                 }
             } else {
                 val tr = translateExpression(arrayIx.index)
                 addToResult(result, tr, tr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
                     val tmpRegMsb = codeGen.registers.nextFree()
-                    it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1=resultRegister, reg2 = tr.resultReg, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_lsb")
                     it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1=tmpRegMsb, reg2 = tr.resultReg, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_msb")
-                    it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=finalResultReg, reg2=resultRegister, reg3=tmpRegMsb)
+                    it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1=resultRegister, reg2 = tr.resultReg, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_lsb")
+                    it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=finalResultReg, reg2=tmpRegMsb, reg3=resultRegister)
                 }
             }
             return ExpressionCodeResult(result, vmDt, finalResultReg, -1)
@@ -366,6 +386,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         when (val callTarget = codeGen.symbolTable.flat.getValue(fcall.name)) {
             is StSub -> {
                 val result = mutableListOf<IRCodeChunkBase>()
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = callTarget.parameters.size), null)
                 // assign the arguments
                 val argRegisters = mutableListOf<FunctionCallArgs.ArgumentSpec>()
                 for ((arg, parameter) in fcall.args.zip(callTarget.parameters)) {
@@ -386,8 +407,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                         FunctionCallArgs.RegSpec(returnIrType, codeGen.registers.nextFree(), null)
                 }
                 // create the call
-                val call = IRInstruction(Opcode.CALL, labelSymbol = fcall.name, fcallArgs = FunctionCallArgs(argRegisters, returnRegSpec))
-                addInstr(result, call, null)
+                addInstr(result, IRInstruction(Opcode.CALL, labelSymbol = fcall.name, fcallArgs = FunctionCallArgs(argRegisters, returnRegSpec)), null)
                 return if(fcall.void)
                     ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
                 else if(fcall.type==DataType.FLOAT)
@@ -397,6 +417,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             }
             is StRomSub -> {
                 val result = mutableListOf<IRCodeChunkBase>()
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = callTarget.parameters.size), null)
                 // assign the arguments
                 val argRegisters = mutableListOf<FunctionCallArgs.ArgumentSpec>()
                 for ((arg, parameter) in fcall.args.zip(callTarget.parameters)) {
@@ -543,14 +564,16 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             val resultRegister = codeGen.registers.nextFree()
             val valueReg = codeGen.registers.nextFree()
             val label = codeGen.createLabelName()
-            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=resultRegister, immediate = 1), null)
-            addInstr(result, IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=valueReg, fpReg1 = leftTr.resultFpReg, fpReg2 = rightTr.resultFpReg), null)
-            if (notEquals) {
-                addInstr(result, IRInstruction(Opcode.BNE, IRDataType.BYTE, reg1=valueReg, immediate = 0, labelSymbol = label), null)
-            } else {
-                addInstr(result, IRInstruction(Opcode.BEQ, IRDataType.BYTE, reg1=valueReg, immediate = 0, labelSymbol = label), null)
+            result += IRCodeChunk(null, null).also {
+                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=resultRegister, immediate = 1)
+                it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=valueReg, fpReg1 = leftTr.resultFpReg, fpReg2 = rightTr.resultFpReg)
+                it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=valueReg, immediate = 0)
+                it += if (notEquals)
+                    IRInstruction(Opcode.BSTNE, labelSymbol = label)
+                else
+                    IRInstruction(Opcode.BSTEQ, labelSymbol = label)
+                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=resultRegister, immediate = 0)
             }
-            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=resultRegister, immediate = 0), null)
             result += IRCodeChunk(label, null)
             return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
         } else {
@@ -690,7 +713,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
                 val tr = translateExpression(binExpr.left)
                 addToResult(result, tr, -1, tr.resultFpReg)
-                val factor = constFactorRight.number.toFloat()
+                val factor = constFactorRight.number
                 result += codeGen.divideByConstFloat(tr.resultFpReg, factor)
                 return ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
             } else {
@@ -746,13 +769,13 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             return if(constFactorLeft!=null) {
                 val tr = translateExpression(binExpr.right)
                 addToResult(result, tr, -1, tr.resultFpReg)
-                val factor = constFactorLeft.number.toFloat()
+                val factor = constFactorLeft.number
                 result += codeGen.multiplyByConstFloat(tr.resultFpReg, factor)
                 ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
             } else if(constFactorRight!=null) {
                 val tr = translateExpression(binExpr.left)
                 addToResult(result, tr, -1, tr.resultFpReg)
-                val factor = constFactorRight.number.toFloat()
+                val factor = constFactorRight.number
                 result += codeGen.multiplyByConstFloat(tr.resultFpReg, factor)
                 ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
             } else {
@@ -800,7 +823,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 return if(binExpr.right is PtNumber) {
                     val tr = translateExpression(binExpr.left)
                     addToResult(result, tr, -1, tr.resultFpReg)
-                    addInstr(result, IRInstruction(Opcode.SUB, vmDt, fpReg1 = tr.resultFpReg, immediateFp = (binExpr.right as PtNumber).number.toFloat()), null)
+                    addInstr(result, IRInstruction(Opcode.SUB, vmDt, fpReg1 = tr.resultFpReg, immediateFp = (binExpr.right as PtNumber).number), null)
                     ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
                 } else {
                     val leftTr = translateExpression(binExpr.left)
@@ -855,7 +878,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 return if(binExpr.right is PtNumber) {
                     val tr = translateExpression(binExpr.left)
                     addToResult(result, tr, -1, tr.resultFpReg)
-                    addInstr(result, IRInstruction(Opcode.ADD, vmDt, fpReg1 = tr.resultFpReg, immediateFp = (binExpr.right as PtNumber).number.toFloat()), null)
+                    addInstr(result, IRInstruction(Opcode.ADD, vmDt, fpReg1 = tr.resultFpReg, immediateFp = (binExpr.right as PtNumber).number), null)
                     ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
                 } else {
                     val leftTr = translateExpression(binExpr.left)
@@ -927,7 +950,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val constFactorRight = operand as? PtNumber
         if(vmDt==IRDataType.FLOAT) {
             if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
-                val factor = constFactorRight.number.toFloat()
+                val factor = constFactorRight.number
                 result += codeGen.divideByConstFloatInplace(knownAddress, symbol, factor)
             } else {
                 val tr = translateExpression(operand)
@@ -976,7 +999,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val constFactorRight = operand as? PtNumber
         if(vmDt==IRDataType.FLOAT) {
             if(constFactorRight!=null) {
-                val factor = constFactorRight.number.toFloat()
+                val factor = constFactorRight.number
                 result += codeGen.multiplyByConstFloatInplace(knownAddress, symbol, factor)
             } else {
                 val tr = translateExpression(operand)
@@ -1301,7 +1324,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 // in-place modify a memory location
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = valueReg, address = knownAddress)
-                    it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = numberReg, immediateFp = operand.number.toFloat())
+                    it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = numberReg, immediateFp = operand.number)
                     it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg, fpReg2 = numberReg)
                     it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=zeroReg, immediate = 0)
                     it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpResultReg, reg2=cmpReg, reg3=zeroReg)
@@ -1312,7 +1335,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 // in-place modify a symbol (variable)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = valueReg, labelSymbol = symbol)
-                    it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = numberReg, immediateFp = operand.number.toFloat())
+                    it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = numberReg, immediateFp = operand.number)
                     it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg, fpReg2 = numberReg)
                     it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=zeroReg, immediate = 0)
                     it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpResultReg, reg2=cmpReg, reg3=zeroReg)

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

@@ -283,15 +283,10 @@ class IRCodeGen(
             else -> TODO("missing codegen for $node")
         }
 
-        chunks.forEach { chunk ->
-            require(chunk.isNotEmpty() || chunk.label != null) {
-                "chunk should have instructions and/or a label"
-            }
-        }
+        val nonEmptyChunks = chunks.filter { it.isNotEmpty() || it.label != null }
+        nonEmptyChunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(node.position)
 
-        chunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(node.position)
-
-        return chunks
+        return nonEmptyChunks
     }
 
     private fun readBinaryData(node: PtIncludeBinary): Collection<UByte> {
@@ -415,13 +410,19 @@ class IRCodeGen(
                 if(choice.statements.children.isEmpty()) {
                     // no statements for this choice value, jump to the end immediately
                     choice.values.children.map { it as PtNumber }.sortedBy { it.number }.forEach { value ->
-                        addInstr(result, IRInstruction(Opcode.BEQ, valueDt, reg1=valueTr.resultReg, immediate = value.number.toInt(), labelSymbol = endLabel), null)
+                        result += IRCodeChunk(null, null).also {
+                            it += IRInstruction(Opcode.CMPI, valueDt, reg1=valueTr.resultReg, immediate = value.number.toInt())
+                            it += IRInstruction(Opcode.BSTEQ, labelSymbol = endLabel)
+                        }
                     }
                 } else {
                     val choiceLabel = createLabelName()
                     choices.add(choiceLabel to choice)
                     choice.values.children.map { it as PtNumber }.sortedBy { it.number }.forEach { value ->
-                        addInstr(result, IRInstruction(Opcode.BEQ, valueDt, reg1=valueTr.resultReg, immediate = value.number.toInt(), labelSymbol = choiceLabel), null)
+                        result += IRCodeChunk(null, null).also {
+                            it += IRInstruction(Opcode.CMPI, valueDt, reg1=valueTr.resultReg, immediate = value.number.toInt())
+                            it += IRInstruction(Opcode.BSTEQ, labelSymbol = choiceLabel)
+                        }
                     }
                 }
             }
@@ -464,7 +465,7 @@ class IRCodeGen(
                         addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = indexReg, immediate = 0), null)
                         result += IRCodeChunk(loopLabel, null).also {
                             it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1 = tmpReg, reg2 = indexReg, labelSymbol = iterable.name)
-                            it += IRInstruction(Opcode.BEQ, IRDataType.BYTE, reg1 = tmpReg, immediate = 0, labelSymbol = endLabel)
+                            it += IRInstruction(Opcode.BSTEQ, labelSymbol = endLabel)
                             it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = tmpReg, labelSymbol = loopvarSymbol)
                         }
                         result += translateNode(forLoop.statements)
@@ -484,15 +485,19 @@ class IRCodeGen(
                             val tmpRegLsb = registers.nextFree()
                             val tmpRegMsb = registers.nextFree()
                             val concatReg = registers.nextFree()
-                            it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1=tmpRegLsb, reg2=indexReg, immediate = iterableLength, labelSymbol=iterable.name+"_lsb")
                             it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1=tmpRegMsb, reg2=indexReg, immediate = iterableLength, labelSymbol=iterable.name+"_msb")
-                            it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=concatReg, reg2=tmpRegLsb, reg3=tmpRegMsb)
+                            it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1=tmpRegLsb, reg2=indexReg, immediate = iterableLength, labelSymbol=iterable.name+"_lsb")
+                            it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=concatReg, reg2=tmpRegMsb, reg3=tmpRegLsb)
                             it += IRInstruction(Opcode.STOREM, irType(elementDt), reg1=concatReg, labelSymbol = loopvarSymbol)
                         }
                         result += translateNode(forLoop.statements)
                         result += IRCodeChunk(null, null).also {
                             it += IRInstruction(Opcode.INC, IRDataType.BYTE, reg1=indexReg)
-                            it += IRInstruction(Opcode.BNE, IRDataType.BYTE, reg1=indexReg, immediate = if(iterableLength==256) 0 else iterableLength, labelSymbol = loopLabel)
+                            if(iterableLength!=256) {
+                                // for length 256, the compare is actually against 0, which doesn't require a separate CMP instruction
+                                it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=indexReg, immediate = iterableLength)
+                            }
+                            it += IRInstruction(Opcode.BSTNE, labelSymbol = loopLabel)
                         }
                     }
                     else -> {
@@ -507,7 +512,13 @@ class IRCodeGen(
                         }
                         result += translateNode(forLoop.statements)
                         result += addConstReg(IRDataType.BYTE, indexReg, elementSize)
-                        addInstr(result, IRInstruction(Opcode.BNE, IRDataType.BYTE, reg1=indexReg, immediate = if(lengthBytes==256) 0 else lengthBytes, labelSymbol = loopLabel), null)
+                        result += IRCodeChunk(null, null).also {
+                            if(lengthBytes!=256) {
+                                // for length 256, the compare is actually against 0, which doesn't require a separate CMP instruction
+                                it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=indexReg, immediate = lengthBytes)
+                            }
+                            it += IRInstruction(Opcode.BSTNE, labelSymbol = loopLabel)
+                        }
                     }
                 }
             }
@@ -555,8 +566,11 @@ class IRCodeGen(
         result += labelFirstChunk(translateNode(forLoop.statements), loopLabel)
         if(step==1 || step==-1) {
             // if endvalue == loopvar, stop loop, else iterate
-            addInstr(result, IRInstruction(Opcode.LOADM, loopvarDtIr, reg1 = fromTr.resultReg, labelSymbol = loopvarSymbol), null)
-            addInstr(result, IRInstruction(Opcode.BEQR, loopvarDtIr, reg1=toTr.resultReg, reg2=fromTr.resultReg, labelSymbol = labelAfterFor), null)
+            result += IRCodeChunk(null, null).also {
+                it += IRInstruction(Opcode.LOADM, loopvarDtIr, reg1 = fromTr.resultReg, labelSymbol = loopvarSymbol)
+                it += IRInstruction(Opcode.CMP, loopvarDtIr, reg1=toTr.resultReg, reg2=fromTr.resultReg)
+                it += IRInstruction(Opcode.BSTEQ, labelSymbol = labelAfterFor)
+            }
             result += addConstMem(loopvarDtIr, null, loopvarSymbol, step)
             addInstr(result, IRInstruction(Opcode.JUMP, labelSymbol = loopLabel), null)
         } else {
@@ -601,8 +615,8 @@ class IRCodeGen(
         result += labelFirstChunk(translateNode(forLoop.statements), loopLabel)
         val chunk2 = addConstMem(loopvarDtIr, null, loopvarSymbol, iterable.step)
         chunk2 += IRInstruction(Opcode.LOADM, loopvarDtIr, reg1 = indexReg, labelSymbol = loopvarSymbol)
-        chunk2 += IRInstruction(Opcode.XOR, loopvarDtIr, reg1 = 999, immediate = 111)
-        chunk2 += IRInstruction(Opcode.BNE, loopvarDtIr, reg1 = indexReg, immediate = rangeEndExclusiveWrapped, labelSymbol = loopLabel)
+        chunk2 += IRInstruction(Opcode.CMPI, loopvarDtIr, reg1 = indexReg, immediate = rangeEndExclusiveWrapped)
+        chunk2 += IRInstruction(Opcode.BSTNE, labelSymbol = loopLabel)
         result += chunk2
         return result
     }
@@ -691,23 +705,23 @@ class IRCodeGen(
         return code
     }
 
-    internal fun multiplyByConstFloat(fpReg: Int, factor: Float): IRCodeChunk {
+    internal fun multiplyByConstFloat(fpReg: Int, factor: Double): IRCodeChunk {
         val code = IRCodeChunk(null, null)
-        if(factor==1f)
+        if(factor==1.0)
             return code
-        code += if(factor==0f) {
-            IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = fpReg, immediateFp = 0f)
+        code += if(factor==0.0) {
+            IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = fpReg, immediateFp = 0.0)
         } else {
             IRInstruction(Opcode.MUL, IRDataType.FLOAT, fpReg1 = fpReg, immediateFp = factor)
         }
         return code
     }
 
-    internal fun multiplyByConstFloatInplace(knownAddress: Int?, symbol: String?, factor: Float): IRCodeChunk {
+    internal fun multiplyByConstFloatInplace(knownAddress: Int?, symbol: String?, factor: Double): IRCodeChunk {
         val code = IRCodeChunk(null, null)
-        if(factor==1f)
+        if(factor==1.0)
             return code
-        if(factor==0f) {
+        if(factor==0.0) {
             code += if(knownAddress!=null)
                 IRInstruction(Opcode.STOREZM, IRDataType.FLOAT, address = knownAddress)
             else
@@ -788,25 +802,25 @@ class IRCodeGen(
         return code
     }
 
-    internal fun divideByConstFloat(fpReg: Int, factor: Float): IRCodeChunk {
+    internal fun divideByConstFloat(fpReg: Int, factor: Double): IRCodeChunk {
         val code = IRCodeChunk(null, null)
-        if(factor==1f)
+        if(factor==1.0)
             return code
-        code += if(factor==0f) {
-            IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = fpReg, immediateFp = Float.MAX_VALUE)
+        code += if(factor==0.0) {
+            IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = fpReg, immediateFp = Double.MAX_VALUE)
         } else {
             IRInstruction(Opcode.DIVS, IRDataType.FLOAT, fpReg1 = fpReg, immediateFp = factor)
         }
         return code
     }
 
-    internal fun divideByConstFloatInplace(knownAddress: Int?, symbol: String?, factor: Float): IRCodeChunk {
+    internal fun divideByConstFloatInplace(knownAddress: Int?, symbol: String?, factor: Double): IRCodeChunk {
         val code = IRCodeChunk(null, null)
-        if(factor==1f)
+        if(factor==1.0)
             return code
-        if(factor==0f) {
+        if(factor==0.0) {
             val maxvalueReg = registers.nextFreeFloat()
-            code += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = maxvalueReg, immediateFp = Float.MAX_VALUE)
+            code += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = maxvalueReg, immediateFp = Double.MAX_VALUE)
             code += if(knownAddress!=null)
                 IRInstruction(Opcode.STOREM, IRDataType.FLOAT, fpReg1 = maxvalueReg, address = knownAddress)
             else
@@ -961,21 +975,31 @@ class IRCodeGen(
                         fpReg1 = leftTr.resultFpReg,
                         fpReg2 = rightTr.resultFpReg
                     )
-                    val gotoOpcode = when (condition.operator) {
-                        "==" -> Opcode.BEQ
-                        "!=" -> Opcode.BNE
-                        "<" -> Opcode.BLTS
-                        ">" -> Opcode.BGTS
-                        "<=" -> Opcode.BLES
-                        ">=" -> Opcode.BGES
-                        else -> throw AssemblyError("weird operator")
+                    when(condition.operator) {
+                        "==" -> {
+                            it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1 = compResultReg, immediate = 0)
+                            it += branchInstr(goto, Opcode.BSTEQ)
+                        }
+                        "!=" -> {
+                            it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1 = compResultReg, immediate = 0)
+                            it += branchInstr(goto, Opcode.BSTNE)
+                        }
+                        else -> {
+                            val gotoOpcode = when (condition.operator) {
+                                "<" -> Opcode.BLTS
+                                ">" -> Opcode.BGTS
+                                "<=" -> Opcode.BLES
+                                ">=" -> Opcode.BGES
+                                else -> throw AssemblyError("weird operator")
+                            }
+                            it += if (goto.address != null)
+                                IRInstruction(gotoOpcode, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, address = goto.address?.toInt())
+                            else if (goto.generatedLabel != null)
+                                IRInstruction(gotoOpcode, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, labelSymbol = goto.generatedLabel)
+                            else
+                                IRInstruction(gotoOpcode, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, labelSymbol = goto.identifier!!.name)
+                        }
                     }
-                    it += if (goto.address != null)
-                        IRInstruction(gotoOpcode, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, address = goto.address?.toInt())
-                    else if (goto.generatedLabel != null)
-                        IRInstruction(gotoOpcode, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, labelSymbol = goto.generatedLabel)
-                    else
-                        IRInstruction(gotoOpcode, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, labelSymbol = goto.identifier!!.name)
                 }
                 return result
             } else {
@@ -990,6 +1014,13 @@ class IRCodeGen(
         }
     }
 
+    private fun branchInstr(goto: PtJump, branchOpcode: Opcode) = if (goto.address != null)
+        IRInstruction(branchOpcode, address = goto.address?.toInt())
+    else if (goto.generatedLabel != null)
+        IRInstruction(branchOpcode, labelSymbol = goto.generatedLabel)
+    else
+        IRInstruction(branchOpcode, labelSymbol = goto.identifier!!.name)
+
     private fun ifZeroIntThenJump(
         result: MutableList<IRCodeChunkBase>,
         ifElse: PtIfElse,
@@ -1000,21 +1031,34 @@ class IRCodeGen(
         val condition = ifElse.condition as PtBinaryExpression
         val leftTr = expressionEval.translateExpression(condition.left)
         addToResult(result, leftTr, leftTr.resultReg, -1)
-        val opcode = when (condition.operator) {
-            "==" -> Opcode.BEQ
-            "!=" -> Opcode.BNE
-            "<" -> if (signed) Opcode.BLTS else Opcode.BLT
-            ">" -> if (signed) Opcode.BGTS else Opcode.BGT
-            "<=" -> if (signed) Opcode.BLES else Opcode.BLE
-            ">=" -> if (signed) Opcode.BGES else Opcode.BGE
-            else -> throw AssemblyError("invalid comparison operator")
+        val requireCompareZero = leftTr.lastInstruction().opcode !in OpcodesThatSetStatusbits
+        when(condition.operator) {
+            "==" -> {
+                if(requireCompareZero)
+                    addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = leftTr.resultReg, immediate = 0), null)
+                addInstr(result, branchInstr(goto, Opcode.BSTEQ), null)
+            }
+            "!=" -> {
+                if(requireCompareZero)
+                    addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = leftTr.resultReg, immediate = 0), null)
+                addInstr(result, branchInstr(goto, Opcode.BSTNE), null)
+            }
+            else -> {
+                val opcode = when (condition.operator) {
+                    "<" -> if (signed) Opcode.BLTS else Opcode.BLT
+                    ">" -> if (signed) Opcode.BGTS else Opcode.BGT
+                    "<=" -> if (signed) Opcode.BLES else Opcode.BLE
+                    ">=" -> if (signed) Opcode.BGES else Opcode.BGE
+                    else -> throw AssemblyError("invalid comparison operator")
+                }
+                if (goto.address != null)
+                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = leftTr.resultReg, immediate = 0, address = goto.address?.toInt()), null)
+                else if (goto.generatedLabel != null)
+                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = leftTr.resultReg, immediate = 0, labelSymbol = goto.generatedLabel), null)
+                else
+                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = leftTr.resultReg, immediate = 0, labelSymbol = goto.identifier!!.name), null)
+            }
         }
-        if (goto.address != null)
-            addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = leftTr.resultReg, immediate = 0, address = goto.address?.toInt()), null)
-        else if (goto.generatedLabel != null)
-            addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = leftTr.resultReg, immediate = 0, labelSymbol = goto.generatedLabel), null)
-        else
-            addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = leftTr.resultReg, immediate = 0, labelSymbol = goto.identifier!!.name), null)
     }
 
     private fun ifNonZeroIntThenJump(
@@ -1026,49 +1070,61 @@ class IRCodeGen(
     ) {
         val condition = ifElse.condition as? PtBinaryExpression
         if(condition==null) {
-            val tr = expressionEval.translateExpression(ifElse.condition)
-            result += tr.chunks
-            if (goto.address != null)
-                addInstr(result, IRInstruction(Opcode.BNE, irDtLeft, reg1 = tr.resultReg, immediate = 0, address = goto.address?.toInt()), null)
-            else if (goto.generatedLabel != null)
-                addInstr(result, IRInstruction(Opcode.BNE, irDtLeft, reg1 = tr.resultReg, immediate = 0, labelSymbol = goto.generatedLabel), null)
-            else
-                addInstr(result, IRInstruction(Opcode.BNE, irDtLeft, reg1 = tr.resultReg, immediate = 0, labelSymbol = goto.identifier!!.name), null)
+            throw AssemblyError("expected condition")
+//            val tr = expressionEval.translateExpression(ifElse.condition)
+//            result += tr.chunks
+//            result += IRCodeChunk(null, null).also {
+//                it += IRInstruction(Opcode.CMPI, irDtLeft, reg1 = tr.resultReg, immediate = 0)      // was redundant CMP most likely
+//                it += branchInstr(goto, Opcode.BSTNE)
+//            }
         } else {
             val leftTr = expressionEval.translateExpression(condition.left)
             addToResult(result, leftTr, leftTr.resultReg, -1)
-            val opcode: Opcode
             val number = (condition.right as? PtNumber)?.number?.toInt()
             if(number!=null) {
                 val firstReg = leftTr.resultReg
-                opcode = when (condition.operator) {
-                    "==" -> Opcode.BEQ
-                    "!=" -> Opcode.BNE
-                    "<" -> if(signed) Opcode.BLTS else Opcode.BLT
-                    ">" -> if(signed) Opcode.BGTS else Opcode.BGT
-                    "<=" -> if(signed) Opcode.BLES else Opcode.BLE
-                    ">=" -> if(signed) Opcode.BGES else Opcode.BGE
-                    else -> throw AssemblyError("invalid comparison operator")
+                when(condition.operator) {
+                    "==" -> {
+                        addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = firstReg, immediate = number), null)
+                        addInstr(result, branchInstr(goto, Opcode.BSTEQ), null)
+                    }
+                    "!=" -> {
+                        addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = firstReg, immediate = number), null)
+                        addInstr(result, branchInstr(goto, Opcode.BSTNE), null)
+                    }
+                    else -> {
+                        val opcode = when (condition.operator) {
+                            "<" -> if(signed) Opcode.BLTS else Opcode.BLT
+                            ">" -> if(signed) Opcode.BGTS else Opcode.BGT
+                            "<=" -> if(signed) Opcode.BLES else Opcode.BLE
+                            ">=" -> if(signed) Opcode.BGES else Opcode.BGE
+                            else -> throw AssemblyError("invalid comparison operator")
+                        }
+                        if (goto.address != null)
+                            addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, immediate = number, address = goto.address?.toInt()), null)
+                        else if (goto.generatedLabel != null)
+                            addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, immediate = number, labelSymbol = goto.generatedLabel), null)
+                        else
+                            addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, immediate = number, labelSymbol = goto.identifier!!.name), null)
+                    }
                 }
-                if (goto.address != null)
-                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, immediate = number, address = goto.address?.toInt()), null)
-                else if (goto.generatedLabel != null)
-                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, immediate = number, labelSymbol = goto.generatedLabel), null)
-                else
-                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, immediate = number, labelSymbol = goto.identifier!!.name), null)
             } else {
                 val rightTr = expressionEval.translateExpression(condition.right)
                 addToResult(result, rightTr, rightTr.resultReg, -1)
                 val firstReg: Int
                 val secondReg: Int
+                val opcode: Opcode
+                var useCmp = false
                 when (condition.operator) {
                     "==" -> {
-                        opcode = Opcode.BEQR
+                        useCmp = true
+                        opcode = Opcode.BSTEQ
                         firstReg = leftTr.resultReg
                         secondReg = rightTr.resultReg
                     }
                     "!=" -> {
-                        opcode = Opcode.BNER
+                        useCmp = true
+                        opcode = Opcode.BSTNE
                         firstReg = leftTr.resultReg
                         secondReg = rightTr.resultReg
                     }
@@ -1096,12 +1152,20 @@ class IRCodeGen(
                     }
                     else -> throw AssemblyError("invalid comparison operator")
                 }
-                if (goto.address != null)
-                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, reg2 = secondReg, address = goto.address?.toInt()), null)
-                else if (goto.generatedLabel != null)
-                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, reg2 = secondReg, labelSymbol = goto.generatedLabel), null)
-                else
-                    addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, reg2 = secondReg, labelSymbol = goto.identifier!!.name), null)
+
+                if(useCmp) {
+                    result += IRCodeChunk(null, null).also {
+                        it += IRInstruction(Opcode.CMP, irDtLeft, reg1 = firstReg, reg2 = secondReg)
+                        it += branchInstr(goto, opcode)
+                    }
+                } else {
+                    if (goto.address != null)
+                        addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, reg2 = secondReg, address = goto.address?.toInt()), null)
+                    else if (goto.generatedLabel != null)
+                        addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, reg2 = secondReg, labelSymbol = goto.generatedLabel), null)
+                    else
+                        addInstr(result, IRInstruction(opcode, irDtLeft, reg1 = firstReg, reg2 = secondReg, labelSymbol = goto.identifier!!.name), null)
+                }
             }
         }
     }
@@ -1109,6 +1173,7 @@ class IRCodeGen(
     private fun translateIfElseZeroComparison(ifElse: PtIfElse, irDtLeft: IRDataType, signed: Boolean): IRCodeChunks {
         val result = mutableListOf<IRCodeChunkBase>()
         val elseBranch: Opcode
+        var useCmpi = false     // for the branch opcodes that have been converted to CMPI + BSTxx form already
         val compResultReg: Int
         val branchDt: IRDataType
         val condition = ifElse.condition as PtBinaryExpression
@@ -1119,16 +1184,22 @@ class IRCodeGen(
             addToResult(result, leftTr, -1, leftTr.resultFpReg)
             result += IRCodeChunk(null, null).also {
                 val rightFpReg = registers.nextFreeFloat()
-                it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = rightFpReg, immediateFp = 0f)
+                it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = rightFpReg, immediateFp = 0.0)
                 it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=compResultReg, fpReg1 = leftTr.resultFpReg, fpReg2 = rightFpReg)
             }
-            elseBranch = when (condition.operator) {
-                "==" -> Opcode.BNE
-                "!=" -> Opcode.BEQ
-                "<" -> Opcode.BGES
-                ">" -> Opcode.BLES
-                "<=" -> Opcode.BGTS
-                ">=" -> Opcode.BLTS
+            when (condition.operator) {
+                "==" -> {
+                    elseBranch = Opcode.BSTNE
+                    useCmpi = true
+                }
+                "!=" -> {
+                    elseBranch = Opcode.BSTEQ
+                    useCmpi = true
+                }
+                "<" -> elseBranch = Opcode.BGES
+                ">" -> elseBranch = Opcode.BLES
+                "<=" -> elseBranch = Opcode.BGTS
+                ">=" -> elseBranch = Opcode.BLTS
                 else -> throw AssemblyError("weird operator")
             }
         } else {
@@ -1137,13 +1208,19 @@ class IRCodeGen(
             val tr = expressionEval.translateExpression(condition.left)
             compResultReg = tr.resultReg
             addToResult(result, tr, tr.resultReg, -1)
-            elseBranch = when (condition.operator) {
-                "==" -> Opcode.BNE
-                "!=" -> Opcode.BEQ
-                "<" -> if (signed) Opcode.BGES else Opcode.BGE
-                ">" -> if (signed) Opcode.BLES else Opcode.BLE
-                "<=" -> if (signed) Opcode.BGTS else Opcode.BGT
-                ">=" -> if (signed) Opcode.BLTS else Opcode.BLT
+            when (condition.operator) {
+                "==" -> {
+                    elseBranch = Opcode.BSTNE
+                    useCmpi = true
+                }
+                "!=" -> {
+                    elseBranch = Opcode.BSTEQ
+                    useCmpi = true
+                }
+                "<" -> elseBranch = if (signed) Opcode.BGES else Opcode.BGE
+                ">" -> elseBranch = if (signed) Opcode.BLES else Opcode.BLE
+                "<=" -> elseBranch = if (signed) Opcode.BGTS else Opcode.BGT
+                ">=" -> elseBranch = if (signed) Opcode.BLTS else Opcode.BLT
                 else -> throw AssemblyError("weird operator")
             }
         }
@@ -1151,14 +1228,26 @@ class IRCodeGen(
         if(ifElse.elseScope.children.isEmpty()) {
             // just if
             val afterIfLabel = createLabelName()
-            addInstr(result, IRInstruction(elseBranch, branchDt, reg1=compResultReg, immediate = 0, labelSymbol = afterIfLabel), null)
+            if(useCmpi) {
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.CMPI, branchDt, reg1=compResultReg, immediate = 0)
+                    it += IRInstruction(elseBranch, labelSymbol = afterIfLabel)
+                }
+            } else
+                addInstr(result, IRInstruction(elseBranch, branchDt, reg1=compResultReg, immediate = 0, labelSymbol = afterIfLabel), null)
             result += translateNode(ifElse.ifScope)
             result += IRCodeChunk(afterIfLabel, null)
         } else {
             // if and else
             val elseLabel = createLabelName()
             val afterIfLabel = createLabelName()
-            addInstr(result, IRInstruction(elseBranch, branchDt, reg1=compResultReg, immediate = 0, labelSymbol = elseLabel), null)
+            if(useCmpi) {
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.CMPI, branchDt, reg1=compResultReg, immediate = 0)
+                    it += IRInstruction(elseBranch, labelSymbol = elseLabel)
+                }
+            } else
+                addInstr(result, IRInstruction(elseBranch, branchDt, reg1=compResultReg, immediate = 0, labelSymbol = elseLabel), null)
             result += translateNode(ifElse.ifScope)
             addInstr(result, IRInstruction(Opcode.JUMP, labelSymbol = afterIfLabel), null)
             result += labelFirstChunk(translateNode(ifElse.elseScope), elseLabel)
@@ -1169,31 +1258,12 @@ class IRCodeGen(
 
     private fun translateIfElseNonZeroComparison(ifElse: PtIfElse, irDtLeft: IRDataType, signed: Boolean): IRCodeChunks {
         val result = mutableListOf<IRCodeChunkBase>()
-        val elseBranchOpcode: Opcode
         val elseBranchFirstReg: Int
         val elseBranchSecondReg: Int
         val branchDt: IRDataType
         val condition = ifElse.condition as? PtBinaryExpression
         if(condition==null) {
-            if(irDtLeft==IRDataType.FLOAT)
-                throw AssemblyError("condition value should not be float")
-            val tr = expressionEval.translateExpression(ifElse.condition)
-            result += tr.chunks
-            if(ifElse.elseScope.children.isNotEmpty()) {
-                val elseLabel = createLabelName()
-                val afterIfLabel = createLabelName()
-                addInstr(result, IRInstruction(Opcode.BEQ, irDtLeft, reg1=tr.resultReg, immediate = 0, labelSymbol = elseLabel), null)
-                result += translateNode(ifElse.ifScope)
-                addInstr(result, IRInstruction(Opcode.JUMP, labelSymbol = afterIfLabel), null)
-                result += labelFirstChunk(translateNode(ifElse.elseScope), elseLabel)
-                result += IRCodeChunk(afterIfLabel, null)
-            } else {
-                val afterIfLabel = createLabelName()
-                addInstr(result, IRInstruction(Opcode.BEQ, irDtLeft, reg1=tr.resultReg, immediate = 0, labelSymbol = afterIfLabel), null)
-                result += translateNode(ifElse.ifScope)
-                result += IRCodeChunk(afterIfLabel, null)
-            }
-            return result
+            throw AssemblyError("if-else condition is not a binaryexpression, should have been converted?")
         } else {
             if (irDtLeft == IRDataType.FLOAT) {
                 val leftTr = expressionEval.translateExpression(condition.left)
@@ -1201,35 +1271,35 @@ class IRCodeGen(
                 val rightTr = expressionEval.translateExpression(condition.right)
                 addToResult(result, rightTr, -1, rightTr.resultFpReg)
                 val compResultReg = registers.nextFree()
-                addInstr(
-                    result,
-                    IRInstruction(
-                        Opcode.FCOMP,
-                        IRDataType.FLOAT,
-                        reg1 = compResultReg,
-                        fpReg1 = leftTr.resultFpReg,
-                        fpReg2 = rightTr.resultFpReg
-                    ),
-                    null
-                )
-                val elseBranch = when (condition.operator) {
-                    "==" -> Opcode.BNE
-                    "!=" -> Opcode.BEQ
-                    "<" -> Opcode.BGES
-                    ">" -> Opcode.BLES
-                    "<=" -> Opcode.BGTS
-                    ">=" -> Opcode.BLTS
+                addInstr(result, IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1 = compResultReg, fpReg1 = leftTr.resultFpReg, fpReg2 = rightTr.resultFpReg), null)
+                val elseBranch: Opcode
+                var useCmpi = false     // for the branch opcodes that have been converted to CMPI + BSTxx form already
+                when (condition.operator) {
+                    "==" -> {
+                        elseBranch = Opcode.BSTNE
+                        useCmpi = true
+                    }
+                    "!=" -> {
+                        elseBranch = Opcode.BSTEQ
+                        useCmpi = true
+                    }
+                    "<" -> elseBranch = Opcode.BGES
+                    ">" -> elseBranch = Opcode.BLES
+                    "<=" -> elseBranch = Opcode.BGTS
+                    ">=" -> elseBranch = Opcode.BLTS
                     else -> throw AssemblyError("weird operator")
                 }
                 if (ifElse.elseScope.children.isNotEmpty()) {
                     // if and else parts
                     val elseLabel = createLabelName()
                     val afterIfLabel = createLabelName()
-                    addInstr(
-                        result,
-                        IRInstruction(elseBranch, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, labelSymbol = elseLabel),
-                        null
-                    )
+                    if(useCmpi) {
+                        result += IRCodeChunk(null, null).also {
+                            it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1 = compResultReg, immediate = 0)
+                            it += IRInstruction(elseBranch, labelSymbol = elseLabel)
+                        }
+                    } else
+                        addInstr(result, IRInstruction(elseBranch, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, labelSymbol = elseLabel), null)
                     result += translateNode(ifElse.ifScope)
                     addInstr(result, IRInstruction(Opcode.JUMP, labelSymbol = afterIfLabel), null)
                     result += labelFirstChunk(translateNode(ifElse.elseScope), elseLabel)
@@ -1237,11 +1307,13 @@ class IRCodeGen(
                 } else {
                     // only if part
                     val afterIfLabel = createLabelName()
-                    addInstr(
-                        result,
-                        IRInstruction(elseBranch, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, labelSymbol = afterIfLabel),
-                        null
-                    )
+                    if(useCmpi) {
+                        result += IRCodeChunk(null, null).also {
+                            it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1 = compResultReg, immediate = 0)
+                            it += IRInstruction(elseBranch, labelSymbol = afterIfLabel)
+                        }
+                    } else
+                        addInstr(result, IRInstruction(elseBranch, IRDataType.BYTE, reg1 = compResultReg, immediate = 0, labelSymbol = afterIfLabel), null)
                     result += translateNode(ifElse.ifScope)
                     result += IRCodeChunk(afterIfLabel, null)
                 }
@@ -1252,26 +1324,34 @@ class IRCodeGen(
                 addToResult(result, leftTr, leftTr.resultReg, -1)
                 val number = (condition.right as? PtNumber)?.number?.toInt()
                 if (number!=null) {
-                    elseBranchOpcode = when (condition.operator) {
-                        "==" -> Opcode.BNE
-                        "!=" -> Opcode.BEQ
-                        "<" -> if(signed) Opcode.BGES else Opcode.BGE
-                        ">" -> if(signed) Opcode.BLES else Opcode.BLE
-                        "<=" -> if(signed) Opcode.BGTS else Opcode.BGT
-                        ">=" -> if(signed) Opcode.BLTS else Opcode.BLT
+                    val elseBranch: Opcode
+                    var useCmpi = false     // for the branch opcodes that have been converted to CMPI + BSTxx form already
+                    when (condition.operator) {
+                        "==" -> {
+                            elseBranch = Opcode.BSTNE
+                            useCmpi = true
+                        }
+                        "!=" -> {
+                            elseBranch = Opcode.BSTEQ
+                            useCmpi = true
+                        }
+                        "<" -> elseBranch = if(signed) Opcode.BGES else Opcode.BGE
+                        ">" -> elseBranch = if(signed) Opcode.BLES else Opcode.BLE
+                        "<=" -> elseBranch = if(signed) Opcode.BGTS else Opcode.BGT
+                        ">=" -> elseBranch = if(signed) Opcode.BLTS else Opcode.BLT
                         else -> throw AssemblyError("invalid comparison operator")
                     }
                     if (ifElse.elseScope.children.isNotEmpty()) {
                         // if and else parts
                         val elseLabel = createLabelName()
                         val afterIfLabel = createLabelName()
-                        addInstr(
-                            result, IRInstruction(
-                                elseBranchOpcode, branchDt,
-                                reg1 = leftTr.resultReg, immediate = number,
-                                labelSymbol = elseLabel
-                            ), null
-                        )
+                        if(useCmpi) {
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.CMPI, branchDt, reg1 = leftTr.resultReg, immediate = number)
+                                it += IRInstruction(elseBranch, labelSymbol = elseLabel)
+                            }
+                        } else
+                            addInstr(result, IRInstruction(elseBranch, branchDt, reg1 = leftTr.resultReg, immediate = number, labelSymbol = elseLabel), null)
                         result += translateNode(ifElse.ifScope)
                         addInstr(result, IRInstruction(Opcode.JUMP, labelSymbol = afterIfLabel), null)
                         result += labelFirstChunk(translateNode(ifElse.elseScope), elseLabel)
@@ -1279,52 +1359,56 @@ class IRCodeGen(
                     } else {
                         // only if part
                         val afterIfLabel = createLabelName()
-                        addInstr(
-                            result, IRInstruction(
-                                elseBranchOpcode, branchDt,
-                                reg1 = leftTr.resultReg, immediate = number,
-                                labelSymbol = afterIfLabel
-                            ), null
-                        )
+                        if(useCmpi) {
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.CMPI, branchDt, reg1 = leftTr.resultReg, immediate = number)
+                                it += IRInstruction(elseBranch, labelSymbol = afterIfLabel)
+                            }
+                        } else
+                            addInstr(result, IRInstruction(elseBranch, branchDt, reg1 = leftTr.resultReg, immediate = number, labelSymbol = afterIfLabel), null)
                         result += translateNode(ifElse.ifScope)
                         result += IRCodeChunk(afterIfLabel, null)
                     }
                 } else {
                     val rightTr = expressionEval.translateExpression(condition.right)
+                    val elseBranch: Opcode
+                    var useCmp = false
                     addToResult(result, rightTr, rightTr.resultReg, -1)
                     when (condition.operator) {
                         "==" -> {
-                            elseBranchOpcode = Opcode.BNER
+                            useCmp = true
+                            elseBranch = Opcode.BSTNE
                             elseBranchFirstReg = leftTr.resultReg
                             elseBranchSecondReg = rightTr.resultReg
                         }
                         "!=" -> {
-                            elseBranchOpcode = Opcode.BEQR
+                            useCmp = true
+                            elseBranch = Opcode.BSTEQ
                             elseBranchFirstReg = leftTr.resultReg
                             elseBranchSecondReg = rightTr.resultReg
                         }
                         "<" -> {
                             // else part when left >= right
-                            elseBranchOpcode = if (signed) Opcode.BGESR else Opcode.BGER
+                            elseBranch = if (signed) Opcode.BGESR else Opcode.BGER
                             elseBranchFirstReg = leftTr.resultReg
                             elseBranchSecondReg = rightTr.resultReg
                         }
                         ">" -> {
                             // else part when left <= right --> right >= left
-                            elseBranchOpcode = if (signed) Opcode.BGESR else Opcode.BGER
+                            elseBranch = if (signed) Opcode.BGESR else Opcode.BGER
                             elseBranchFirstReg = rightTr.resultReg
                             elseBranchSecondReg = leftTr.resultReg
                         }
                         "<=" -> {
                             // else part when left > right
-                            elseBranchOpcode = if (signed) Opcode.BGTSR else Opcode.BGTR
+                            elseBranch = if (signed) Opcode.BGTSR else Opcode.BGTR
                             elseBranchFirstReg = leftTr.resultReg
                             elseBranchSecondReg = rightTr.resultReg
                         }
 
                         ">=" -> {
                             // else part when left < right --> right > left
-                            elseBranchOpcode = if (signed) Opcode.BGTSR else Opcode.BGTR
+                            elseBranch = if (signed) Opcode.BGTSR else Opcode.BGTR
                             elseBranchFirstReg = rightTr.resultReg
                             elseBranchSecondReg = leftTr.resultReg
                         }
@@ -1334,13 +1418,14 @@ class IRCodeGen(
                         // if and else parts
                         val elseLabel = createLabelName()
                         val afterIfLabel = createLabelName()
-                        addInstr(
-                            result, IRInstruction(
-                                elseBranchOpcode, branchDt,
-                                reg1 = elseBranchFirstReg, reg2 = elseBranchSecondReg,
-                                labelSymbol = elseLabel
-                            ), null
-                        )
+                        if(useCmp) {
+                            result += IRCodeChunk(null,null).also {
+                                it += IRInstruction(Opcode.CMP, branchDt, reg1 = elseBranchFirstReg, reg2 = elseBranchSecondReg)
+                                it += IRInstruction(elseBranch, labelSymbol = elseLabel)
+                            }
+                        } else {
+                            addInstr(result, IRInstruction(elseBranch, branchDt, reg1 = elseBranchFirstReg, reg2 = elseBranchSecondReg, labelSymbol = elseLabel), null)
+                        }
                         result += translateNode(ifElse.ifScope)
                         addInstr(result, IRInstruction(Opcode.JUMP, labelSymbol = afterIfLabel), null)
                         result += labelFirstChunk(translateNode(ifElse.elseScope), elseLabel)
@@ -1348,13 +1433,14 @@ class IRCodeGen(
                     } else {
                         // only if part
                         val afterIfLabel = createLabelName()
-                        addInstr(
-                            result, IRInstruction(
-                                elseBranchOpcode, branchDt,
-                                reg1 = elseBranchFirstReg, reg2 = elseBranchSecondReg,
-                                labelSymbol = afterIfLabel
-                            ), null
-                        )
+                        if(useCmp) {
+                            result += IRCodeChunk(null,null).also {
+                                it += IRInstruction(Opcode.CMP, branchDt, reg1 = elseBranchFirstReg, reg2 = elseBranchSecondReg)
+                                it += IRInstruction(elseBranch, labelSymbol = afterIfLabel)
+                            }
+                        } else {
+                            addInstr(result, IRInstruction(elseBranch, branchDt, reg1 = elseBranchFirstReg, reg2 = elseBranchSecondReg, labelSymbol = afterIfLabel), null)
+                        }
                         result += translateNode(ifElse.ifScope)
                         result += IRCodeChunk(afterIfLabel, null)
                     }
@@ -1525,12 +1611,12 @@ class IRCodeGen(
         addToResult(result, countTr, countTr.resultReg, -1)
         if(constIntValue(repeat.count)==null) {
             // check if the counter is already zero
-            addInstr(result, IRInstruction(Opcode.BEQ, irDt, reg1=countTr.resultReg, immediate = 0, labelSymbol = skipRepeatLabel), null)
+            addInstr(result, IRInstruction(Opcode.BSTEQ, labelSymbol = skipRepeatLabel), null)
         }
         result += labelFirstChunk(translateNode(repeat.statements), repeatLabel)
         result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.DEC, irDt, reg1 = countTr.resultReg)
-            it += IRInstruction(Opcode.BNE, irDt, reg1 = countTr.resultReg, immediate = 0, labelSymbol = repeatLabel)
+            it += IRInstruction(Opcode.DEC, irDt, reg1 = countTr.resultReg)  // sets status bits
+            it += IRInstruction(Opcode.BSTNE, labelSymbol = repeatLabel)
         }
         result += IRCodeChunk(skipRepeatLabel, null)
         return result

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

@@ -45,6 +45,7 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                         val indexedInstructions = chunk1.instructions.withIndex()
                             .map { IndexedValue(it.index, it.value) }
                         val changed = removeNops(chunk1, indexedInstructions)
+                                || replaceConcatZeroMsbWithExt(chunk1, indexedInstructions)
                                 || removeDoubleLoadsAndStores(chunk1, indexedInstructions)       // TODO not yet implemented
                                 || removeUselessArithmetic(chunk1, indexedInstructions)
                                 || removeNeedlessCompares(chunk1, indexedInstructions)
@@ -63,6 +64,22 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
         irprog.linkChunks()  // re-link
     }
 
+    private fun replaceConcatZeroMsbWithExt(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if (ins.opcode == Opcode.CONCAT) {
+                // if the previous instruction loads a zero in the msb, this can be turned into EXT.B instead
+                val prev = indexedInstructions[idx-1].value
+                if(prev.opcode==Opcode.LOAD && prev.immediate==0 && prev.reg1==ins.reg2) {
+                    chunk.instructions[idx] = IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1 = ins.reg1, reg2 = ins.reg3)
+                    chunk.instructions.removeAt(idx-1)
+                    changed = true
+                }
+            }
+        }
+        return changed
+    }
+
     private fun removeEmptyChunks(sub: IRSubroutine) {
         if(sub.chunks.isEmpty())
             return
@@ -70,7 +87,7 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
         /*
         Empty Code chunk with label ->
             If next chunk has no label -> move label to next chunk, remove original
-            If next chunk has label -> label name should be the same, remove original. Otherwise FOR NOW leave it in place. (TODO: merge both labels into 1)
+            If next chunk has label -> label name should be the same, remove original. Otherwise merge both labels into 1.
             If is last chunk -> keep chunk in place because of the label.
         Empty Code chunk without label ->
             should not have been generated! ERROR.
@@ -79,6 +96,7 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
 
         val relabelChunks = mutableListOf<Pair<Int, String>>()
         val removeChunks = mutableListOf<Int>()
+        val replaceLabels = mutableMapOf<String, String>()
 
         sub.chunks.withIndex().forEach { (index, chunk) ->
             if(chunk is IRCodeChunk && chunk.instructions.isEmpty()) {
@@ -92,10 +110,18 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                             relabelChunks += Pair(index + 1, chunk.label!!)
                             removeChunks += index
                         } else {
-                            if (chunk.label == nextchunk.label)
-                                removeChunks += index
-                            else {
-                                // TODO: merge labels on same chunk
+                            // merge both labels into 1 except if this is the label chunk at the start of the subroutine
+                            if(index>0) {
+                                if (chunk.label == nextchunk.label)
+                                    removeChunks += index
+                                else {
+                                    removeChunks += index
+                                    replaceLabels[chunk.label!!] = nextchunk.label!!
+                                    replaceLabels.entries.forEach { (key, value) ->
+                                        if (value == chunk.label)
+                                            replaceLabels[key] = nextchunk.label!!
+                                    }
+                                }
                             }
                         }
                     }
@@ -112,6 +138,25 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
             sub.chunks[index] = chunk
         }
         removeChunks.reversed().forEach { index -> sub.chunks.removeAt(index) }
+
+        sub.chunks.forEach { chunk ->
+            chunk.instructions.withIndex().forEach { (idx, instr) ->
+                instr.labelSymbol?.let {
+                    if(instr.opcode in OpcodesThatBranch) {
+                        replaceLabels.forEach { (from, to) ->
+                            if (it == from) {
+                                chunk.instructions[idx] = instr.copy(labelSymbol = to)
+                            }
+                            else {
+                                val actualPrefix = "$from."
+                                if (it.startsWith(actualPrefix))
+                                    chunk.instructions[idx] = instr.copy(labelSymbol = "$to.")
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
 
     private fun joinChunks(sub: IRSubroutine) {
@@ -363,6 +408,9 @@ 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) ->
 
@@ -376,5 +424,6 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
             // ...
         }
         return changed
+*/
     }
 }

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

@@ -25,18 +25,29 @@ class IRUnusedCodeRemover(
     }
 
     private fun pruneSymboltable(blockLabel: String) {
-        // we could clean up the SymbolTable as well, but ONLY if these symbols aren't referenced somewhere still in an instruction
+        // we could clean up the SymbolTable as well, but ONLY if these symbols aren't referenced somewhere still in an instruction or variable initializer value
         val prefix = "$blockLabel."
         val blockVars = irprog.st.allVariables().filter { it.name.startsWith(prefix) }
         blockVars.forEach { stVar ->
-            irprog. allSubs().flatMap { it.chunks }.forEach { chunk ->
+            irprog.allSubs().flatMap { it.chunks }.forEach { chunk ->
                 chunk.instructions.forEach { ins ->
                     if(ins.labelSymbol == stVar.name) {
-                        return
+                        return  // symbol occurs in an instruction
                     }
                 }
             }
+
+            irprog.st.allVariables().forEach { variable ->
+                val initValue = variable.onetimeInitializationArrayValue
+                if(!initValue.isNullOrEmpty()) {
+                    if(initValue.any {
+                        it.addressOfSymbol?.startsWith(blockLabel)==true
+                    })
+                        return   // symbol occurs in an initializer value (address-of this symbol)_
+                }
+            }
         }
+
         irprog.st.removeTree(blockLabel)
     }
 
@@ -50,9 +61,6 @@ class IRUnusedCodeRemover(
         irprog.blocks.forEach { block ->
             block.children.filterIsInstance<IRSubroutine>().reversed().forEach { sub ->
                 if(sub.isEmpty()) {
-                    if(!sub.position.file.startsWith(LIBRARYFILEPREFIX)) {
-                        errors.warn("unused subroutine ${sub.label}", sub.position)
-                    }
                     block.children.remove(sub)
                     irprog.st.removeTree(sub.label)
                     numRemoved++
@@ -207,9 +215,7 @@ class IRUnusedCodeRemover(
         return removeUnlinkedChunks(linkedChunks)
     }
 
-    private fun removeUnlinkedChunks(
-        linkedChunks: Set<IRCodeChunkBase>
-    ): Int {
+    private fun removeUnlinkedChunks(linkedChunks: Set<IRCodeChunkBase>): Int {
         var numRemoved = 0
         irprog.foreachSub { sub ->
             sub.chunks.withIndex().reversed().forEach { (index, chunk) ->

codeGenIntermediate/test/Dummies.kt

@@ -16,6 +16,8 @@ internal object DummyMemsizer : IMemSizer {
 }
 
 internal object DummyStringEncoder : IStringEncoding {
+    override val defaultEncoding: Encoding = Encoding.ISO
+
     override fun encodeString(str: String, encoding: Encoding): List<UByte> {
         return emptyList()
     }

codeGenIntermediate/test/TestIRPeepholeOpt.kt

@@ -18,6 +18,7 @@ class TestIRPeepholeOpt: FunSpec({
             CbmPrgLauncherType.NONE,
             ZeropageType.DONTUSE,
             emptyList(),
+            CompilationOptions.AllZeropageAllowed,
             floats = false,
             noSysInit = true,
             compTarget = target,
@@ -52,9 +53,9 @@ class TestIRPeepholeOpt: FunSpec({
 
     test("remove jmp to label below") {
         val c1 = IRCodeChunk("main.start", null)
-        c1 += IRInstruction(Opcode.JUMP, labelSymbol = "label")  // removed, but chunk stays because of label
+        c1 += IRInstruction(Opcode.JUMP, labelSymbol = "label")
         val c2 = IRCodeChunk("label", null)
-        c2 += IRInstruction(Opcode.JUMP, labelSymbol = "label2") // removed, but chunk stays because of label
+        c2 += IRInstruction(Opcode.JUMP, labelSymbol = "label2")
         c2 += IRInstruction(Opcode.NOP)  // removed
         val c3 = IRCodeChunk("label2", null)
         c3 += IRInstruction(Opcode.JUMP, labelSymbol = "label3")
@@ -66,15 +67,13 @@ class TestIRPeepholeOpt: FunSpec({
         irProg.chunks().flatMap { it.instructions }.size shouldBe 5
         val opt = IRPeepholeOptimizer(irProg)
         opt.optimize(true, ErrorReporterForTests())
-        irProg.chunks().size shouldBe 4
+        irProg.chunks().size shouldBe 3
         irProg.chunks()[0].label shouldBe "main.start"
-        irProg.chunks()[1].label shouldBe "label"
-        irProg.chunks()[2].label shouldBe "label2"
-        irProg.chunks()[3].label shouldBe "label3"
+        irProg.chunks()[1].label shouldBe "label2"
+        irProg.chunks()[2].label shouldBe "label3"
         irProg.chunks()[0].isEmpty() shouldBe true
-        irProg.chunks()[1].isEmpty() shouldBe true
-        irProg.chunks()[2].isEmpty() shouldBe false
-        irProg.chunks()[3].isEmpty() shouldBe true
+        irProg.chunks()[1].isEmpty() shouldBe false
+        irProg.chunks()[2].isEmpty() shouldBe true
         val instr = irProg.chunks().flatMap { it.instructions }
         instr.size shouldBe 2
         instr[0].opcode shouldBe Opcode.JUMP

codeGenIntermediate/test/TestVmCodeGen.kt

@@ -19,6 +19,7 @@ class TestVmCodeGen: FunSpec({
             CbmPrgLauncherType.NONE,
             ZeropageType.DONTUSE,
             zpReserved = emptyList(),
+            zpAllowed = CompilationOptions.AllZeropageAllowed,
             floats = true,
             noSysInit = false,
             compTarget = target,
@@ -41,7 +42,7 @@ class TestVmCodeGen: FunSpec({
 //}
         val codegen = VmCodeGen()
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("pi", DataType.UBYTE, ZeropageWish.DONTCARE, PtNumber(DataType.UBYTE, 0.0, Position.DUMMY), null, Position.DUMMY))
         sub.add(PtVariable("particleX", DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, 3u, Position.DUMMY))
@@ -91,7 +92,7 @@ class TestVmCodeGen: FunSpec({
         program.add(block)
 
         // define the "cx16.r0" virtual register
-        val cx16block = PtBlock("cx16", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val cx16block = PtBlock("cx16", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         cx16block.add(PtMemMapped("r0", DataType.UWORD, 100u, null, Position.DUMMY))
         program.add(cx16block)
 
@@ -120,7 +121,7 @@ class TestVmCodeGen: FunSpec({
 //}
         val codegen = VmCodeGen()
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("f1", DataType.FLOAT, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
         val if1 = PtIfElse(Position.DUMMY)
@@ -183,7 +184,7 @@ class TestVmCodeGen: FunSpec({
 //}
         val codegen = VmCodeGen()
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("f1", DataType.FLOAT, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
         val if1 = PtIfElse(Position.DUMMY)
@@ -242,7 +243,7 @@ class TestVmCodeGen: FunSpec({
 //}
         val codegen = VmCodeGen()
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("f1", DataType.FLOAT, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
         val if1 = PtIfElse(Position.DUMMY)
@@ -289,7 +290,7 @@ class TestVmCodeGen: FunSpec({
 //}
         val codegen = VmCodeGen()
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("sb1", DataType.BYTE, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
         val if1 = PtIfElse(Position.DUMMY)
@@ -352,7 +353,7 @@ class TestVmCodeGen: FunSpec({
 //}
         val codegen = VmCodeGen()
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("sb1", DataType.BYTE, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
         val if1 = PtIfElse(Position.DUMMY)
@@ -411,7 +412,7 @@ class TestVmCodeGen: FunSpec({
 //}
         val codegen = VmCodeGen()
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("ub1", DataType.UBYTE, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
         val if1 = PtIfElse(Position.DUMMY)
@@ -451,7 +452,7 @@ class TestVmCodeGen: FunSpec({
 //}
         val codegen = VmCodeGen()
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main", null, false, false, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
         val romsub = PtAsmSub("routine", 0x5000u, setOf(CpuRegister.Y), emptyList(), emptyList(), false, Position.DUMMY)
         block.add(romsub)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
@@ -466,7 +467,11 @@ class TestVmCodeGen: FunSpec({
         val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
         val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
         irChunks.size shouldBe 1
-        val callInstr = irChunks.single().instructions.single()
+        irChunks[0].instructions.size shouldBe 2
+        val preparecallInstr = irChunks[0].instructions[0]
+        preparecallInstr.opcode shouldBe Opcode.PREPARECALL
+        preparecallInstr.immediate shouldBe 0
+        val callInstr = irChunks[0].instructions[1]
         callInstr.opcode shouldBe Opcode.CALL
         callInstr.address shouldBe 0x5000
     }

codeOptimizers/build.gradle

@@ -33,10 +33,10 @@ dependencies {
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
 }

codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -2,7 +2,6 @@ package prog8.optimizer
 
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.maySwapOperandOrder
 import prog8.ast.statements.ForLoop
@@ -19,12 +18,13 @@ import kotlin.math.floor
 class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
 
     override fun before(memread: DirectMemoryRead, parent: Node): Iterable<IAstModification> {
-        // @( &thing )  -->  thing
+        // @( &thing )  -->  thing  (but only if thing is a byte type!)
         val addrOf = memread.addressExpression as? AddressOf
-        return if(addrOf!=null)
-            listOf(IAstModification.ReplaceNode(memread, addrOf.identifier, parent))
-        else
-            noModifications
+        if(addrOf!=null) {
+            if(addrOf.identifier.inferType(program).isBytes)
+                return listOf(IAstModification.ReplaceNode(memread, addrOf.identifier, parent))
+        }
+        return noModifications
     }
 
     override fun after(containment: ContainmentCheck, parent: Node): Iterable<IAstModification> {
@@ -86,7 +86,8 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
 
         if(expr.operator=="==" && rightconst!=null) {
             val leftExpr = expr.left as? BinaryExpression
-            if(leftExpr!=null) {
+            // only do this shuffling when the LHS is not a constant itself (otherwise problematic nested replacements)
+            if(leftExpr?.constValue(program) != null) {
                 val leftRightConst = leftExpr.right.constValue(program)
                 if(leftRightConst!=null) {
                     when (leftExpr.operator) {
@@ -183,10 +184,12 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                         val newExpr = BinaryExpression(leftBinExpr.left, "*", constants, expr.position)
                         return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
                     } else if (leftBinExpr.operator=="/") {
-                        //  (X / C2) * rightConst   -->  X * (rightConst/C2)
-                        val constants = BinaryExpression(rightconst, "/", c2, c2.position)
-                        val newExpr = BinaryExpression(leftBinExpr.left, "*", constants, expr.position)
-                        return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                        if(expr.inferType(program).istype(DataType.FLOAT)) {
+                            //  (X / C2) * rightConst   -->  X * (rightConst/C2)    only valid for floating point
+                            val constants = BinaryExpression(rightconst, "/", c2, c2.position)
+                            val newExpr = BinaryExpression(leftBinExpr.left, "*", constants, expr.position)
+                            return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                        }
                     }
                 }
             }
@@ -194,7 +197,7 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                 val c2 = leftBinExpr.right.constValue(program)
                 if(c2!=null && leftBinExpr.operator=="/") {
                     // (X / C1) / C2   -->  X / (C1*C2)
-                    // NOTE: do not optimize  (X * C1) / C2   -->  X * (C1/C2)  because this causes precision loss on integers
+                    // NOTE: do not optimize  (X * C1) / C2  for integers,  -->  X * (C1/C2)  because this causes precision loss on integers
                     val constants = BinaryExpression(c2, "*", rightconst, c2.position)
                     val newExpr = BinaryExpression(leftBinExpr.left, "/", constants, expr.position)
                     return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
@@ -385,7 +388,7 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                         return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
                 }
             }
-            else -> throw FatalAstException("invalid loopvar datatype $loopvar")
+            else -> { /* nothing for floats, these are not allowed in for loops and will give an error elsewhere */ }
         }
 
         return noModifications
@@ -525,7 +528,8 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                     return IAstModification.ReplaceNode(expr, change, expr.parent)
                 }
             }
-            else if(expr.operator=="*" && subExpr.operator=="/") {
+            else if(expr.operator=="*" && subExpr.operator=="/" && subExpr.inferType(program).istype(DataType.FLOAT)) {
+                // division optimizations only valid for floats
                 if(leftIsConst) {
                     val change = if(subleftIsConst) {
                         // C1*(C2/V) -> (C1*C2)/V

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -28,6 +28,7 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err
                     errors.err("refused rounding of float to avoid loss of precision", decl.value!!.position)
                 } else {
                     // cast the numeric literal to the appropriate datatype of the variable
+                    declConstValue.linkParents(decl)
                     val cast = declConstValue.cast(decl.datatype)
                     if (cast.isValid)
                         return listOf(IAstModification.ReplaceNode(decl.value!!, cast.valueOrZero(), decl))
@@ -251,7 +252,16 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
             return noModifications
         }
 
-        if(decl.type== VarDeclType.CONST || decl.type== VarDeclType.VAR) {
+        if(decl.isArray && decl.type==VarDeclType.MEMORY) {
+            val memaddr = decl.value?.constValue(program)
+            if(memaddr!=null && memaddr !== decl.value) {
+                return listOf(IAstModification.SetExpression(
+                    { decl.value = it }, memaddr, decl
+                ))
+            }
+        }
+
+        if(decl.type==VarDeclType.CONST || decl.type==VarDeclType.VAR) {
             if(decl.isArray){
                 val arraysize = decl.arraysize
                 if(arraysize==null) {
@@ -276,107 +286,10 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                         return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
                     }
                 }
-                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_W_SPLIT, DataType.ARRAY_UW_SPLIT -> {
-                    val rangeExpr = decl.value as? RangeExpression
-                    if(rangeExpr!=null) {
-                        // convert the initializer range expression to an actual array
-                        val constRange = rangeExpr.toConstantIntegerRange()
-                        if(constRange?.isEmpty()==true) {
-                            if(constRange.first>constRange.last && constRange.step>=0)
-                                errors.err("descending range with positive step", decl.value?.position!!)
-                            else if(constRange.first<constRange.last && constRange.step<=0)
-                                errors.err("ascending range with negative step", decl.value?.position!!)
-                        }
-                        val declArraySize = decl.arraysize?.constIndex()
-                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
-                            errors.err("range expression size (${rangeExpr.size()}) doesn't match declared array size ($declArraySize)", decl.value?.position!!)
-                        if(constRange!=null) {
-                            val eltType = rangeExpr.inferType(program).getOr(DataType.UBYTE)
-                            val newValue = if(eltType in ByteDatatypes) {
-                                ArrayLiteral(InferredTypes.InferredType.known(decl.datatype),
-                                        constRange.map { NumericLiteral(eltType, it.toDouble(), decl.value!!.position) }.toTypedArray(),
-                                        position = decl.value!!.position)
-                            } else {
-                                ArrayLiteral(InferredTypes.InferredType.known(decl.datatype),
-                                        constRange.map { NumericLiteral(eltType, it.toDouble(), decl.value!!.position) }.toTypedArray(),
-                                        position = decl.value!!.position)
-                            }
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
-                        }
-                    }
-                    val numericLv = decl.value as? NumericLiteral
-                    if(numericLv!=null && numericLv.type== DataType.FLOAT)
-                        errors.err("arraysize requires only integers here", numericLv.position)
-                    val size = decl.arraysize?.constIndex() ?: return noModifications
-                    if (rangeExpr==null && numericLv!=null) {
-                        // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
-                        val fillvalue = numericLv.number.toInt()
-                        when(decl.datatype){
-                            DataType.ARRAY_UB -> {
-                                if(fillvalue !in 0..255)
-                                    errors.err("ubyte value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_B -> {
-                                if(fillvalue !in -128..127)
-                                    errors.err("byte value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_UW -> {
-                                if(fillvalue !in 0..65535)
-                                    errors.err("uword value overflow", numericLv.position)
-                            }
-                            DataType.ARRAY_W -> {
-                                if(fillvalue !in -32768..32767)
-                                    errors.err("word value overflow", numericLv.position)
-                            }
-                            else -> {}
-                        }
-                        // create the array itself, filled with the fillvalue.
-                        val array = Array(size) {fillvalue}.map { NumericLiteral(ArrayToElementTypes.getValue(decl.datatype), it.toDouble(), numericLv.position) }.toTypedArray<Expression>()
-                        val refValue = ArrayLiteral(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
-                        return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
-                    }
-                }
-                DataType.ARRAY_F -> {
-                    val rangeExpr = decl.value as? RangeExpression
-                    if(rangeExpr!=null) {
-                        // convert the initializer range expression to an actual array of floats
-                        val declArraySize = decl.arraysize?.constIndex()
-                        if(declArraySize!=null && declArraySize!=rangeExpr.size())
-                            errors.err("range expression size (${rangeExpr.size()}) doesn't match declared array size ($declArraySize)", decl.value?.position!!)
-                        val constRange = rangeExpr.toConstantIntegerRange()
-                        if(constRange!=null) {
-                            val newValue = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_F),
-                                    constRange.map { NumericLiteral(DataType.FLOAT, it.toDouble(), decl.value!!.position) }.toTypedArray(),
-                                    position = decl.value!!.position)
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
-                        }
-                    }
-
-                    val numericLv = decl.value as? NumericLiteral
-                    val size = decl.arraysize?.constIndex() ?: return noModifications
-                    if(rangeExpr==null && numericLv!=null) {
-                        // arraysize initializer is a single int, and we know the size.
-                        val fillvalue = numericLv.number
-                        if (fillvalue < compTarget.machine.FLOAT_MAX_NEGATIVE || fillvalue > compTarget.machine.FLOAT_MAX_POSITIVE)
-                            errors.err("float value overflow", numericLv.position)
-                        else {
-                            // create the array itself, filled with the fillvalue.
-                            val array = Array(size) {fillvalue}.map { NumericLiteral(DataType.FLOAT, it, numericLv.position) }.toTypedArray<Expression>()
-                            val refValue = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = numericLv.position)
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
-                        }
-                    }
-                }
-                DataType.ARRAY_BOOL -> {
-                    val numericLv = decl.value as? NumericLiteral
-                    val size = decl.arraysize?.constIndex() ?: return noModifications
-                    if(numericLv!=null) {
-                        // arraysize initializer is a single int, and we know the size.
-                        val fillvalue = if(numericLv.number==0.0) 0.0 else 1.0
-                        val array = Array(size) {fillvalue}.map { NumericLiteral(DataType.UBYTE, fillvalue, numericLv.position) }.toTypedArray<Expression>()
-                        val refValue = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_BOOL), array, position = numericLv.position)
-                        return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
-                    }
+                in ArrayDatatypes -> {
+                    val replacedArrayInitializer = createConstArrayInitializerValue(decl)
+                    if(replacedArrayInitializer!=null)
+                        return listOf(IAstModification.ReplaceNode(decl.value!!, replacedArrayInitializer, decl))
                 }
                 else -> {
                     // nothing to do for this type
@@ -386,4 +299,112 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
 
         return noModifications
     }
+
+    private fun createConstArrayInitializerValue(decl: VarDecl): ArrayLiteral? {
+
+        if(decl.type==VarDeclType.MEMORY)
+            return null     // memory mapped arrays can never have an initializer value other than the address where they're mapped.
+
+        // convert the initializer range expression from a range or int, to an actual array.
+        when(decl.datatype) {
+            DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_W_SPLIT, DataType.ARRAY_UW_SPLIT -> {
+                val rangeExpr = decl.value as? RangeExpression
+                if(rangeExpr!=null) {
+                    val constRange = rangeExpr.toConstantIntegerRange()
+                    if(constRange?.isEmpty()==true) {
+                        if(constRange.first>constRange.last && constRange.step>=0)
+                            errors.err("descending range with positive step", decl.value?.position!!)
+                        else if(constRange.first<constRange.last && constRange.step<=0)
+                            errors.err("ascending range with negative step", decl.value?.position!!)
+                    }
+                    val declArraySize = decl.arraysize?.constIndex()
+                    if(declArraySize!=null && declArraySize!=rangeExpr.size())
+                        errors.err("range expression size (${rangeExpr.size()}) doesn't match declared array size ($declArraySize)", decl.value?.position!!)
+                    if(constRange!=null) {
+                        val eltType = rangeExpr.inferType(program).getOr(DataType.UBYTE)
+                        return if(eltType in ByteDatatypes) {
+                            ArrayLiteral(InferredTypes.InferredType.known(decl.datatype),
+                                constRange.map { NumericLiteral(eltType, it.toDouble(), decl.value!!.position) }.toTypedArray(),
+                                position = decl.value!!.position)
+                        } else {
+                            ArrayLiteral(InferredTypes.InferredType.known(decl.datatype),
+                                constRange.map { NumericLiteral(eltType, it.toDouble(), decl.value!!.position) }.toTypedArray(),
+                                position = decl.value!!.position)
+                        }
+                    }
+                }
+                val numericLv = decl.value as? NumericLiteral
+                if(numericLv!=null && numericLv.type== DataType.FLOAT)
+                    errors.err("arraysize requires only integers here", numericLv.position)
+                val size = decl.arraysize?.constIndex() ?: return null
+                if (rangeExpr==null && numericLv!=null) {
+                    // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
+                    val fillvalue = numericLv.number.toInt()
+                    when(decl.datatype){
+                        DataType.ARRAY_UB -> {
+                            if(fillvalue !in 0..255)
+                                errors.err("ubyte value overflow", numericLv.position)
+                        }
+                        DataType.ARRAY_B -> {
+                            if(fillvalue !in -128..127)
+                                errors.err("byte value overflow", numericLv.position)
+                        }
+                        DataType.ARRAY_UW -> {
+                            if(fillvalue !in 0..65535)
+                                errors.err("uword value overflow", numericLv.position)
+                        }
+                        DataType.ARRAY_W -> {
+                            if(fillvalue !in -32768..32767)
+                                errors.err("word value overflow", numericLv.position)
+                        }
+                        else -> {}
+                    }
+                    // create the array itself, filled with the fillvalue.
+                    val array = Array(size) {fillvalue}.map { NumericLiteral(ArrayToElementTypes.getValue(decl.datatype), it.toDouble(), numericLv.position) }.toTypedArray<Expression>()
+                    return ArrayLiteral(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
+                }
+            }
+            DataType.ARRAY_F -> {
+                val rangeExpr = decl.value as? RangeExpression
+                if(rangeExpr!=null) {
+                    // convert the initializer range expression to an actual array of floats
+                    val declArraySize = decl.arraysize?.constIndex()
+                    if(declArraySize!=null && declArraySize!=rangeExpr.size())
+                        errors.err("range expression size (${rangeExpr.size()}) doesn't match declared array size ($declArraySize)", decl.value?.position!!)
+                    val constRange = rangeExpr.toConstantIntegerRange()
+                    if(constRange!=null) {
+                        return ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_F),
+                            constRange.map { NumericLiteral(DataType.FLOAT, it.toDouble(), decl.value!!.position) }.toTypedArray(),
+                            position = decl.value!!.position)
+                    }
+                }
+
+                val numericLv = decl.value as? NumericLiteral
+                val size = decl.arraysize?.constIndex() ?: return null
+                if(rangeExpr==null && numericLv!=null) {
+                    // arraysize initializer is a single int, and we know the size.
+                    val fillvalue = numericLv.number
+                    if (fillvalue < compTarget.machine.FLOAT_MAX_NEGATIVE || fillvalue > compTarget.machine.FLOAT_MAX_POSITIVE)
+                        errors.err("float value overflow", numericLv.position)
+                    else {
+                        // create the array itself, filled with the fillvalue.
+                        val array = Array(size) {fillvalue}.map { NumericLiteral(DataType.FLOAT, it, numericLv.position) }.toTypedArray<Expression>()
+                        return ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = numericLv.position)
+                    }
+                }
+            }
+            DataType.ARRAY_BOOL -> {
+                val numericLv = decl.value as? NumericLiteral
+                val size = decl.arraysize?.constIndex() ?: return null
+                if(numericLv!=null) {
+                    // arraysize initializer is a single int, and we know the size.
+                    val fillvalue = if(numericLv.number==0.0) 0.0 else 1.0
+                    val array = Array(size) {fillvalue}.map { NumericLiteral(DataType.UBYTE, fillvalue, numericLv.position) }.toTypedArray<Expression>()
+                    return ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_BOOL), array, position = numericLv.position)
+                }
+            }
+            else -> return null
+        }
+        return null
+    }
 }

codeOptimizers/src/prog8/optimizer/Inliner.kt

@@ -34,85 +34,100 @@ class Inliner(private val program: Program, private val options: CompilationOpti
                 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]))) {
-                        // subroutine is possible candidate to be inlined
-                        subroutine.inline =
-                            when(val stmt=subroutine.statements[0]) {
-                                is Return -> {
-                                    if(stmt.value is NumericLiteral)
-                                        true
-                                    else if(stmt.value==null)
-                                        true
-                                    else if (stmt.value is IdentifierReference) {
-                                        makeFullyScoped(stmt.value as IdentifierReference)
-                                        true
-                                    } else if(stmt.value!! is IFunctionCall && (stmt.value as IFunctionCall).args.size<=1 && (stmt.value as IFunctionCall).args.all { it is NumericLiteral || it is IdentifierReference }) {
-                                        when (stmt.value) {
-                                            is BuiltinFunctionCall -> {
-                                                makeFullyScoped(stmt.value as BuiltinFunctionCall)
-                                                true
+                        if(subroutine !== program.entrypoint) {
+                            // subroutine is possible candidate to be inlined
+                            subroutine.inline =
+                                when (val stmt = subroutine.statements[0]) {
+                                    is Return -> {
+                                        if (stmt.value is NumericLiteral)
+                                            true
+                                        else if (stmt.value == null)
+                                            true
+                                        else if (stmt.value is IdentifierReference) {
+                                            makeFullyScoped(stmt.value as IdentifierReference)
+                                            true
+                                        } else if (stmt.value!! is IFunctionCall && (stmt.value as IFunctionCall).args.size <= 1 && (stmt.value as IFunctionCall).args.all { it is NumericLiteral || it is IdentifierReference }) {
+                                            when (stmt.value) {
+                                                is BuiltinFunctionCall -> {
+                                                    makeFullyScoped(stmt.value as BuiltinFunctionCall)
+                                                    true
+                                                }
+
+                                                is FunctionCallExpression -> {
+                                                    makeFullyScoped(stmt.value as FunctionCallExpression)
+                                                    true
+                                                }
+
+                                                else -> false
                                             }
-                                            is FunctionCallExpression -> {
-                                                makeFullyScoped(stmt.value as FunctionCallExpression)
-                                                true
-                                            }
-                                            else -> false
-                                        }
-                                    } else
-                                        false
-                                }
-                                is Assignment -> {
-                                    if(stmt.value.isSimple) {
-                                        val targetInline =
-                                            if(stmt.target.identifier!=null) {
-                                                makeFullyScoped(stmt.target.identifier!!)
-                                                true
-                                            } else if(stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
-                                                if(stmt.target.memoryAddress?.addressExpression is IdentifierReference)
-                                                    makeFullyScoped(stmt.target.memoryAddress?.addressExpression as IdentifierReference)
-                                                true
-                                            } else
-                                                false
-                                        val valueInline =
-                                            if(stmt.value is IdentifierReference) {
-                                                makeFullyScoped(stmt.value as IdentifierReference)
-                                                true
-                                            } else if((stmt.value as? DirectMemoryRead)?.addressExpression is NumericLiteral || (stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference) {
-                                                if((stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference)
-                                                    makeFullyScoped((stmt.value as? DirectMemoryRead)?.addressExpression as IdentifierReference)
-                                                true
-                                            } else
-                                                false
-                                        targetInline || valueInline
-                                    } else
-                                        false
-                                }
-                                is BuiltinFunctionCallStatement -> {
-                                    val inline = stmt.args.size<=1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
-                                    if(inline)
-                                        makeFullyScoped(stmt)
-                                    inline
-                                }
-                                is FunctionCallStatement -> {
-                                    val inline = stmt.args.size<=1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
-                                    if(inline)
-                                        makeFullyScoped(stmt)
-                                    inline
-                                }
-                                is PostIncrDecr -> {
-                                    if(stmt.target.identifier!=null) {
-                                        makeFullyScoped(stmt.target.identifier!!)
-                                        true
+                                        } else
+                                            false
                                     }
-                                    else if(stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
-                                        if(stmt.target.memoryAddress?.addressExpression is IdentifierReference)
-                                            makeFullyScoped(stmt.target.memoryAddress?.addressExpression as IdentifierReference)
-                                        true
-                                    } else
-                                        false
+
+                                    is Assignment -> {
+                                        if (stmt.value.isSimple) {
+                                            val targetInline =
+                                                if (stmt.target.identifier != null) {
+                                                    makeFullyScoped(stmt.target.identifier!!)
+                                                    true
+                                                } else if (stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
+                                                    if (stmt.target.memoryAddress?.addressExpression is IdentifierReference)
+                                                        makeFullyScoped(stmt.target.memoryAddress?.addressExpression as IdentifierReference)
+                                                    true
+                                                } else
+                                                    false
+                                            val valueInline =
+                                                if (stmt.value is IdentifierReference) {
+                                                    makeFullyScoped(stmt.value as IdentifierReference)
+                                                    true
+                                                } else if ((stmt.value as? DirectMemoryRead)?.addressExpression is NumericLiteral || (stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference) {
+                                                    if ((stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference)
+                                                        makeFullyScoped((stmt.value as? DirectMemoryRead)?.addressExpression as IdentifierReference)
+                                                    true
+                                                } else
+                                                    false
+                                            targetInline || valueInline
+                                        } else
+                                            false
+                                    }
+
+                                    is BuiltinFunctionCallStatement -> {
+                                        val inline =
+                                            stmt.args.size <= 1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
+                                        if (inline)
+                                            makeFullyScoped(stmt)
+                                        inline
+                                    }
+
+                                    is FunctionCallStatement -> {
+                                        val inline =
+                                            stmt.args.size <= 1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
+                                        if (inline)
+                                            makeFullyScoped(stmt)
+                                        inline
+                                    }
+
+                                    is PostIncrDecr -> {
+                                        if (stmt.target.identifier != null) {
+                                            makeFullyScoped(stmt.target.identifier!!)
+                                            true
+                                        } else if (stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
+                                            if (stmt.target.memoryAddress?.addressExpression is IdentifierReference)
+                                                makeFullyScoped(stmt.target.memoryAddress?.addressExpression as IdentifierReference)
+                                            true
+                                        } else
+                                            false
+                                    }
+
+                                    is Jump -> true
+                                    else -> false
                                 }
-                                is Jump -> true
-                                else -> false
-                            }
+                        }
+                    }
+
+                    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.
                     }
                 }
             }
@@ -129,16 +144,20 @@ class Inliner(private val program: Program, private val options: CompilationOpti
 
         private fun makeFullyScoped(call: BuiltinFunctionCallStatement) {
             val scopedArgs = makeScopedArgs(call.args)
-            val scopedCall = BuiltinFunctionCallStatement(call.target.copy(), scopedArgs.toMutableList(), call.position)
-            modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+            if(scopedArgs.any()) {
+                val scopedCall = BuiltinFunctionCallStatement(call.target.copy(), scopedArgs.toMutableList(), call.position)
+                modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+            }
         }
 
         private fun makeFullyScoped(call: FunctionCallStatement) {
             call.target.targetSubroutine(program)?.let { sub ->
                 val scopedName = IdentifierReference(sub.scopedName, call.target.position)
                 val scopedArgs = makeScopedArgs(call.args)
-                val scopedCall = FunctionCallStatement(scopedName, scopedArgs.toMutableList(), call.void, call.position)
-                modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+                if(scopedArgs.any()) {
+                    val scopedCall = FunctionCallStatement(scopedName, scopedArgs.toMutableList(), call.void, call.position)
+                    modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+                }
             }
         }
 
@@ -146,8 +165,10 @@ class Inliner(private val program: Program, private val options: CompilationOpti
             call.target.targetSubroutine(program)?.let { sub ->
                 val scopedName = IdentifierReference(sub.scopedName, call.target.position)
                 val scopedArgs = makeScopedArgs(call.args)
-                val scopedCall = BuiltinFunctionCall(scopedName, scopedArgs.toMutableList(), call.position)
-                modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+                if(scopedArgs.any()) {
+                    val scopedCall = BuiltinFunctionCall(scopedName, scopedArgs.toMutableList(), call.position)
+                    modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+                }
             }
         }
 
@@ -155,8 +176,10 @@ class Inliner(private val program: Program, private val options: CompilationOpti
             call.target.targetSubroutine(program)?.let { sub ->
                 val scopedName = IdentifierReference(sub.scopedName, call.target.position)
                 val scopedArgs = makeScopedArgs(call.args)
-                val scopedCall = FunctionCallExpression(scopedName, scopedArgs.toMutableList(), call.position)
-                modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+                if(scopedArgs.any()) {
+                    val scopedCall = FunctionCallExpression(scopedName, scopedArgs.toMutableList(), call.position)
+                    modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+                }
             }
         }
 
@@ -165,7 +188,8 @@ class Inliner(private val program: Program, private val options: CompilationOpti
                 when (it) {
                     is NumericLiteral -> it.copy()
                     is IdentifierReference -> {
-                        val scoped = (it.targetStatement(program)!! as INamedStatement).scopedName
+                        val target = it.targetStatement(program) ?: return emptyList()
+                        val scoped = (target as INamedStatement).scopedName
                         IdentifierReference(scoped, it.position)
                     }
                     else -> throw InternalCompilerException("expected only number or identifier arg, otherwise too complex")

codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt

@@ -30,7 +30,7 @@ class StatementOptimizer(private val program: Program,
         if(functionCallStatement.target.nameInSource==listOf("txt", "print")) {
             val arg = functionCallStatement.args.single()
             val stringVar: IdentifierReference? = if(arg is AddressOf) {
-                arg.identifier
+                if(arg.arrayIndex==null) arg.identifier else null
             } else {
                 arg as? IdentifierReference
             }
@@ -45,11 +45,7 @@ class StatementOptimizer(private val program: Program,
                             mutableListOf(NumericLiteral(DataType.UBYTE, firstCharEncoded.toDouble(), pos)),
                             functionCallStatement.void, pos
                         )
-                        val stringDecl = string.parent as VarDecl
-                        return listOf(
-                            IAstModification.ReplaceNode(functionCallStatement, chrout, parent),
-                            IAstModification.Remove(stringDecl, stringDecl.parent as IStatementContainer)
-                        )
+                        return listOf(IAstModification.ReplaceNode(functionCallStatement, chrout, parent))
                     } else if (string.value.length == 2) {
                         val firstTwoCharsEncoded = options.compTarget.encodeString(string.value.take(2), string.encoding)
                         val chrout1 = FunctionCallStatement(
@@ -62,11 +58,9 @@ class StatementOptimizer(private val program: Program,
                             mutableListOf(NumericLiteral(DataType.UBYTE, firstTwoCharsEncoded[1].toDouble(), pos)),
                             functionCallStatement.void, pos
                         )
-                        val stringDecl = string.parent as VarDecl
                         return listOf(
                             IAstModification.InsertBefore(functionCallStatement, chrout1, parent as IStatementContainer),
-                            IAstModification.ReplaceNode(functionCallStatement, chrout2, parent),
-                            IAstModification.Remove(stringDecl, stringDecl.parent as IStatementContainer)
+                            IAstModification.ReplaceNode(functionCallStatement, chrout2, parent)
                         )
                     }
                 }
@@ -77,6 +71,11 @@ class StatementOptimizer(private val program: Program,
     }
 
     override fun after(ifElse: IfElse, parent: Node): Iterable<IAstModification> {
+        val constvalue = ifElse.condition.constValue(program)
+        if(constvalue!=null) {
+            errors.warn("condition is always ${constvalue.asBooleanValue}", ifElse.condition.position)
+        }
+
         // remove empty if statements
         if(ifElse.truepart.isEmpty() && ifElse.elsepart.isEmpty())
             return listOf(IAstModification.Remove(ifElse, parent as IStatementContainer))
@@ -93,17 +92,12 @@ class StatementOptimizer(private val program: Program,
             )
         }
 
-        val constvalue = ifElse.condition.constValue(program)
         if(constvalue!=null) {
             return if(constvalue.asBooleanValue){
                 // always true -> keep only if-part
-                if(!ifElse.definingModule.isLibrary)
-                    errors.warn("condition is always true", ifElse.condition.position)
                 listOf(IAstModification.ReplaceNode(ifElse, ifElse.truepart, parent))
             } else {
                 // always false -> keep only else-part
-                if(!ifElse.definingModule.isLibrary)
-                    errors.warn("condition is always false", ifElse.condition.position)
                 listOf(IAstModification.ReplaceNode(ifElse, ifElse.elsepart, parent))
             }
         }
@@ -174,6 +168,70 @@ class StatementOptimizer(private val program: Program,
             }
         }
 
+        val loopvarDt = forLoop.loopVarDt(program)
+        if(loopvarDt.istype(DataType.UWORD) || loopvarDt.istype(DataType.UBYTE)) {
+            if (range != null && range.from.constValue(program)?.number == 0.0 && range.step.constValue(program)?.number==1.0) {
+                val toBinExpr = range.to as? BinaryExpression
+                if(toBinExpr!=null && toBinExpr.operator=="-" && toBinExpr.right.constValue(program)?.number==1.0) {
+                    // FOR var IN 0 TO X-1 .... ---> var=0, DO {... , var++} UNTIL var==X
+                    val pos = forLoop.position
+                    val condition = BinaryExpression(forLoop.loopVar.copy(), "==", toBinExpr.left, pos)
+                    val incOne = PostIncrDecr(AssignTarget(forLoop.loopVar.copy(), null, null, pos), "++", pos)
+                    forLoop.body.statements.add(incOne)
+                    val replacement = AnonymousScope(mutableListOf(
+                        Assignment(AssignTarget(forLoop.loopVar.copy(), null, null, pos),
+                            NumericLiteral.optimalNumeric(0.0, pos),
+                            AssignmentOrigin.OPTIMIZER, pos),
+                        UntilLoop(forLoop.body, condition, pos)
+                    ), pos)
+                    return listOf(IAstModification.ReplaceNode(forLoop, replacement, parent))
+                }
+
+                if(options.compTarget.name!=VMTarget.NAME) {
+                    // this optimization is not effective for the VM target.
+                    val toConst = range.to.constValue(program)
+                    if (toConst == null) {
+                        // FOR var in 0 TO X ... --->  var=0, REPEAT { ... , IF var==X break , var++ }
+                        val pos = forLoop.position
+                        val incOne = PostIncrDecr(AssignTarget(forLoop.loopVar.copy(), null, null, pos), "++", pos)
+                        val breakCondition = IfElse(
+                            BinaryExpression(forLoop.loopVar, "==", range.to, pos),
+                            AnonymousScope(mutableListOf(Break(pos)), pos),
+                            AnonymousScope(mutableListOf(), pos),
+                            pos
+                        )
+                        forLoop.body.statements.add(breakCondition)
+                        forLoop.body.statements.add(incOne)
+                        val replacement = AnonymousScope(mutableListOf(
+                            Assignment(AssignTarget(forLoop.loopVar.copy(), null, null, pos),
+                                NumericLiteral.optimalNumeric(0.0, pos),
+                                AssignmentOrigin.OPTIMIZER, pos),
+                            RepeatLoop(null, forLoop.body, pos)
+                        ), pos)
+                        return listOf(IAstModification.ReplaceNode(forLoop, replacement, parent))
+                    }
+                }
+            }
+
+            if (range != null && range.to.constValue(program)?.number == 0.0 && range.step.constValue(program)?.number==-1.0) {
+                val fromExpr = range.from
+                if(fromExpr.constValue(program)==null) {
+                    // FOR X = something DOWNTO 0 {...} -->  X=something,  DO { ... , X-- } UNTIL X=255 (or 65535 if uword)
+                    val pos = forLoop.position
+                    val checkValue = NumericLiteral(loopvarDt.getOr(DataType.UNDEFINED), if(loopvarDt.istype(DataType.UBYTE)) 255.0 else 65535.0, pos)
+                    val condition = BinaryExpression(forLoop.loopVar.copy(), "==", checkValue, pos)
+                    val decOne = PostIncrDecr(AssignTarget(forLoop.loopVar.copy(), null, null, pos), "--", pos)
+                    forLoop.body.statements.add(decOne)
+                    val replacement = AnonymousScope(mutableListOf(
+                        Assignment(AssignTarget(forLoop.loopVar.copy(), null, null, pos),
+                            fromExpr, AssignmentOrigin.OPTIMIZER, pos),
+                        UntilLoop(forLoop.body, condition, pos)
+                    ), pos)
+                    return listOf(IAstModification.ReplaceNode(forLoop, replacement, parent))
+                }
+            }
+        }
+
         return noModifications
     }
 
@@ -430,6 +488,27 @@ class StatementOptimizer(private val program: Program,
                 }
             }
         }
+
+        val constantValue = whenStmt.condition.constValue(program)?.number
+        if(constantValue!=null) {
+            // when condition is a constant
+            var matchingChoice: WhenChoice? = null
+            loop@ for(choice in whenStmt.choices) {
+                for(value in choice.values ?: emptyList()) {
+                    if(value.constValue(program)?.number == constantValue) {
+                        matchingChoice = choice
+                        break@loop
+                    }
+                }
+            }
+            if(matchingChoice==null)
+                matchingChoice = whenStmt.choices.singleOrNull { it.values==null }
+            if(matchingChoice!=null) {
+                // get rid of the whole when-statement and just leave the matching choice
+                return listOf(IAstModification.ReplaceNode(whenStmt, matchingChoice.statements, parent))
+            }
+        }
+
         return noModifications
     }
 

codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -99,7 +99,7 @@ class UnusedCodeRemover(private val program: Program,
                     }
                     return removals
                 }
-                if(!subroutine.definingModule.isLibrary && !subroutine.hasBeenInlined) {
+                if(!subroutine.hasBeenInlined && subroutine.definingModule===program.toplevelModule) {
                     errors.warn("unused subroutine '${subroutine.name}'", subroutine.position)
                 }
                 if(!subroutine.inline) {
@@ -139,13 +139,20 @@ class UnusedCodeRemover(private val program: Program,
                                     )
                                 } else if(assignment.value is IFunctionCall) {
                                     // replace the unused variable's initializer function call by a void
-                                    errors.warn("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(
-                                        IAstModification.ReplaceNode(decl, voidCall, parent),
-                                        IAstModification.Remove(assignment, assignment.parent as IStatementContainer)
-                                    )
+                                    // but only if the vardecl immediately precedes it!
+                                    if(singleUse.parent.parent === parent) {
+                                        val declIndex = (parent as IStatementContainer).statements.indexOf(decl)
+                                        val singleUseIndex = (parent as IStatementContainer).statements.indexOf(singleUse.parent)
+                                        if(declIndex==singleUseIndex-1) {
+                                            errors.warn("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(
+                                                IAstModification.ReplaceNode(decl, voidCall, parent),
+                                                IAstModification.Remove(assignment, assignment.parent as IStatementContainer)
+                                            )
+                                        }
+                                    }
                                 } else {
                                     errors.warn("variable '${decl.name}' is unused but has non-trivial initialization assignment. Leaving this in but maybe it can be removed altogether", decl.position)
                                 }

compiler/build.gradle

@@ -33,14 +33,14 @@ dependencies {
     implementation project(':codeGenIntermediate')
     implementation project(':codeGenExperimental')
     implementation project(':virtualmachine')
-    implementation "org.antlr:antlr4-runtime:4.12.0"
+    implementation "org.antlr:antlr4-runtime:4.13.1"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.5'
+    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.6'
     implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
 
     testImplementation project(':intermediate')
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.6.2'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
 }
 
 configurations.all {
@@ -59,10 +59,10 @@ configurations {
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
     test {

compiler/res/prog8lib/atari/syslib.p8

@@ -8,6 +8,13 @@ atari {
         &uword  RESET_VEC       = $FFFC     ; 6502 reset vector, determined by the kernal if banked in
         &uword  IRQ_VEC         = $FFFE     ; 6502 interrupt vector, determined by the kernal if banked in
 
+        &uword COLCRS = 85
+        &ubyte ROWCRS = 84
+
+    romsub $F24A = getchar() -> ubyte @A
+    romsub $F2B0 = outchar(ubyte character @ A)
+    romsub $F2FD = waitkey() -> ubyte @A
+
 }
 
 sys {
@@ -198,6 +205,54 @@ _longcopy
         }}
     }
 
+    sub disable_caseswitch() {
+        ; no-op
+    }
+
+    sub enable_caseswitch() {
+        ; no-op
+    }
+
+    asmsub save_prog8_internals() {
+        %asm {{
+            lda  P8ZP_SCRATCH_B1
+            sta  save_SCRATCH_ZPB1
+            lda  P8ZP_SCRATCH_REG
+            sta  save_SCRATCH_ZPREG
+            lda  P8ZP_SCRATCH_W1
+            sta  save_SCRATCH_ZPWORD1
+            lda  P8ZP_SCRATCH_W1+1
+            sta  save_SCRATCH_ZPWORD1+1
+            lda  P8ZP_SCRATCH_W2
+            sta  save_SCRATCH_ZPWORD2
+            lda  P8ZP_SCRATCH_W2+1
+            sta  save_SCRATCH_ZPWORD2+1
+            rts
+save_SCRATCH_ZPB1	.byte  0
+save_SCRATCH_ZPREG	.byte  0
+save_SCRATCH_ZPWORD1	.word  0
+save_SCRATCH_ZPWORD2	.word  0
+        }}
+    }
+
+    asmsub restore_prog8_internals() {
+        %asm {{
+            lda  save_prog8_internals.save_SCRATCH_ZPB1
+            sta  P8ZP_SCRATCH_B1
+            lda  save_prog8_internals.save_SCRATCH_ZPREG
+            sta  P8ZP_SCRATCH_REG
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1
+            sta  P8ZP_SCRATCH_W1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1+1
+            sta  P8ZP_SCRATCH_W1+1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2
+            sta  P8ZP_SCRATCH_W2
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2+1
+            sta  P8ZP_SCRATCH_W2+1
+            rts
+        }}
+    }
+
     inline asmsub exit(ubyte returnvalue @A) {
         ; -- immediately exit the program with a return code in the A register
         ;    TODO

compiler/res/prog8lib/atari/textio.p8

@@ -1,4 +1,5 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the Atari 800XL
+; Reference:  https://www.atariarchives.org/mapping/appendix12.php
 
 %import syslib
 %import conv
@@ -24,12 +25,22 @@ sub spc() {
     txt.chrout(' ')
 }
 
-asmsub column(ubyte col @A) clobbers(A, X, Y) {
+sub column(ubyte col) {
     ; ---- set the cursor on the given column (starting with 0) on the current line
-    ;      TODO
-    %asm {{
-        rts
-    }}
+    atari.COLCRS = col
+}
+
+sub get_column() -> ubyte {
+    return atari.COLCRS as ubyte
+}
+
+sub row(ubyte rownum) {
+    ; ---- set the cursor on the given row (starting with 0) on the current line
+    atari.ROWCRS = rownum
+}
+
+sub get_row() -> ubyte {
+    return atari.ROWCRS
 }
 
 asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A)  {
@@ -114,9 +125,6 @@ asmsub  scroll_down  (bool alsocolors @ Pc) clobbers(A)  {
 }
 
 
-romsub $F2B0 = outchar(ubyte character @ A)
-romsub $F2Fd = waitkey()
-
 asmsub chrout(ubyte character @ A) {
 	%asm {{
 		sta  _tmp_outchar+1
@@ -126,7 +134,7 @@ asmsub chrout(ubyte character @ A) {
 		pha
 _tmp_outchar
 		lda  #0
-		jsr  outchar
+		jsr  atari.outchar
 		pla
 		tay
 		pla
@@ -372,12 +380,20 @@ sub  setcc  (ubyte col, ubyte row, ubyte char, ubyte charcolor)  {
         }}
 }
 
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) {
-	; ---- set cursor at specific position
-	; TODO
-	%asm  {{
-	    rts
-	}}
+sub  plot(ubyte col, ubyte rownum) {
+    column(col)
+    row(rownum)
+}
+
+sub get_cursor(uword colptr, uword rowptr) {
+    @(colptr) = get_column()
+    @(rowptr) = get_row()
+}
+
+asmsub waitkey() -> ubyte @A {
+    %asm {{
+        jmp  atari.waitkey
+    }}
 }
 
 asmsub width() clobbers(X,Y) -> ubyte @A {

compiler/res/prog8lib/c128/graphics.p8

@@ -1,62 +0,0 @@
-%import syslib
-%import textio
-
-; Bitmap pixel graphics module for the Commodore 128
-
-; TODO c128 actually implement the graphics routines. Ideally a way to 'borrow' the code form the C64 version without just copy-pasting that here?
-
-graphics {
-    %option no_symbol_prefixing
-
-    const uword WIDTH = 320
-    const ubyte HEIGHT = 200
-
-    sub enable_bitmap_mode() {
-        ; enable bitmap screen, erase it and set colors to black/white.
-        ; TODO
-    }
-
-    sub disable_bitmap_mode() {
-        ; enables text mode, erase the text screen, color white
-        ; TODO
-    }
-
-
-    sub clear_screen(ubyte pixelcolor, ubyte bgcolor) {
-        ; TODO
-    }
-
-    sub line(uword @zp x1, ubyte @zp y1, uword @zp x2, ubyte @zp y2) {
-        ; TODO
-    }
-
-    sub fillrect(uword x, uword y, uword width, uword height) {
-        ; TODO
-    }
-
-    sub rect(uword x, uword y, uword width, uword height) {
-        ; TODO
-    }
-
-    sub horizontal_line(uword x, uword y, uword length) {
-        ; TODO
-    }
-
-    sub vertical_line(uword x, uword y, uword height) {
-        ; TODO
-    }
-
-    sub circle(uword xcenter, ubyte ycenter, ubyte radius) {
-        ; TODO
-    }
-
-    sub disc(uword xcenter, ubyte ycenter, ubyte radius) {
-        ; TODO
-    }
-
-    inline asmsub  plot(uword plotx @R0, uword ploty @R1) clobbers(A, X, Y) {
-        %asm {{
-            nop     ; TODO
-        }}
-    }
-}

compiler/res/prog8lib/c128/syslib.p8

@@ -391,77 +391,78 @@ asmsub  enable_runstop_and_charsetswitch() clobbers(A) {
     }}
 }
 
-asmsub  set_irq(uword handler @AY, bool useKernal @Pc) clobbers(A)  {
+    asmsub save_prog8_internals() {
+        %asm {{
+            lda  P8ZP_SCRATCH_B1
+            sta  save_SCRATCH_ZPB1
+            lda  P8ZP_SCRATCH_REG
+            sta  save_SCRATCH_ZPREG
+            lda  P8ZP_SCRATCH_W1
+            sta  save_SCRATCH_ZPWORD1
+            lda  P8ZP_SCRATCH_W1+1
+            sta  save_SCRATCH_ZPWORD1+1
+            lda  P8ZP_SCRATCH_W2
+            sta  save_SCRATCH_ZPWORD2
+            lda  P8ZP_SCRATCH_W2+1
+            sta  save_SCRATCH_ZPWORD2+1
+            rts
+save_SCRATCH_ZPB1	.byte  0
+save_SCRATCH_ZPREG	.byte  0
+save_SCRATCH_ZPWORD1	.word  0
+save_SCRATCH_ZPWORD2	.word  0
+        }}
+    }
+
+    asmsub restore_prog8_internals() {
+        %asm {{
+            lda  save_prog8_internals.save_SCRATCH_ZPB1
+            sta  P8ZP_SCRATCH_B1
+            lda  save_prog8_internals.save_SCRATCH_ZPREG
+            sta  P8ZP_SCRATCH_REG
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1
+            sta  P8ZP_SCRATCH_W1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1+1
+            sta  P8ZP_SCRATCH_W1+1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2
+            sta  P8ZP_SCRATCH_W2
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2+1
+            sta  P8ZP_SCRATCH_W2+1
+            rts
+        }}
+    }
+
+asmsub  set_irq(uword handler @AY) clobbers(A)  {
 	%asm {{
-	        sta  _modified+1
-	        sty  _modified+2
-	        lda  #0
-	        rol  a
-	        sta  _use_kernal
 		sei
+        sta  _modified+1
+        sty  _modified+2
 		lda  #<_irq_handler
 		sta  cbm.CINV
 		lda  #>_irq_handler
 		sta  cbm.CINV+1
 		cli
 		rts
-_irq_handler    jsr  _irq_handler_init
-_modified	jsr  $ffff                      ; modified
-		jsr  _irq_handler_end
-		lda  _use_kernal
-		bne  +
-		lda  #$ff
+_irq_handler
+        jsr  sys.save_prog8_internals
+        cld
+_modified
+        jsr  $ffff                      ; modified
+        pha
+        jsr  sys.restore_prog8_internals
+        pla
+        beq  +
+		jmp  cbm.IRQDFRT		; continue with normal kernal irq routine
++		lda  #$ff
 		sta  c64.VICIRQ			; acknowledge raster irq
 		lda  c64.CIA1ICR		; acknowledge CIA1 interrupt
-		; end irq processing - don't use kernal's irq handling
 		pla
 		tay
 		pla
 		tax
 		pla
 		rti
-+		jmp  cbm.IRQDFRT		; continue with normal kernal irq routine
 
 _use_kernal     .byte  0
-
-_irq_handler_init
-		; save all zp scratch registers as these might be clobbered by the irq routine
-		lda  P8ZP_SCRATCH_B1
-		sta  IRQ_SCRATCH_ZPB1
-		lda  P8ZP_SCRATCH_REG
-		sta  IRQ_SCRATCH_ZPREG
-		lda  P8ZP_SCRATCH_W1
-		sta  IRQ_SCRATCH_ZPWORD1
-		lda  P8ZP_SCRATCH_W1+1
-		sta  IRQ_SCRATCH_ZPWORD1+1
-		lda  P8ZP_SCRATCH_W2
-		sta  IRQ_SCRATCH_ZPWORD2
-		lda  P8ZP_SCRATCH_W2+1
-		sta  IRQ_SCRATCH_ZPWORD2+1
-		cld
-		rts
-
-_irq_handler_end
-		; restore all zp scratch registers
-		lda  IRQ_SCRATCH_ZPB1
-		sta  P8ZP_SCRATCH_B1
-		lda  IRQ_SCRATCH_ZPREG
-		sta  P8ZP_SCRATCH_REG
-		lda  IRQ_SCRATCH_ZPWORD1
-		sta  P8ZP_SCRATCH_W1
-		lda  IRQ_SCRATCH_ZPWORD1+1
-		sta  P8ZP_SCRATCH_W1+1
-		lda  IRQ_SCRATCH_ZPWORD2
-		sta  P8ZP_SCRATCH_W2
-		lda  IRQ_SCRATCH_ZPWORD2+1
-		sta  P8ZP_SCRATCH_W2+1
-		rts
-
-IRQ_SCRATCH_ZPB1	.byte  0
-IRQ_SCRATCH_ZPREG	.byte  0
-IRQ_SCRATCH_ZPWORD1	.word  0
-IRQ_SCRATCH_ZPWORD2	.word  0
-
 		}}
 }
 
@@ -481,40 +482,39 @@ asmsub  restore_irq() clobbers(A) {
 	}}
 }
 
-asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0, bool useKernal @Pc) clobbers(A) {
+asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0) clobbers(A) {
 	%asm {{
-	        sta  _modified+1
-	        sty  _modified+2
-	        lda  #0
-	        rol  a
-	        sta  set_irq._use_kernal
-		lda  cx16.r0
-		ldy  cx16.r0+1
-		sei
-		jsr  _setup_raster_irq
-		lda  #<_raster_irq_handler
-		sta  cbm.CINV
-		lda  #>_raster_irq_handler
-		sta  cbm.CINV+1
-		cli
-		rts
+        sei
+        sta  _modified+1
+        sty  _modified+2
+        lda  cx16.r0
+        ldy  cx16.r0+1
+        jsr  _setup_raster_irq
+        lda  #<_raster_irq_handler
+        sta  cbm.CINV
+        lda  #>_raster_irq_handler
+        sta  cbm.CINV+1
+        cli
+        rts
 
 _raster_irq_handler
-		jsr  set_irq._irq_handler_init
-_modified	jsr  $ffff              ; modified
-		jsr  set_irq._irq_handler_end
+		jsr  sys.save_prog8_internals
+		cld
+_modified
+        jsr  $ffff              ; modified
+        pha
+		jsr  sys.restore_prog8_internals
         lda  #$ff
         sta  c64.VICIRQ			; acknowledge raster irq
-		lda  set_irq._use_kernal
-		bne  +
-		; end irq processing - don't use kernal's irq handling
 		pla
+		beq  +
+		jmp  cbm.IRQDFRT        ; continue with kernal irq routine
++		pla
 		tay
 		pla
 		tax
 		pla
 		rti
-+		jmp  cbm.IRQDFRT                ; continue with kernal irq routine
 
 _setup_raster_irq
 		pha
@@ -734,6 +734,20 @@ _longcopy
         }}
     }
 
+    inline asmsub disable_caseswitch() {
+        %asm {{
+            lda  #$80
+            sta  247
+        }}
+    }
+
+    inline asmsub enable_caseswitch() {
+        %asm {{
+            lda  #0
+            sta  247
+        }}
+    }
+
     inline asmsub exit(ubyte returnvalue @A) {
         ; -- immediately exit the program with a return code in the A register
         %asm {{

compiler/res/prog8lib/c128/textio.p8

@@ -1,4 +1,6 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the Commodore-128
+; All routines work with Screencode character encoding, except `print`, `chrout` and `input_chars`,
+; these work with PETSCII encoding instead.
 
 %import syslib
 %import conv
@@ -38,6 +40,45 @@ asmsub column(ubyte col @A) clobbers(A, X, Y) {
     }}
 }
 
+
+asmsub get_column() -> ubyte @Y {
+    %asm {{
+        sec
+        jmp cbm.PLOT
+    }}
+}
+
+asmsub row(ubyte rownum @A) clobbers(A, X, Y) {
+    ; ---- set the cursor on the given row (starting with 0) on the current line
+    %asm {{
+        sec
+        jsr  cbm.PLOT
+        tax
+        clc
+        jmp  cbm.PLOT
+    }}
+}
+
+asmsub get_row() -> ubyte @X {
+    %asm {{
+        sec
+        jmp cbm.PLOT
+    }}
+}
+
+sub get_cursor(uword colptr, uword rowptr) {
+    %asm {{
+        sec
+        jsr cbm.PLOT
+        tya
+        ldy #$00
+        sta (colptr),y
+        txa
+        sta (rowptr),y
+    }}
+}
+
+
 asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
 	; ---- fill the character screen with the given fill character and character color.
 	;      (assumes screen and color matrix are at their default addresses)
@@ -238,10 +279,10 @@ _scroll_screen  ; scroll only the screen memory
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte char @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
+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 from 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.
@@ -427,7 +468,8 @@ asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 }
 
 asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
-	; ---- Input a string (max. 80 chars) from the keyboard. Returns length in Y. (string is terminated with a 0 byte as well)
+	; ---- 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 {{
@@ -584,4 +626,11 @@ asmsub height() clobbers(X, Y) -> ubyte @A {
     }}
 }
 
+asmsub waitkey() -> ubyte @A {
+    %asm {{
+-       jsr cbm.GETIN
+        beq -
+        rts
+    }}
+}
 }

compiler/res/prog8lib/c64/floats.p8

@@ -7,8 +7,9 @@ floats {
 	; ---- this block contains C-64 floating point related functions ----
     %option no_symbol_prefixing
 
-        const float  PI     = 3.141592653589793
-        const float  TWOPI  = 6.283185307179586
+        const float  π      = 3.141592653589793
+        const float  PI     = π
+        const float  TWOPI  = 2*π
 
 
 ; ---- C64 basic and kernal ROM float constants and functions ----
@@ -52,7 +53,7 @@ romsub $bddd = FOUT() clobbers(X) -> uword @ AY             ; fac1 -> string, ad
 
 romsub $b849 = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for 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!
+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
 
 romsub $b86a = FADDT() clobbers(A,X,Y)                      ; fac1 += fac2
@@ -77,6 +78,7 @@ romsub $bf71 = SQR() clobbers(A,X,Y)                        ; fac1 = SQRT(fac1)
 romsub $bf74 = SQRA() clobbers(A,X,Y)                       ; fac1 = SQRT(fac2)
 romsub $bfed = EXP() clobbers(A,X,Y)                        ; fac1 = EXP(fac1)  (e ** fac1)
 romsub $bfb4 = NEGOP() clobbers(A)                          ; switch the sign of fac1 (fac1 = -fac1)
+romsub $b8d7 = NORMAL() clobbers(A)                         ; normalize FAC1
 romsub $e097 = RND() clobbers(A,X,Y)                        ; fac1 = RND(fac1) float random number generator
 romsub $e264 = COS() clobbers(A,X,Y)                        ; fac1 = COS(fac1)
 romsub $e26b = SIN() clobbers(A,X,Y)                        ; fac1 = SIN(fac1)
@@ -175,6 +177,12 @@ asmsub parse_f(str value @AY) -> float @FAC1 {
     }}
 }
 
+asmsub normalize(float value @FAC1) -> float @ FAC1 {
+    %asm {{
+        jmp  floats.NORMAL
+    }}
+}
+
 
 %asminclude "library:c64/floats.asm"
 %asminclude "library:c64/floats_funcs.asm"

compiler/res/prog8lib/c64/graphics.p8

@@ -1,6 +1,9 @@
 ; bitmap pixel graphics module for the C64
 ; only black/white monochrome 320x200 for now
 ;
+; 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!
+;
 ; Sets character matrix and bitmap screen memory at a higher memory location $5c00-$7fff
 ; so that the program itself can be larger without starting to overwrite the graphics memory.
 
@@ -244,7 +247,8 @@ hline_zero2
     }
 
     sub circle(uword xcenter, ubyte ycenter, ubyte radius) {
-        ; Midpoint algorithm
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
+        ; Midpoint algorithm.
         if radius==0
             return
         ubyte @zp ploty
@@ -273,16 +277,17 @@ hline_zero2
             internal_plotx = xcenter - yy
             internal_plot(ploty)
             yy++
-            if decisionOver2<=0
-                decisionOver2 += (yy as word)*2+1
-            else {
+            if decisionOver2>=0 {
                 radius--
-                decisionOver2 += (yy as word -radius)*2+1
+                decisionOver2 -= radius*$0002
             }
+            decisionOver2 += yy*$0002
+            decisionOver2++
         }
     }
 
     sub disc(uword xcenter, ubyte ycenter, ubyte radius) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
         ; Midpoint algorithm, filled
         if radius==0
             return
@@ -295,12 +300,12 @@ hline_zero2
             horizontal_line(xcenter-yy, ycenter+radius, yy*2+1)
             horizontal_line(xcenter-yy, ycenter-radius, yy*2+1)
             yy++
-            if decisionOver2<=0
-                decisionOver2 += (yy as word)*2+1
-            else {
+            if decisionOver2>=0 {
                 radius--
-                decisionOver2 += (yy as word -radius)*2+1
+                decisionOver2 -= radius*$0002
             }
+            decisionOver2 += yy*$0002
+            decisionOver2++
         }
     }
 

compiler/res/prog8lib/c64/syslib.p8

@@ -393,78 +393,77 @@ asmsub  enable_runstop_and_charsetswitch() clobbers(A) {
     }}
 }
 
-asmsub  set_irq(uword handler @AY, bool useKernal @Pc) clobbers(A)  {
+    asmsub save_prog8_internals() {
+        %asm {{
+            lda  P8ZP_SCRATCH_B1
+            sta  save_SCRATCH_ZPB1
+            lda  P8ZP_SCRATCH_REG
+            sta  save_SCRATCH_ZPREG
+            lda  P8ZP_SCRATCH_W1
+            sta  save_SCRATCH_ZPWORD1
+            lda  P8ZP_SCRATCH_W1+1
+            sta  save_SCRATCH_ZPWORD1+1
+            lda  P8ZP_SCRATCH_W2
+            sta  save_SCRATCH_ZPWORD2
+            lda  P8ZP_SCRATCH_W2+1
+            sta  save_SCRATCH_ZPWORD2+1
+            rts
+save_SCRATCH_ZPB1	.byte  0
+save_SCRATCH_ZPREG	.byte  0
+save_SCRATCH_ZPWORD1	.word  0
+save_SCRATCH_ZPWORD2	.word  0
+        }}
+    }
+
+    asmsub restore_prog8_internals() {
+        %asm {{
+            lda  save_prog8_internals.save_SCRATCH_ZPB1
+            sta  P8ZP_SCRATCH_B1
+            lda  save_prog8_internals.save_SCRATCH_ZPREG
+            sta  P8ZP_SCRATCH_REG
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1
+            sta  P8ZP_SCRATCH_W1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1+1
+            sta  P8ZP_SCRATCH_W1+1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2
+            sta  P8ZP_SCRATCH_W2
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2+1
+            sta  P8ZP_SCRATCH_W2+1
+            rts
+        }}
+    }
+
+asmsub  set_irq(uword handler @AY) clobbers(A)  {
 	%asm {{
-	        sta  _modified+1
-	        sty  _modified+2
-	        lda  #0
-	        rol  a
-	        sta  _use_kernal
-		sei
+	    sei
+        sta  _modified+1
+        sty  _modified+2
 		lda  #<_irq_handler
 		sta  cbm.CINV
 		lda  #>_irq_handler
 		sta  cbm.CINV+1
 		cli
 		rts
-_irq_handler    jsr  _irq_handler_init
-_modified	jsr  $ffff                      ; modified
-		jsr  _irq_handler_end
-		lda  _use_kernal
-		bne  +
-		lda  #$ff
+_irq_handler
+        jsr  sys.save_prog8_internals
+        cld
+_modified
+        jsr  $ffff                      ; modified
+        pha
+		jsr  sys.restore_prog8_internals
+		pla
+		beq  +
+		jmp  cbm.IRQDFRT		; continue with normal kernal irq routine
++		lda  #$ff
 		sta  c64.VICIRQ			; acknowledge raster irq
 		lda  c64.CIA1ICR		; acknowledge CIA1 interrupt
-		; end irq processing - don't use kernal's irq handling
 		pla
 		tay
 		pla
 		tax
 		pla
 		rti
-+		jmp  cbm.IRQDFRT		; continue with normal kernal irq routine
-
-_use_kernal     .byte  0
-
-_irq_handler_init
-		; save all zp scratch registers as these might be clobbered by the irq routine
-		lda  P8ZP_SCRATCH_B1
-		sta  IRQ_SCRATCH_ZPB1
-		lda  P8ZP_SCRATCH_REG
-		sta  IRQ_SCRATCH_ZPREG
-		lda  P8ZP_SCRATCH_W1
-		sta  IRQ_SCRATCH_ZPWORD1
-		lda  P8ZP_SCRATCH_W1+1
-		sta  IRQ_SCRATCH_ZPWORD1+1
-		lda  P8ZP_SCRATCH_W2
-		sta  IRQ_SCRATCH_ZPWORD2
-		lda  P8ZP_SCRATCH_W2+1
-		sta  IRQ_SCRATCH_ZPWORD2+1
-		cld
-		rts
-
-_irq_handler_end
-		; restore all zp scratch registers
-		lda  IRQ_SCRATCH_ZPB1
-		sta  P8ZP_SCRATCH_B1
-		lda  IRQ_SCRATCH_ZPREG
-		sta  P8ZP_SCRATCH_REG
-		lda  IRQ_SCRATCH_ZPWORD1
-		sta  P8ZP_SCRATCH_W1
-		lda  IRQ_SCRATCH_ZPWORD1+1
-		sta  P8ZP_SCRATCH_W1+1
-		lda  IRQ_SCRATCH_ZPWORD2
-		sta  P8ZP_SCRATCH_W2
-		lda  IRQ_SCRATCH_ZPWORD2+1
-		sta  P8ZP_SCRATCH_W2+1
-		rts
-
-IRQ_SCRATCH_ZPB1	.byte  0
-IRQ_SCRATCH_ZPREG	.byte  0
-IRQ_SCRATCH_ZPWORD1	.word  0
-IRQ_SCRATCH_ZPWORD2	.word  0
-
-		}}
+    }}
 }
 
 asmsub  restore_irq() clobbers(A) {
@@ -483,40 +482,39 @@ asmsub  restore_irq() clobbers(A) {
 	}}
 }
 
-asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0, bool useKernal @Pc) clobbers(A) {
+asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0) clobbers(A) {
 	%asm {{
-	        sta  _modified+1
-	        sty  _modified+2
-	        lda  #0
-	        rol  a
-	        sta  set_irq._use_kernal
-		lda  cx16.r0
-		ldy  cx16.r0+1
-		sei
-		jsr  _setup_raster_irq
-		lda  #<_raster_irq_handler
-		sta  cbm.CINV
-		lda  #>_raster_irq_handler
-		sta  cbm.CINV+1
-		cli
-		rts
+	    sei
+        sta  _modified+1
+        sty  _modified+2
+        lda  cx16.r0
+        ldy  cx16.r0+1
+        jsr  _setup_raster_irq
+        lda  #<_raster_irq_handler
+        sta  cbm.CINV
+        lda  #>_raster_irq_handler
+        sta  cbm.CINV+1
+        cli
+        rts
 
 _raster_irq_handler
-		jsr  set_irq._irq_handler_init
-_modified	jsr  $ffff              ; modified
-		jsr  set_irq._irq_handler_end
+		jsr  sys.save_prog8_internals
+		cld
+_modified
+        jsr  $ffff              ; modified
+        pha
+        jsr  sys.restore_prog8_internals
         lda  #$ff
         sta  c64.VICIRQ			; acknowledge raster irq
-		lda  set_irq._use_kernal
-		bne  +
-		; end irq processing - don't use kernal's irq handling
-		pla
+        pla
+        beq  +
+		jmp  cbm.IRQDFRT                ; continue with kernal irq routine
++		pla
 		tay
 		pla
 		tax
 		pla
 		rti
-+		jmp  cbm.IRQDFRT                ; continue with kernal irq routine
 
 _setup_raster_irq
 		pha
@@ -737,6 +735,20 @@ _longcopy
         }}
     }
 
+    inline asmsub disable_caseswitch() {
+        %asm {{
+            lda  #$80
+            sta  657
+        }}
+    }
+
+    inline asmsub enable_caseswitch() {
+        %asm {{
+            lda  #0
+            sta  657
+        }}
+    }
+
     inline asmsub exit(ubyte returnvalue @A) {
         ; -- immediately exit the program with a return code in the A register
         %asm {{

compiler/res/prog8lib/c64/textio.p8

@@ -1,4 +1,6 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the Commodore-64
+; All routines work with Screencode character encoding, except `print`, `chrout` and `input_chars`,
+; these work with PETSCII encoding instead.
 
 %import syslib
 %import conv
@@ -39,6 +41,45 @@ asmsub column(ubyte col @A) clobbers(A, X, Y) {
     }}
 }
 
+
+asmsub get_column() -> ubyte @Y {
+    %asm {{
+        sec
+        jmp cbm.PLOT
+    }}
+}
+
+asmsub row(ubyte rownum @A) clobbers(A, X, Y) {
+    ; ---- set the cursor on the given row (starting with 0) on the current line
+    %asm {{
+        sec
+        jsr  cbm.PLOT
+        tax
+        clc
+        jmp  cbm.PLOT
+    }}
+}
+
+asmsub get_row() -> ubyte @X {
+    %asm {{
+        sec
+        jmp cbm.PLOT
+    }}
+}
+
+sub get_cursor(uword colptr, uword rowptr) {
+    %asm {{
+        sec
+        jsr cbm.PLOT
+        tya
+        ldy #$00
+        sta (colptr),y
+        txa
+        sta (rowptr),y
+    }}
+}
+
+
 asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A)  {
 	; ---- fill the character screen with the given fill character and character color.
 	;      (assumes screen and color matrix are at their default addresses)
@@ -237,10 +278,10 @@ _scroll_screen  ; scroll only the screen memory
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
+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 from 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.
@@ -426,7 +467,8 @@ asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 }
 
 asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
-	; ---- Input a string (max. 80 chars) from the keyboard. Returns length in Y. (string is terminated with a 0 byte as well)
+	; ---- 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 {{
@@ -583,4 +625,11 @@ asmsub height() clobbers(X, Y) -> ubyte @A {
     }}
 }
 
+asmsub waitkey() -> ubyte @A {
+    %asm {{
+-       jsr cbm.GETIN
+        beq -
+        rts
+    }}
+}
 }

compiler/res/prog8lib/cx16/bmx.p8

@@ -0,0 +1,361 @@
+; Routines to load and save "BMX" files (commander X16 bitmap format) Version 1.
+; Only uncompressed images are supported for now.
+; BMX Specification: https://cx16forum.com/forum/viewtopic.php?t=6945
+
+%import diskio
+
+bmx {
+
+    ubyte[32] header
+    str FILEID = petscii:"bmx"
+
+    ubyte bitsperpixel          ; consider using set_bpp() when setting this
+    ubyte vera_colordepth       ; consider using set_vera_colordepth() when setting this
+    uword width
+    uword height
+    ubyte border
+    uword palette_entries       ; 1-256
+    ubyte palette_start
+    ubyte compression
+    uword palette_buffer_ptr = 0    ; should you want to load or save the palette into main memory instead of directly into vram
+
+    uword error_message             ; pointer to error message, or 0 if all ok
+    ubyte old_drivenumber
+
+    sub open(ubyte drivenumber, str filename) -> bool {
+        ; Open a BMX bitmap file and reads the header information.
+        ; Returns true if all is ok, false otherwise + error_message will be set.
+        error_message = 0
+        old_drivenumber = diskio.drivenumber
+        diskio.drivenumber = drivenumber
+        if diskio.f_open(filename) {
+            diskio.reset_read_channel()
+            if read_header() {
+                if parse_header() {
+                    if palette_entries>0 {
+                        if width<=640 {
+                            return true
+                        } else
+                            error_message = "image too large"
+                    } else
+                        error_message = "invalid bmx file"
+                } ; note: parse_header sets the error message by itself
+            } else
+                error_message = "invalid bmx file"
+        } else
+            error_message = diskio.status()
+
+        close()
+        return false
+    }
+
+    sub close() {
+        ; if you want to close the file before actually loading palette or bitmap data.
+        diskio.f_close()
+        diskio.drivenumber = old_drivenumber
+    }
+
+    sub continue_load(ubyte vbank, uword vaddr) -> bool {
+        ; Continues loading the palette and bitmap data from the opened BMX file.
+        ; Parameters: the vram bank and address where the bitmap data should go.
+        ; You can set palette_buffer_ptr if you want the palette buffered rather than directly into vram.
+        ; Note: does not change vera screen mode or colordepth! You have to do that yourself!
+        ; Returns true if all is ok, false otherwise + error_message will be set.
+        error_message = 0
+        diskio.reset_read_channel()
+        if width==320 or width==640 {
+            if compression==0 {
+                if read_palette() {
+                    if not read_bitmap(vbank, vaddr)
+                        error_message = "bitmap error"
+                } else
+                    error_message = "palette error"
+            } else
+                error_message = "compression not supported"
+        } else
+            error_message = "width not 320 or 640"      ; note: use continue_load_stamp() to read other sizes
+
+        close()
+        return error_message==0
+    }
+
+    sub continue_load_stamp(ubyte vbank, uword vaddr, uword screenwidth) -> bool {
+        ; Continues loading the palette and bitmap "stamp" data from the opened BMX file.
+        ; "Stamp" means: load an image that is smaller than the screen (so we need to pad around it)
+        ; Parameters:the vram bank and address where the bitmap data should go,
+        ; and the screen width that the stamp image is loaded into.
+        ; You can set palette_buffer_ptr if you want the palette buffered rather than directly into vram.
+        ; Note: does not change vera screen mode or colordepth! You have to do that yourself!
+        ; Returns true if all is ok, false otherwise + error_message will be set.
+        error_message = 0
+        diskio.reset_read_channel()
+        if compression==0 {
+            if read_palette() {
+                if not read_bitmap_padded(vbank, vaddr, screenwidth)
+                    error_message = "bitmap error"
+            } else
+                error_message = "palette error"
+        } else
+            error_message = "compression not supported"
+
+        close()
+        return error_message==0
+    }
+
+    sub continue_load_only_palette() -> bool {
+        ; Continues loading the palette but not the bitmap data from the opened BMX file.
+        ; You can set palette_buffer_ptr if you want the palette buffered rather than directly into vram.
+        ; Returns true if all is ok, false otherwise + error_message will be set.
+        ; Afterwards the file is closed and you can no longer read additional data from it!
+        error_message = 0
+        diskio.reset_read_channel()
+        if not read_palette()
+            error_message = "palette error"
+        close()
+        return error_message==0
+    }
+
+    sub save(ubyte drivenumber, str filename, ubyte vbank, uword vaddr, uword screenwidth) -> bool {
+        ; Save bitmap and palette data from vram into a BMX file.
+        ; First you must have set all bmx.* variables to the correct values! (like width, height..)
+        ; Parameters:
+        ; drive number and filename to save to,
+        ; vram bank and address of the bitmap data to save,
+        ; and optionally the screen width if you want to save a "stamp" that's smaller than the screen.
+        ; If you're saving the whole screen width, you can leave screenwidth at 0.
+        ; Returns: success status. If false, error_message points to the error message string.
+        error_message = 0
+        if compression {
+            error_message = "compression not supported"
+            return false
+        }
+        if screenwidth==0 {
+            if width!=320 and width!=640 {
+                error_message = "width not 320 or 640"
+                return false
+            }
+        } else {
+            if width>screenwidth {
+                error_message = "image too large"
+                return false
+            }
+        }
+
+        old_drivenumber = diskio.drivenumber
+        diskio.drivenumber = drivenumber
+        if diskio.f_open_w(filename) {
+            cx16.r0 = diskio.status()
+            if cx16.r0[0]!='0' {
+                error_message = cx16.r0
+                goto save_end
+            }
+            diskio.reset_write_channel()
+            if write_header() {
+                if write_palette() {
+                    if not write_bitmap(vbank, vaddr, screenwidth)
+                        error_message = "bitmap error"
+                } else
+                    error_message = "palette error"
+            } else
+                error_message = "header error"
+        } else
+             error_message = diskio.status()
+save_end:
+        diskio.f_close_w()
+        diskio.drivenumber = old_drivenumber
+        return error_message==0
+    }
+
+    sub set_bpp(ubyte bpp) {
+        ubyte[8] depths = [0,1,1,2,2,2,2,3]
+        vera_colordepth = depths[bpp-1]
+    }
+
+    sub set_vera_colordepth(ubyte depth) {
+        vera_colordepth = depth
+        bitsperpixel = 1 << depth
+    }
+
+; ------------------- helper routines, usually not needed to call yourself -------------------------
+
+    sub read_header() -> bool {
+        ; load a BMX header from the currently active input file
+        for cx16.r0L in 0 to sizeof(header)-1 {
+            header[cx16.r0L] = cbm.CHRIN()
+        }
+        return not cbm.READST()
+    }
+
+    sub read_palette() -> bool {
+        ; load palette data from the currently active input file
+        ; if palette_buffer_ptr is not 0, the palette data is read into that memory buffer,
+        ; otherwise it is read directly into the palette in vram.
+        cx16.vaddr(1, $fa00+palette_start*2, 0, 1)
+        cx16.r3 = palette_buffer_ptr
+        cx16.r2L = lsb(palette_entries)
+        do {
+            cx16.r4L = cbm.CHRIN()
+            cx16.r4H = cbm.CHRIN()
+            if cx16.r3 {
+                pokew(cx16.r3, cx16.r4)             ; into memory
+                cx16.r3+=2
+            } else {
+                cx16.VERA_DATA0 = cx16.r4L          ; into vram
+                cx16.VERA_DATA0 = cx16.r4H
+            }
+            cx16.r2L--
+        } until cx16.r2L==0
+        return cbm.READST()==0 or cbm.READST()&$40    ; no error or eof?
+    }
+
+    sub read_bitmap_padded(ubyte vbank, uword vaddr, uword screenwidth) -> bool {
+        ; load bitmap "stamp" into vram from the currently active input file
+        cx16.r3 = bytes_per_scanline(width)         ; num bytes per image scanline
+        cx16.r2 = bytes_per_scanline(screenwidth)   ; num bytes per screen scanline
+        repeat height {
+            cx16.vaddr(vbank, vaddr, 0, 1)
+            read_scanline(cx16.r3)
+            vaddr += cx16.r2
+            if_cs
+                vbank++
+        }
+        return cbm.READST()==0 or cbm.READST()&$40    ; no error or eof?
+    }
+
+    sub read_bitmap(ubyte vbank, uword vaddr) -> bool {
+        ; load contiguous bitmap into vram from the currently active input file
+        cx16.r3 = bytes_per_scanline(width)
+        cx16.vaddr(vbank, vaddr, 0, 1)
+        repeat height
+            read_scanline(cx16.r3)
+        return cbm.READST()==0 or cbm.READST()&$40    ; no error or eof?
+    }
+
+    sub read_scanline(uword size) {
+        while size {
+            cx16.r0 = cx16.MACPTR(min(255, size) as ubyte, &cx16.VERA_DATA0, true)
+            if_cs {
+                ; no MACPTR support
+                repeat size
+                    cx16.VERA_DATA0 = cbm.CHRIN()
+                return
+            }
+            size -= cx16.r0
+        }
+    }
+
+    sub write_header() -> bool {
+        ; save out the BMX header to the currently active output file
+        build_header()
+        for cx16.r0L in 0 to sizeof(header)-1 {
+            cbm.CHROUT(header[cx16.r0L])
+        }
+        return not cbm.READST()
+    }
+
+    sub write_palette() -> bool {
+        ; write palette data to the currently active input file
+        ; if palette_buffer_ptr is not 0, the palette data is read from that memory buffer,
+        ; otherwise it is read directly from the palette in vram.
+        cx16.r3 = palette_buffer_ptr
+        cx16.r2L = lsb(palette_entries)
+        cx16.vaddr(1, $fa00+palette_start*2, 0, 1)
+        do {
+            if cx16.r3 {
+                cbm.CHROUT(@(cx16.r3))      ; from memory
+                cx16.r3++
+                cbm.CHROUT(@(cx16.r3))
+                cx16.r3++
+            } else {
+                cbm.CHROUT(cx16.VERA_DATA0) ; from vram
+                cbm.CHROUT(cx16.VERA_DATA0)
+            }
+            cx16.r2L--
+        } until cx16.r2L==0
+        return not cbm.READST()
+    }
+
+    sub write_bitmap(ubyte vbank, uword vaddr, uword screenwidth) -> bool {
+        ; screenwidth=0: save contiguous bitmap from vram to the currently active output file
+        ; screenwidth>0: save "stamp" bitmap from vram to the currently active output file
+        cx16.vaddr(vbank, vaddr, 0, 1)
+        cx16.r3 = bytes_per_scanline(width)         ; num bytes per image scanline
+        cx16.r2 = 0
+        if screenwidth
+            cx16.r2 = bytes_per_scanline(screenwidth-width)   ; num bytes padding per screen scanline
+        repeat height {
+            write_scanline(cx16.r3)
+            repeat cx16.r2
+                cx16.r0L = cx16.VERA_DATA0
+        }
+        return not cbm.READST()
+
+        sub write_scanline(uword size) {
+            while size {
+                cx16.r0L = lsb(size)
+                if msb(size)
+                    cx16.r0L = 0        ; 256 bytes
+                cx16.r0 = cx16.MCIOUT(cx16.r0L, &cx16.VERA_DATA0, true)
+                if_cs {
+                    ; no MCIOUT support
+                    repeat size
+                        cbm.CHROUT(cx16.VERA_DATA0)
+                    return
+                }
+                size -= cx16.r0
+            }
+        }
+    }
+
+    sub bytes_per_scanline(uword w) -> uword {
+        ubyte[4] shifts = [3,2,1,0]
+        return w >> shifts[vera_colordepth]
+    }
+
+    sub parse_header() -> bool {
+        if header[0]==FILEID[0] and header[1]==FILEID[1] and header[2]==FILEID[2] {
+            if header[3]==1 {       ; only version 1 supported for now
+                bitsperpixel = header[4]
+                vera_colordepth = header[5]
+                width = peekw(&header+6)
+                height = peekw(&header+8)
+                palette_entries = header[10]
+                if palette_entries==0
+                    palette_entries=256
+                palette_start = header[11]
+                ; the data offset is not needed:  data_offset = peekw(&header+12)
+                compression = header[14]
+                border = header[15]
+                return true
+            } else
+                error_message = "unsupported bmx file version"
+        } else
+            error_message = "invalid bmx file"
+
+        return false
+    }
+
+    sub build_header() {
+        ; build the internal BMX header structure
+        ; normally you don't have to call this yourself
+        sys.memset(header, sizeof(header), 0)
+        uword data_offset = palette_entries*$0002
+        data_offset += sizeof(header)
+        header[0] = FILEID[0]
+        header[1] = FILEID[1]
+        header[2] = FILEID[2]
+        header[3] = 1        ; version 1
+        header[4] = bitsperpixel
+        header[5] = vera_colordepth
+        header[6] = lsb(width)
+        header[7] = msb(width)
+        header[8] = lsb(height)
+        header[9] = msb(height)
+        header[10] = lsb(palette_entries)
+        header[11] = palette_start
+        header[12] = lsb(data_offset)
+        header[13] = msb(data_offset)
+        header[14] = compression
+        header[15] = border
+    }
+}

compiler/res/prog8lib/cx16/diskio.p8

@@ -1,6 +1,16 @@
 ; Commander X16 disk drive I/O routines.
 ; Largely compatible with the default C64 ones, but adds more stuff specific to the X16 as well.
 
+; NOTE: If you experience weird behavior with these routines and you are using them
+;       in the X16 emulator using HostFs, please try again with an SD-card image instead first.
+;       It is possible that there are still small differences between HostFS and actual CBM DOS in the emulator.
+;
+; About the secondary addresses:
+; for writes (new files or overwrites), you can use 1 (without the mode string) or 2-14 (with the mode string)
+; for reads (existing files) you can use 0 or 2-14 (mode string is optional)
+; for modify mode (new files* or existing files), you must use 2-14, and the mode string ,s,m is required
+
+
 %import textio
 %import string
 %import syslib
@@ -8,22 +18,29 @@
 diskio {
     %option no_symbol_prefixing
 
-    ubyte drivenumber = 8
+    const ubyte READ_IO_CHANNEL=12
+    const ubyte WRITE_IO_CHANNEL=13
 
-    sub set_drive(ubyte number) {
-        drivenumber = number
+    ubyte drivenumber = 8           ; user programs can set this to the drive number they want to load/save to!
+
+    sub reset_read_channel() {
+        void cbm.CHKIN(READ_IO_CHANNEL)
+    }
+
+    sub reset_write_channel() {
+        cbm.CHKOUT(WRITE_IO_CHANNEL)
     }
 
     sub directory() -> bool {
         ; -- Prints the directory contents to the screen. Returns success.
 
         cbm.SETNAM(1, "$")
-        cbm.SETLFS(12, drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
         ubyte status = 1
         void cbm.OPEN()          ; open 12,8,0,"$"
         if_cs
             goto io_error
-        void cbm.CHKIN(12)        ; use #12 as input channel
+        reset_read_channel()
         if_cs
             goto io_error
 
@@ -61,7 +78,7 @@ diskio {
 
 io_error:
         cbm.CLRCHN()        ; restore default i/o devices
-        cbm.CLOSE(12)
+        cbm.CLOSE(READ_IO_CHANNEL)
 
         if status and status & $40 == 0 {            ; bit 6=end of file
             txt.print("\ni/o error, status: ")
@@ -76,12 +93,12 @@ io_error:
     sub diskname() -> uword {
         ; returns disk label name or 0 if error
         cbm.SETNAM(3, "$")
-        cbm.SETLFS(12, diskio.drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
         ubyte status = 1
         void cbm.OPEN()          ; open 12,8,0,"$=c"
         if_cs
             goto io_error
-        void cbm.CHKIN(12)        ; use #12 as input channel
+        reset_read_channel()
         if_cs
             goto io_error
 
@@ -89,12 +106,12 @@ io_error:
             ; skip up to entry name
         }
 
-        cx16.r0 = &diskio.list_filename
+        cx16.r0 = &list_filename
         repeat {
             @(cx16.r0) = cbm.CHRIN()
             if @(cx16.r0)=='"' {
                 @(cx16.r0) = ' '
-                while @(cx16.r0)==' ' and cx16.r0>=&diskio.list_filename {
+                while @(cx16.r0)==' ' and cx16.r0>=&list_filename {
                     @(cx16.r0) = 0
                     cx16.r0--
                 }
@@ -106,10 +123,10 @@ io_error:
 
 io_error:
         cbm.CLRCHN()
-        cbm.CLOSE(12)
+        cbm.CLOSE(READ_IO_CHANNEL)
         if status and status & $40 == 0
             return 0
-        return diskio.list_filename
+        return list_filename
     }
 
     ; internal variables for the iterative file lister / loader
@@ -124,12 +141,13 @@ io_error:
 
     sub list_filenames(uword pattern_ptr, uword filenames_buffer, uword filenames_buf_size) -> ubyte {
         ; -- fill the provided buffer with the names of the files on the disk (until buffer is full).
-        ;    Files in the buffer are separeted by a 0 byte. You can provide an optional pattern to match against.
+        ;    Files in the buffer are separated by a 0 byte. You can provide an optional pattern to match against.
         ;    After the last filename one additional 0 byte is placed to indicate the end of the list.
         ;    Returns number of files (it skips 'dir' entries i.e. subdirectories).
         ;    Also sets carry on exit: Carry clear = all files returned, Carry set = directory has more files that didn't fit in the buffer.
         uword buffer_start = filenames_buffer
         ubyte files_found = 0
+        filenames_buffer[0]=0
         if lf_start_list(pattern_ptr) {
             while lf_next_entry() {
                 if list_filetype!="dir" {
@@ -150,7 +168,7 @@ io_error:
         return files_found
     }
 
-    ; ----- iterative file lister functions (uses io channel 12) -----
+    ; ----- iterative file lister functions (uses the read io channel) -----
 
     sub lf_start_list(uword pattern_ptr) -> bool {
         ; -- start an iterative file listing with optional pattern matching.
@@ -161,11 +179,11 @@ io_error:
         iteration_in_progress = true
 
         cbm.SETNAM(1, "$")
-        cbm.SETLFS(12, drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
         void cbm.OPEN()          ; open 12,8,0,"$"
         if_cs
             goto io_error
-        void cbm.CHKIN(12)        ; use #12 as input channel
+        reset_read_channel()
         if_cs
             goto io_error
 
@@ -190,7 +208,7 @@ io_error:
             return false
 
         repeat {
-            void cbm.CHKIN(12)        ; use #12 as input channel again
+            reset_read_channel()        ; use the input io channel again
 
             uword nameptr = &list_filename
             ubyte blocks_lsb = cbm.CHRIN()
@@ -251,32 +269,36 @@ close_end:
         ; -- end an iterative file listing session (close channels).
         if iteration_in_progress {
             cbm.CLRCHN()
-            cbm.CLOSE(12)
+            cbm.CLOSE(READ_IO_CHANNEL)
             iteration_in_progress = false
         }
     }
 
 
-    ; ----- iterative file loader functions (uses io channel 12) -----
+    ; ----- iterative file loader functions (uses the read io channel) -----
 
-    sub f_open(uword filenameptr) -> bool {
+    sub f_open(str filenameptr) -> bool {
         ; -- open a file for iterative reading with f_read
         ;    note: only a single iteration loop can be active at a time!
+        ;    Returns true if the file is successfully opened and readable.
+        ;    No need to check status(), unlike f_open_w() !
+        ;    NOTE: the default input isn't yet set to this logical file, you must use reset_read_channel() to do this,
+        ;          if you're going to read from it yourself instead of using f_read()!
         f_close()
 
         cbm.SETNAM(string.length(filenameptr), filenameptr)
-        cbm.SETLFS(12, drivenumber, 12)     ; note: has to be 12,x,12 because otherwise f_seek doesn't work
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, READ_IO_CHANNEL)     ; note: has to be Channel,x,Channel because otherwise f_seek doesn't work
         void cbm.OPEN()          ; open 12,8,12,"filename"
         if_cc {
             if cbm.READST()==0 {
                 iteration_in_progress = true
-                void cbm.CHKIN(12)          ; use #12 as input channel
+                reset_read_channel()
                 if_cc {
                     void cbm.CHRIN()        ; read first byte to test for file not found
                     if not cbm.READST() {
-                        cbm.CLOSE(12)           ; close file because we already consumed first byte
+                        cbm.CLOSE(READ_IO_CHANNEL)           ; close file because we already consumed first byte
                         void cbm.OPEN()         ; re-open the file
-                        void cbm.CHKIN(12)
+                        cbm.CLRCHN()            ; reset default i/o channels
                         return true
                     }
                 }
@@ -290,21 +312,21 @@ close_end:
     sub f_read(uword bufferpointer, uword num_bytes) -> uword {
         ; -- read from the currently open file, up to the given number of bytes.
         ;    returns the actual number of bytes read.  (checks for End-of-file and error conditions)
-        ;    NOTE: cannot be used to load into VRAM.  Use vload() or call cx16.macptr() yourself with the vera data register as address.
+        ;    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 or not num_bytes
             return 0
 
+        reset_read_channel()
         list_blocks = 0     ; we reuse this variable for the total number of bytes read
 
-        ; commander X16 supports fast block-read via macptr() kernal call
         uword readsize
         while num_bytes {
             readsize = 255
             if num_bytes<readsize
                 readsize = num_bytes
-            readsize = cx16.macptr(lsb(readsize), bufferpointer, false)
+            readsize = cx16.MACPTR(lsb(readsize), bufferpointer, false)     ; fast block reads
             if_cs
-                goto byte_read_loop     ; macptr block read not supported, do fallback loop
+                goto byte_read_loop     ; MACPTR block read not supported, do fallback loop
             list_blocks += readsize
             bufferpointer += readsize
             if msb(bufferpointer) == $c0
@@ -317,7 +339,7 @@ close_end:
         }
         return list_blocks  ; number of bytes read
 
-byte_read_loop:         ; fallback if macptr() isn't supported on the device
+byte_read_loop:         ; fallback if MACPTR isn't supported on the device
         %asm {{
             lda  bufferpointer
             sta  m_in_buffer+1
@@ -348,10 +370,11 @@ 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.
-        ;    NOTE: cannot be used to load into VRAM.  Use vload() or call cx16.macptr() yourself with the vera data register as address.
+        ;    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
 
+        reset_read_channel()
         uword total_read = 0
         while not cbm.READST() {
             cx16.r0 = f_read(bufferpointer, 256)
@@ -370,8 +393,7 @@ m_in_buffer     sta  $ffff
         %asm {{
             sta  P8ZP_SCRATCH_W1
             sty  P8ZP_SCRATCH_W1+1
-            ldx  #12
-            jsr  cbm.CHKIN              ; use channel 12 again for input
+            jsr  reset_read_channel
             ldy  #0
 _loop       jsr  cbm.CHRIN
             sta  (P8ZP_SCRATCH_W1),y
@@ -392,23 +414,41 @@ _end        rts
         ; -- end an iterative file loading session (close channels).
         if iteration_in_progress {
             cbm.CLRCHN()
-            cbm.CLOSE(12)
+            cbm.CLOSE(READ_IO_CHANNEL)
             iteration_in_progress = false
         }
     }
 
 
-    ; ----- iterative file writing functions (uses io channel 13) -----
+    ; ----- iterative file writing functions (uses write io channel) -----
 
-    sub f_open_w(uword filenameptr) -> bool {
-        ; -- open a file for iterative writing with f_write
+    sub f_open_w(str filename) -> bool {
+        ; -- Open a file for iterative writing with f_write
+        ;    WARNING: returns true if the open command was received by the device,
+        ;    but this can still mean the file wasn't successfully opened for writing!
+        ;    (for example, if it already exists). This is different than f_open()!
+        ;    To be 100% sure if this call was successful, you have to use status()
+        ;    and check the drive's status message!
+        return internal_f_open_w(filename, false)
+    }
+
+    sub f_open_w_seek(str filename) -> bool {
+        ; -- Open an existing file for iterative writing with f_write, and seeking with f_seek_w.
+        return internal_f_open_w(filename, true)
+    }
+
+    sub internal_f_open_w(str filename, bool open_for_seeks) -> bool {
         f_close_w()
-
-        cbm.SETNAM(string.length(filenameptr), filenameptr)
-        cbm.SETLFS(13, drivenumber, 1)
-        void cbm.OPEN()             ; open 13,8,1,"filename"
+        list_filename = filename
+        str modifier = ",s,?"
+        modifier[3] = 'w'
+        if open_for_seeks
+            modifier[3] = 'm'
+        cx16.r0L = string.append(list_filename, modifier)   ; secondary 13 requires a mode suffix to signal we're writing/modifying
+        cbm.SETNAM(cx16.r0L, list_filename)
+        cbm.SETLFS(WRITE_IO_CHANNEL, drivenumber, WRITE_IO_CHANNEL)
+        void cbm.OPEN()             ; open 13,8,13,"filename"
         if_cc {
-            cbm.CHKOUT(13)          ; use #13 as output channel
             return not cbm.READST()
         }
         f_close_w()
@@ -418,7 +458,22 @@ _end        rts
     sub f_write(uword bufferpointer, uword num_bytes) -> bool {
         ; -- write the given number of bytes to the currently open file
         if num_bytes!=0 {
-            cbm.CHKOUT(13)        ; use #13 as output channel again
+            reset_write_channel()
+            do {
+                cx16.r0 = cx16.MCIOUT(lsb(num_bytes), bufferpointer, false)     ; fast block writes
+                if_cs
+                    goto no_mciout
+                num_bytes -= cx16.r0
+                bufferpointer += cx16.r0
+                if msb(bufferpointer) == $c0
+                    bufferpointer = mkword($a0, lsb(bufferpointer))  ; wrap over bank boundary
+                if cbm.READST()!=0
+                    return false
+            } until num_bytes==0
+            return not cbm.READST()
+
+no_mciout:
+            ; the device doesn't support MCIOUT, use a normal per-byte write loop
             repeat num_bytes {
                 cbm.CHROUT(@(bufferpointer))
                 bufferpointer++
@@ -431,7 +486,7 @@ _end        rts
     sub f_close_w() {
         ; -- end an iterative file writing session (close channels).
         cbm.CLRCHN()
-        cbm.CLOSE(13)
+        cbm.CLOSE(WRITE_IO_CHANNEL)
     }
 
 
@@ -506,9 +561,6 @@ io_error:
         if_cc
             cx16.r0L = cbm.READST()==0
 
-        cbm.CLRCHN()
-        cbm.CLOSE(1)
-
         return cx16.r0L
     }
 
@@ -557,8 +609,6 @@ io_error:
 +
         }}
 
-        cbm.CLRCHN()
-        cbm.CLOSE(1)
         return cx16.r1
     }
 
@@ -693,11 +743,11 @@ internal_vload:
         cx16.r12 = reversebuffer + MAX_PATH_LEN-1
         @(cx16.r12)=0
         cbm.SETNAM(3, "$=c")
-        cbm.SETLFS(12, diskio.drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
         void cbm.OPEN()          ; open 12,8,0,"$=c"
         if_cs
             goto io_error
-        void cbm.CHKIN(12)        ; use #12 as input channel
+        reset_read_channel()
         if_cs
             goto io_error
 
@@ -734,7 +784,7 @@ internal_vload:
 
 io_error:
         cbm.CLRCHN()
-        cbm.CLOSE(12)
+        cbm.CLOSE(READ_IO_CHANNEL)
         if status and status & $40 == 0
             return 0
         if @(cx16.r12)==0 {
@@ -767,7 +817,7 @@ 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
         ubyte[6] command = ['p',0,0,0,0,0]
-        command[1] = 12       ; f_open uses channel 12
+        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)
@@ -777,19 +827,22 @@ io_error:
         cbm.SETLFS(15, drivenumber, 15)
         void cbm.OPEN()
         cbm.CLOSE(15)
-        void cbm.CHKIN(12)       ; back to the channel that f_open uses
+        reset_read_channel()       ; back to the read io channel
     }
 
 
-    ; NOTE: f_seek_w() doesn't work reliably right now. I only manage to corrupt the fat32 filesystem on the sdcard with it...
-;    sub f_seek_w(uword pos_hiword, uword pos_loword) {
-;        ; -- seek in the output file opened with f_open_w, to the given 32-bits position
-;        diskio.f_seek.command[1] = 13       ; f_open_w uses channel 13
-;        diskio.f_seek.command[2] = lsb(pos_loword)
-;        diskio.f_seek.command[3] = msb(pos_loword)
-;        diskio.f_seek.command[4] = lsb(pos_hiword)
-;        diskio.f_seek.command[5] = msb(pos_hiword)
-;        goto diskio.f_seek.send_command
-;    }
+    sub f_seek_w(uword pos_hiword, uword pos_loword) {
+        ; -- seek in the output file opened with f_open_w_seek, to the given 32-bits position
+        diskio.f_seek.command[1] = WRITE_IO_CHANNEL       ; f_open_w uses this secondary address
+        diskio.f_seek.command[2] = lsb(pos_loword)
+        diskio.f_seek.command[3] = msb(pos_loword)
+        diskio.f_seek.command[4] = lsb(pos_hiword)
+        diskio.f_seek.command[5] = msb(pos_hiword)
+        cbm.SETNAM(sizeof(diskio.f_seek.command), &diskio.f_seek.command)
+        cbm.SETLFS(15, drivenumber, 15)
+        void cbm.OPEN()
+        cbm.CLOSE(15)
+        reset_write_channel()    ; back to the write io channel
+    }
 
 }

compiler/res/prog8lib/cx16/emudbg.p8

@@ -0,0 +1,60 @@
+; Emulator debug interface.
+; Docs: https://github.com/X16Community/x16-emulator#emulator-io-registers
+
+emudbg {
+
+    const uword EMU_BASE = $9fb0
+
+    &ubyte EMU_DBG_HOTKEY_ENABLED = EMU_BASE + 0
+    &ubyte EMU_LOG_VIDEO          = EMU_BASE + 1
+    &ubyte EMU_LOG_KEYBOARD       = EMU_BASE + 2
+    &ubyte EMU_ECHO_MODE          = EMU_BASE + 3
+    &ubyte EMU_SAVE_ON_EXIT       = EMU_BASE + 4
+    &ubyte EMU_RECORD_GIF         = EMU_BASE + 5
+    &ubyte EMU_RECORD_WAV         = EMU_BASE + 6
+    &ubyte EMU_CMDKEYS_DISABLED   = EMU_BASE + 7
+    &ubyte EMU_CPUCLK_L           = EMU_BASE + 8     ; write: reset cpu clock to 0
+    &ubyte EMU_CPUCLK_M           = EMU_BASE + 9     ; write: outputs "User debug 1: $xx"
+    &ubyte EMU_CPUCLK_H           = EMU_BASE + 10    ; write: outputs "User debug 2: $xx"
+    &ubyte EMU_CPUCLK_U           = EMU_BASE + 11    ; write: outputs as character to console
+    ; 12 is unused for now
+    &ubyte EMU_KEYMAP             = EMU_BASE + 13
+    &ubyte EMU_EMU_DETECT1        = EMU_BASE + 14
+    &ubyte EMU_EMU_DETECT2        = EMU_BASE + 15
+
+    sub is_emulator() -> bool {
+        ; Test for emulator presence.
+        ; It is recommended to only use the debug registers if this returns true.
+        return EMU_EMU_DETECT1=='1' and EMU_EMU_DETECT2=='6'
+    }
+
+    sub console_write(str isoString) {
+        ; note: make sure the text is in Iso encoding.
+        if is_emulator() {
+            ubyte chr
+            repeat {
+                chr = @(isoString)
+                if_z
+                    break
+                EMU_CPUCLK_U = chr
+                isoString++
+            }
+        }
+    }
+
+    sub console_chrout(ubyte char) {
+        ; note: make sure the character is in Iso encoding.
+        if is_emulator()
+            EMU_CPUCLK_U = char
+    }
+
+    sub console_value1(ubyte value) {
+        if is_emulator()
+            EMU_CPUCLK_M = value
+    }
+
+    sub console_value2(ubyte value) {
+        if is_emulator()
+            EMU_CPUCLK_H = value
+    }
+}

compiler/res/prog8lib/cx16/floats.p8

@@ -8,8 +8,9 @@ floats {
 
     %option no_symbol_prefixing
 
-        const float  PI     = 3.141592653589793
-        const float  TWOPI  = 6.283185307179586
+        const float  π      = 3.141592653589793
+        const float  PI     = π
+        const float  TWOPI  = 2*π
 
 
 ; ---- ROM float functions (same as on C128 except base page) ----
@@ -28,7 +29,7 @@ romsub $fe00 = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 100-101
 romsub $fe03 = GIVAYF(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)
 
 romsub $fe06 = FOUT() clobbers(X) -> uword @ AY             ; fac1 -> string, address returned in AY
-; romsub $fe09 = VAL_1() clobbers(A,X,Y)                      ; convert ASCII string to floating point [not yet implemented!!!] see parse_f() instead
+romsub $fe09 = VAL_1(uword string @XY, ubyte length @A) clobbers(A,X,Y) -> float @FAC1      ; convert ASCII string in XY and length in A, to floating point in FAC1. WARNING: not implemented in the ROM yet!
 
 ; GETADR: fac1 -> unsigned word in Y/A (might throw ILLEGAL QUANTITY) (result also in $14/15)
 ; (tip: use GETADRAY to get A/Y output; lo/hi switched to normal little endian order)
@@ -71,10 +72,10 @@ romsub $fe6c = MOVAF() clobbers(A,X)                        ; copy fac1 to fac2
 ; X16 additions
 romsub $fe6f = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for 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) (juse use NEGOP() instead!)
+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!)
 romsub $fe7b = MUL10() clobbers(A,X,Y)                      ; fac1 *= 10
-romsub $fe7e = DIV10() clobbers(A,X,Y)                      ; fac1 /= 10 , CAUTION: result is always positive!
+romsub $fe7e = DIV10() clobbers(A,X,Y)                      ; fac1 /= 10 , CAUTION: result is always positive! Have to restore sign manually!
 romsub $fe81 = MOVEF() clobbers(A,X)                        ; copy fac1 to fac2
 romsub $fe84 = SGN() clobbers(A,X,Y)                        ; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
 romsub $fe87 = FLOAT() clobbers(A,X,Y)                      ; FAC = (s8).A
@@ -138,14 +139,38 @@ asmsub  FREADUY (ubyte value @Y) {
 
 asmsub parse_f(str value @AY) -> float @FAC1 {
     ; -- parse a string value of a number to float in FAC1
-    ;    warning: uses an internal BASIC routine that may be rom version dependent
-    ;    ($ddf2 is inside the routine for VAL at $ddef)
+    ;    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 VAL_1 is merged into the kernal properly, remove all the workarounds here
     %asm {{
-        sta  $a9
-        sty  $aa
+        ldx  VAL_1
+        cpx  #$4c       ; is there an implementation in VAL_1? (test for JMP)
+        bne  +          ; no, do it ourselves
+        pha             ; yes, count the length and call rom VAL_1.
+        phy
         jsr  prog8_lib.strlen
         tya
-        jmp  $ddf2
+        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
+        ldy  #0
+-       lda  _msg,y
+        beq  +
+        jsr  cbm.CHROUT
+        iny
+        bne  -
++       jmp  sys.exit
+
+_msg    .text 13,"?val kaputt",13,0
     }}
 }
 
@@ -159,6 +184,12 @@ sub rndf() -> float {
     }}
 }
 
+asmsub normalize(float value @FAC1) -> float @ FAC1 {
+    %asm {{
+        jmp  floats.NORMAL
+    }}
+}
+
 %asminclude "library:c64/floats.asm"
 %asminclude "library:c64/floats_funcs.asm"
 

compiler/res/prog8lib/cx16/gfx2.p8

@@ -4,21 +4,23 @@
 ;
 ; No text layer is currently shown, text can be drawn as part of the bitmap itself.
 ; Note: for similar graphics routines that also work on the C-64, use the "graphics" module instead.
+; Note: for identical routines for a monochrome 1 bpp screen, use the "monogfx" module instead.
 ; Note: for color palette manipulation, use the "palette" module or write Vera registers yourself.
 ; Note: this library implements code for various resolutions and color depths. This takes up memory.
 ;       If you're memory constrained you should probably not use this built-in library,
 ;       but make a copy in your project only containing the code for the required resolution.
 ;
+; 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!
+;
 ;
 ; SCREEN MODE LIST:
 ;   mode 0 = reset back to default text mode
-;   mode 1 = bitmap 320 x 240 monochrome
-;   mode 2 = bitmap 320 x 240 x 4c (not yet implemented: just use 256c, there's enough vram for that)
-;   mode 3 = bitmap 320 x 240 x 16c (not yet implemented: just use 256c, there's enough vram for that)
-;   mode 4 = bitmap 320 x 240 x 256c  (like SCREEN $80 but using this api instead of kernal)
-;   mode 5 = bitmap 640 x 480 monochrome
-;   mode 6 = bitmap 640 x 480 x 4c
-;   higher color dephts in highres are not supported due to lack of VRAM
+;   mode 1 = bitmap 320 x 240 x 256c (8 bpp)
+;   mode 2 = bitmap 640 x 480 x 4c (2 bpp)
+;   mode 3 = bitmap 320 x 240 x 4c (not yet implemented: just use 256c, there's enough vram for that)
+;   mode 4 = bitmap 320 x 240 x 16c (not yet implemented: just use 256c, there's enough vram for that)
+;   mode 5 = bitmap 640 x 400 x 16c (not yet implemented)
 
 gfx2 {
 
@@ -29,24 +31,11 @@ gfx2 {
     uword width = 0
     uword height = 0
     ubyte bpp = 0
-    bool monochrome_dont_stipple_flag = false            ; set to false to enable stippling mode in monochrome displaymodes
 
     sub screen_mode(ubyte mode) {
+        cx16.VERA_CTRL=0
         when mode {
             1 -> {
-                ; lores monochrome
-                cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
-                cx16.VERA_DC_HSCALE = 64
-                cx16.VERA_DC_VSCALE = 64
-                cx16.VERA_L1_CONFIG = %00000100
-                cx16.VERA_L1_MAPBASE = 0
-                cx16.VERA_L1_TILEBASE = 0
-                width = 320
-                height = 240
-                bpp = 1
-            }
-            ; TODO modes 2, 3
-            4 -> {
                 ; lores 256c
                 cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
                 cx16.VERA_DC_HSCALE = 64
@@ -54,23 +43,8 @@ gfx2 {
                 cx16.VERA_L1_CONFIG = %00000111
                 cx16.VERA_L1_MAPBASE = 0
                 cx16.VERA_L1_TILEBASE = 0
-                width = 320
-                height = 240
-                bpp = 8
             }
-            5 -> {
-                ; highres monochrome
-                cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
-                cx16.VERA_DC_HSCALE = 128
-                cx16.VERA_DC_VSCALE = 128
-                cx16.VERA_L1_CONFIG = %00000100
-                cx16.VERA_L1_MAPBASE = 0
-                cx16.VERA_L1_TILEBASE = %00000001
-                width = 640
-                height = 480
-                bpp = 1
-            }
-            6 -> {
+            2 -> {
                 ; highres 4c
                 cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
                 cx16.VERA_DC_HSCALE = 128
@@ -78,61 +52,63 @@ gfx2 {
                 cx16.VERA_L1_CONFIG = %00000101
                 cx16.VERA_L1_MAPBASE = 0
                 cx16.VERA_L1_TILEBASE = %00000001
-                width = 640
-                height = 480
-                bpp = 2
             }
             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
+            }
+        }
+
+        init_mode(mode)
+        if active_mode
+            clear_screen(0)
+    }
+
+    sub init_mode(ubyte mode) {
+        ; set the internal configuration variables corresponding to the given screenmode
+        ; doesn't manipulate Vera / the actual display mode
+        active_mode = mode
+        when mode {
+            1 -> {
+                width = 320
+                height = 240
+                bpp = 8
+            }
+            2 -> {
+                width = 640
+                height = 480
+                bpp = 2
+            }
+            else -> {
                 width = 0
                 height = 0
                 bpp = 0
-                mode = 0
+                active_mode = 0
             }
         }
-
-        active_mode = mode
-        if bpp
-            clear_screen()
     }
 
-    sub clear_screen() {
-        monochrome_stipple(false)
+    sub clear_screen(ubyte color) {
         position(0, 0)
         when active_mode {
             1 -> {
-                ; lores monochrome
-                repeat 240/2/8
-                    cs_innerloop640()
-            }
-            ; TODO modes 2, 3
-            4 -> {
                 ; lores 256c
                 repeat 240/2
-                    cs_innerloop640()
+                    cs_innerloop640(color)
             }
-            5 -> {
-                ; highres monochrome
-                repeat 480/8
-                    cs_innerloop640()
-            }
-            6 -> {
+            2 -> {
                 ; highres 4c
+                ubyte[] colors = [%00000000, %01010101, %10101010, %11111111]
+                color = colors[color&3]
                 repeat 480/4
-                    cs_innerloop640()
+                    cs_innerloop640(color)
             }
-            ; modes 7 and 8 not supported due to lack of VRAM
         }
         position(0, 0)
     }
 
-    sub monochrome_stipple(bool enable) {
-        monochrome_dont_stipple_flag = not enable
-    }
-
     sub rect(uword xx, uword yy, uword rwidth, uword rheight, ubyte color) {
         if rwidth==0 or rheight==0
             return
@@ -147,6 +123,8 @@ gfx2 {
     }
 
     sub fillrect(uword xx, uword yy, uword rwidth, uword rheight, ubyte color) {
+        ; Draw a filled rectangle of the given size and color.
+        ; To fill the whole screen, use clear_screen(color) instead - it is much faster.
         if rwidth==0
             return
         repeat rheight {
@@ -156,87 +134,10 @@ gfx2 {
     }
 
     sub horizontal_line(uword xx, uword yy, uword length, ubyte color) {
-        ubyte[9] masked_starts = [ 0, %00000001, %00000011, %00000111, %00001111, %00011111, %00111111, %01111111, %11111111]
-        ubyte[9] masked_ends   = [ 0, %10000000, %11000000, %11100000, %11110000, %11111000, %11111100, %11111110, %11111111]
-
         if length==0
             return
         when active_mode {
-            1, 5 -> {
-                ; monochrome modes, either resolution
-                ubyte separate_pixels = (8-lsb(xx)) & 7
-                if separate_pixels as uword > length
-                    separate_pixels = lsb(length)
-                if separate_pixels {
-                    if monochrome_dont_stipple_flag {
-                        position(xx,yy)
-                        cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off
-                        if color
-                            cx16.VERA_DATA0 |= masked_starts[separate_pixels]
-                        else
-                            cx16.VERA_DATA0 &= ~masked_starts[separate_pixels]
-                        xx += separate_pixels
-                    } else {
-                        repeat separate_pixels {
-                            plot(xx, yy, color)
-                            xx++
-                        }
-                    }
-                    length -= separate_pixels
-                }
-                if length {
-                    position(xx, yy)
-                    separate_pixels = lsb(length) & 7
-                    xx += length & $fff8
-                    %asm {{
-                        lsr  length+1
-                        ror  length
-                        lsr  length+1
-                        ror  length
-                        lsr  length+1
-                        ror  length
-                        lda  color
-                        bne  +
-                        ldy  #0     ; black
-                        bra  _loop
-+                       lda  monochrome_dont_stipple_flag
-                        beq  _stipple
-                        ldy  #255       ; don't stipple
-                        bra  _loop
-_stipple                lda  yy
-                        and  #1         ; determine stipple pattern to use
-                        bne  +
-                        ldy  #%01010101
-                        bra  _loop
-+                       ldy  #%10101010
-_loop                   lda  length
-                        ora  length+1
-                        beq  _done
-                        sty  cx16.VERA_DATA0
-                        lda  length
-                        bne  +
-                        dec  length+1
-+                       dec  length
-                        bra  _loop
-_done
-                    }}
-
-                    if monochrome_dont_stipple_flag {
-                        cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off
-                        if color
-                            cx16.VERA_DATA0 |= masked_ends[separate_pixels]
-                        else
-                            cx16.VERA_DATA0 &= ~masked_ends[separate_pixels]
-                    } else {
-                        repeat separate_pixels {
-                            plot(xx, yy, color)
-                            xx++
-                        }
-                    }
-                }
-                cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off again
-            }
-            4 -> {
+            1 -> {
                 ; lores 256c
                 position(xx, yy)
                 %asm {{
@@ -257,8 +158,8 @@ _done
 +
                 }}
             }
-            6 -> {
-                ; highres 4c ....also mostly usable for mode 2, lores 4c?
+            2 -> {
+                ; highres 4c ....also mostly usable for lores 4c?
                 color &= 3
                 ubyte[4] colorbits
                 ubyte ii
@@ -305,62 +206,27 @@ _done
         }
     }
 
+    sub safe_horizontal_line(uword xx, uword yy, uword length, ubyte color) {
+        ; does bounds checking and clipping
+        if msb(yy)&$80!=0 or yy>=height
+            return
+        if msb(xx)&$80!=0 {
+            length += xx
+            xx = 0
+        }
+        if xx>=width
+            return
+        if xx+length>width
+            length = width-xx
+        if length>width
+            return
+
+        horizontal_line(xx, yy, length, color)
+    }
+
     sub vertical_line(uword xx, uword yy, uword lheight, ubyte color) {
         when active_mode {
-            1, 5 -> {
-                ; monochrome, lo-res
-                cx16.r15L = gfx2.plot.maskbits[xx as ubyte & 7]           ; bitmask
-                if color {
-                    if monochrome_dont_stipple_flag {
-                        ; draw continuous line.
-                        position2(xx,yy,true)
-                        if active_mode==1
-                            set_both_strides(11)    ; 40 increment = 1 line in 320 px monochrome
-                        else
-                            set_both_strides(12)    ; 80 increment = 1 line in 640 px monochrome
-                        repeat lheight {
-                            %asm {{
-                                lda  cx16.VERA_DATA0
-                                ora  cx16.r15L
-                                sta  cx16.VERA_DATA1
-                            }}
-                        }
-                    } else {
-                        ; draw stippled line.
-                        if xx&1 {
-                            yy++
-                            lheight--
-                        }
-                        position2(xx,yy,true)
-                        if active_mode==1
-                            set_both_strides(12)    ; 80 increment = 2 line in 320 px monochrome
-                        else
-                            set_both_strides(13)    ; 160 increment = 2 line in 640 px monochrome
-                        repeat lheight/2 {
-                            %asm {{
-                                lda  cx16.VERA_DATA0
-                                ora  cx16.r15L
-                                sta  cx16.VERA_DATA1
-                            }}
-                        }
-                    }
-                } else {
-                    position2(xx,yy,true)
-                    cx16.r15 = ~cx16.r15    ; erase pixels
-                    if active_mode==1
-                        set_both_strides(11)    ; 40 increment = 1 line in 320 px monochrome
-                    else
-                        set_both_strides(12)    ; 80 increment = 1 line in 640 px monochrome
-                    repeat lheight {
-                        %asm {{
-                            lda  cx16.VERA_DATA0
-                            and  cx16.r15L
-                            sta  cx16.VERA_DATA1
-                        }}
-                    }
-                }
-            }
-            4 -> {
+            1 -> {
                 ; lores 256c
                 ; set vera auto-increment to 320 pixel increment (=next line)
                 position(xx,yy)
@@ -375,7 +241,7 @@ _done
 +
                 }}
             }
-            6 -> {
+            2 -> {
                 ; highres 4c
                 ; use TWO vera adress pointers simultaneously one for reading, one for writing, so auto-increment is possible
                 if lheight==0
@@ -505,6 +371,7 @@ _done
     }
 
     sub circle(uword @zp xcenter, uword @zp ycenter, ubyte radius, ubyte color) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
         ; Midpoint algorithm.
         if radius==0
             return
@@ -518,36 +385,91 @@ _done
         while xx>=yy {
             cx16.r14 = xcenter + xx
             cx16.r15 = ycenter + yy
-            plot(cx16.r14, cx16.r15, color)
+            plotq()
             cx16.r14 = xcenter - xx
-            plot(cx16.r14, cx16.r15, color)
+            plotq()
             cx16.r14 = xcenter + xx
             cx16.r15 = ycenter - yy
-            plot(cx16.r14, cx16.r15, color)
+            plotq()
             cx16.r14 = xcenter - xx
-            plot(cx16.r14, cx16.r15, color)
+            plotq()
             cx16.r14 = xcenter + yy
             cx16.r15 = ycenter + xx
-            plot(cx16.r14, cx16.r15, color)
+            plotq()
             cx16.r14 = xcenter - yy
-            plot(cx16.r14, cx16.r15, color)
+            plotq()
             cx16.r14 = xcenter + yy
             cx16.r15 = ycenter - xx
-            plot(cx16.r14, cx16.r15, color)
+            plotq()
             cx16.r14 = xcenter - yy
-            plot(cx16.r14, cx16.r15, color)
+            plotq()
 
             yy++
-            if decisionOver2<=0
-                decisionOver2 += (yy as word)*2+1
-            else {
+            if decisionOver2>=0 {
                 xx--
-                decisionOver2 += (yy as word -xx)*2+1
+                decisionOver2 -= xx*$0002
             }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+
+        sub plotq() {
+            ; cx16.r14 = x, cx16.r15 = y, color=color.
+            plot(cx16.r14, cx16.r15, color)
+        }
+    }
+
+    sub safe_circle(uword @zp xcenter, uword @zp ycenter, ubyte radius, ubyte color) {
+        ; This version does bounds checks and clipping, but is a lot slower.
+        ; Midpoint algorithm.
+        if radius==0
+            return
+
+        ubyte @zp xx = radius
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-xx
+        ; R14 = internal plot X
+        ; R15 = internal plot Y
+
+        while xx>=yy {
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter + yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter - yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter + xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter - xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+
+            yy++
+            if decisionOver2>=0 {
+                xx--
+                decisionOver2 -= xx*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+
+        sub plotq() {
+            ; cx16.r14 = x, cx16.r15 = y, color=color.
+            safe_plot(cx16.r14, cx16.r15, color)
         }
     }
 
     sub disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, ubyte color) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
         ; Midpoint algorithm, filled
         if radius==0
             return
@@ -560,17 +482,39 @@ _done
             horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, color)
             horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, color)
             yy++
-            if decisionOver2<=0
-                decisionOver2 += (yy as word)*2+1
-            else {
+            if decisionOver2>=0 {
                 radius--
-                decisionOver2 += (yy as word -radius)*2+1
+                decisionOver2 -= radius*$0002
             }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+    }
+
+    sub safe_disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, ubyte color) {
+        ; This version does bounds checks and clipping, but is a lot slower.
+        ; Midpoint algorithm, filled
+        if radius==0
+            return
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-radius
+
+        while radius>=yy {
+            safe_horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, color)
+            safe_horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, color)
+            safe_horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, color)
+            safe_horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, color)
+            yy++
+            if decisionOver2>=0 {
+                radius--
+                decisionOver2 -= radius*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
         }
     }
 
     sub plot(uword @zp xx, uword @zp yy, ubyte @zp color) {
-        ubyte[8] @shared maskbits = [128, 64, 32, 16, 8, 4, 2, 1]
         ubyte[4] @shared mask4c = [%00111111, %11001111, %11110011, %11111100]
         ubyte[4] @shared shift4c = [6,4,2,0]
         ubyte[4] shiftedleft_4c_1 = [1<<6, 1<<4, 1<<2, 1<<0]
@@ -579,31 +523,6 @@ _done
 
         when active_mode {
             1 -> {
-                ; lores monochrome
-                if color {
-                    ; solid color or perhaps stipple
-                    %asm {{
-                        lda  xx
-                        eor  yy
-                        ora  monochrome_dont_stipple_flag
-                        and  #1
-                    }}
-                    if_nz {
-                        mode_1_prepare()
-                        %asm {{
-                            tsb  cx16.VERA_DATA0
-                        }}
-                    }
-                } else {
-                    ; only erase
-                    mode_1_prepare()
-                    %asm {{
-                        trb  cx16.VERA_DATA0
-                    }}
-                }
-            }
-            ; TODO modes 2, 3
-            4 -> {
                 ; lores 256c
                 void addr_mul_24_for_lores_256c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 %asm {{
@@ -619,32 +538,8 @@ _done
                     sta  cx16.VERA_DATA0
                 }}
             }
-            5 -> {
-                ; highres monochrome
-                if color {
-                    ; solid color or perhaps stipple
-                    %asm {{
-                        lda  xx
-                        eor  yy
-                        ora  monochrome_dont_stipple_flag
-                        and  #1
-                    }}
-                    if_nz {
-                        mode_5_prepare()
-                        %asm {{
-                            tsb  cx16.VERA_DATA0
-                        }}
-                    }
-                } else {
-                    ; only erase
-                    mode_5_prepare()
-                    %asm {{
-                        trb  cx16.VERA_DATA0
-                    }}
-                }
-            }
-            6 -> {
-                ; highres 4c   ....also mostly usable for mode 2, lores 4c?
+            2 -> {
+                ; highres 4c   ....also mostly usable for lores 4c?
                 void addr_mul_24_for_highres_4c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 cx16.r2L = lsb(xx) & 3       ; xbits
                 ; color &= 3
@@ -670,76 +565,20 @@ _done
                 }}
             }
         }
+    }
 
-        sub mode_1_prepare() {
-            %asm {{
-                lda  xx
-                and  #7
-                pha     ; xbits
-            }}
-            xx /= 8
-            xx += yy*(320/8)
-            %asm {{
-                stz  cx16.VERA_CTRL
-                stz  cx16.VERA_ADDR_H
-                lda  xx+1
-                sta  cx16.VERA_ADDR_M
-                lda  xx
-                sta  cx16.VERA_ADDR_L
-                ply     ; xbits
-                lda  maskbits,y
-            }}
-        }
-
-        sub mode_5_prepare() {
-            %asm {{
-                lda  xx
-                and  #7
-                pha     ; xbits
-            }}
-            xx /= 8
-            xx += yy*(640/8)
-            %asm {{
-                stz  cx16.VERA_CTRL
-                stz  cx16.VERA_ADDR_H
-                lda  xx+1
-                sta  cx16.VERA_ADDR_M
-                lda  xx
-                sta  cx16.VERA_ADDR_L
-                ply     ; xbits
-                lda  maskbits,y
-            }}
-        }
+    sub safe_plot(uword xx, uword yy, ubyte color) {
+        ; A plot that does bounds checks to see if the pixel is inside the screen.
+        if msb(xx)&$80!=0 or msb(yy)&$80!=0
+            return
+        if xx >= width or yy >= height
+            return
+        plot(xx, yy, color)
     }
 
     sub pget(uword @zp xx, uword yy) -> ubyte {
         when active_mode {
             1 -> {
-                ; lores monochrome
-                %asm {{
-                    lda  xx
-                    and  #7
-                    pha     ; xbits
-                }}
-                xx /= 8
-                xx += yy*(320/8)
-                %asm {{
-                    stz  cx16.VERA_CTRL
-                    stz  cx16.VERA_ADDR_H
-                    lda  xx+1
-                    sta  cx16.VERA_ADDR_M
-                    lda  xx
-                    sta  cx16.VERA_ADDR_L
-                    ply         ; xbits
-                    lda  plot.maskbits,y
-                    and  cx16.VERA_DATA0
-                    beq  +
-                    lda  #1
-+
-                }}
-            }
-            ; TODO modes 2, 3
-            4 -> {
                 ; lores 256c
                 void addr_mul_24_for_lores_256c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 %asm {{
@@ -753,31 +592,7 @@ _done
                     lda  cx16.VERA_DATA0
                 }}
             }
-            5 -> {
-                ; hires monochrome
-                %asm {{
-                    lda  xx
-                    and  #7
-                    pha     ; xbits
-                }}
-                xx /= 8
-                xx += yy*(640/8)
-                %asm {{
-                    stz  cx16.VERA_CTRL
-                    stz  cx16.VERA_ADDR_H
-                    lda  xx+1
-                    sta  cx16.VERA_ADDR_M
-                    lda  xx
-                    sta  cx16.VERA_ADDR_L
-                    ply     ; xbits
-                    lda  plot.maskbits,y
-                    and  cx16.VERA_DATA0
-                    beq  +
-                    lda  #1
-+
-                }}
-            }
-            6 -> {
+            2 -> {
                 ; hires 4c
                 void addr_mul_24_for_highres_4c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
                 %asm {{
@@ -789,21 +604,32 @@ _done
                     lda  cx16.r0L
                     sta  cx16.VERA_ADDR_L
                     lda  cx16.VERA_DATA0
-                    sta  cx16.r0L
+                    pha
+                    lda  xx
+                    and  #3
+                    tay
+                    lda  gfx2.plot.shift4c,y
+                    tay
+                    pla
+                    cpy  #0
+                    beq  +
+-                   lsr  a
+                    dey
+                    bne  -
++                   and #3
                 }}
-                cx16.r1L = lsb(xx) & 3
-                cx16.r0L >>= gfx2.plot.shift4c[cx16.r1L]
-                return cx16.r0L & 3
             }
             else -> return 0
         }
     }
 
-    sub fill(word @zp xx, word @zp yy, ubyte new_color) {
+    sub fill(uword x, uword y, ubyte new_color) {
         ; 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 = 48
+        const ubyte MAXDEPTH = 64
+        word @zp xx = x as word
+        word @zp yy = y as word
         word[MAXDEPTH] @split @shared stack_xl
         word[MAXDEPTH] @split @shared stack_xr
         word[MAXDEPTH] @split @shared stack_y
@@ -882,11 +708,15 @@ _done
         while cx16.r12L {
             pop_stack()
             xx = x1
-            while xx >= 0 and pget(xx as uword, yy as uword) == cx16.r11L {
-                plot(xx as uword, yy as uword, cx16.r10L)
+            ; TODO: 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--
             }
-            if xx >= x1
+            if x1!=xx
+                horizontal_line(xx as uword+1, yy as uword, x1-xx as uword, cx16.r10L)
+            else
                 goto skip
 
             left = xx + 1
@@ -895,17 +725,26 @@ _done
             xx = x1 + 1
 
             do {
-                while xx <= width-1 and pget(xx as uword, yy as uword) == cx16.r11L {
-                    plot(xx as uword, yy as uword, cx16.r10L)
+                cx16.r9 = xx
+                ; TODO: 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++
                 }
+                if cx16.r9!=xx
+                    horizontal_line(cx16.r9, yy as uword, (xx as uword)-cx16.r9, cx16.r10L)
+
                 push_stack(left, xx - 1, yy, dy)
                 if xx > x2 + 1
                     push_stack(x2 + 1, xx - 1, yy, -dy)
 skip:
                 xx++
-                while xx <= x2 and pget(xx as uword, yy as uword) != cx16.r11L
+                while xx <= x2 {
+                    if pget(xx as uword, yy as uword) == cx16.r11L
+                        break
                     xx++
+                }
                 left = xx
             } until xx>x2
         }
@@ -914,29 +753,16 @@ skip:
     sub position(uword @zp xx, uword yy) {
         when active_mode {
             1 -> {
-                ; lores monochrome
-                cx16.r0 = yy*(320/8) + xx/8
-                cx16.vaddr(0, cx16.r0, 0, 1)
-            }
-            ; TODO modes 2, 3
-            4 -> {
                 ; lores 256c
                 void addr_mul_24_for_lores_256c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
-                cx16.r2L = cx16.r1L
-                cx16.vaddr(cx16.r2L, cx16.r0, 0, 1)
             }
-            5 -> {
-                ; highres monochrome
-                cx16.r0 = yy*(640/8) + xx/8
-                cx16.vaddr(0, cx16.r0, 0, 1)
-            }
-            6 -> {
+            2 -> {
                 ; highres 4c
                 void addr_mul_24_for_highres_4c(yy, xx)      ; 24 bits result is in r0 and r1L (highest byte)
-                cx16.r2L = cx16.r1L
-                cx16.vaddr(cx16.r2L, cx16.r0, 0, 1)
             }
         }
+        cx16.r2L = cx16.r1L
+        cx16.vaddr(cx16.r2L, cx16.r0, 0, 1)
     }
 
     sub position2(uword @zp xx, uword yy, bool also_port_1) {
@@ -948,7 +774,6 @@ skip:
     inline asmsub next_pixel(ubyte color @A) {
         ; -- sets the next pixel byte to the graphics chip.
         ;    for 8 bpp screens this will plot 1 pixel.
-        ;    for 1 bpp screens it will plot 8 pixels at once (color = bit pattern).
         ;    for 2 bpp screens it will plot 4 pixels at once (color = bit pattern).
         %asm {{
             sta  cx16.VERA_DATA0
@@ -958,7 +783,6 @@ skip:
     asmsub next_pixels(uword pixels @AY, uword amount @R0) clobbers(A, X, Y)  {
         ; -- sets the next bunch of pixels from a prepared array of bytes.
         ;    for 8 bpp screens this will plot 1 pixel per byte.
-        ;    for 1 bpp screens it will plot 8 pixels at once (colors are the bit patterns per byte).
         ;    for 2 bpp screens it will plot 4 pixels at once (colors are the bit patterns per byte).
         %asm {{
             sta  P8ZP_SCRATCH_W1
@@ -1019,92 +843,7 @@ skip:
         ubyte[8] @shared char_bitmap_bytes_right
 
         when active_mode {
-            1, 5 -> {
-                ; monochrome mode, either resolution
-                cx16.r3 = sctextptr
-                while @(cx16.r3) {
-                    chardataptr = charset_addr + @(cx16.r3) * $0008
-                    ; copy the character bitmap into RAM
-                    cx16.vaddr_autoincr(charset_bank, chardataptr, 0, 1)
-                    %asm {{
-                        ; pre-shift the bits
-                        lda  text.xx
-                        and  #7
-                        sta  P8ZP_SCRATCH_B1
-                        ldy  #0
--                       lda  cx16.VERA_DATA0
-                        stz  P8ZP_SCRATCH_REG
-                        ldx  P8ZP_SCRATCH_B1
-                        cpx  #0
-                        beq  +
--                       lsr  a
-                        ror  P8ZP_SCRATCH_REG
-                        dex
-                        bne  -
-+                       sta  char_bitmap_bytes_left,y
-                        lda  P8ZP_SCRATCH_REG
-                        sta  char_bitmap_bytes_right,y
-                        iny
-                        cpy  #8
-                        bne  --
-                    }}
-                    ; left part of shifted char
-                    position2(xx, yy, true)
-                    set_autoincrs_mode1_or_5()
-                    if color {
-                        %asm {{
-                            ldy  #0
--                           lda  char_bitmap_bytes_left,y
-                            ora  cx16.VERA_DATA1
-                            sta  cx16.VERA_DATA0
-                            iny
-                            cpy  #8
-                            bne  -
-                        }}
-                    } else {
-                        %asm {{
-                            ldy  #0
--                           lda  char_bitmap_bytes_left,y
-                            eor  #255
-                            and  cx16.VERA_DATA1
-                            sta  cx16.VERA_DATA0
-                            iny
-                            cpy  #8
-                            bne  -
-                        }}
-                    }
-                    ; right part of shifted char
-                    if lsb(xx) & 7 {
-                        position2(xx+8, yy, true)
-                        set_autoincrs_mode1_or_5()
-                        if color {
-                            %asm {{
-                                ldy  #0
-    -                           lda  char_bitmap_bytes_right,y
-                                ora  cx16.VERA_DATA1
-                                sta  cx16.VERA_DATA0
-                                iny
-                                cpy  #8
-                                bne  -
-                            }}
-                        } else {
-                            %asm {{
-                                ldy  #0
-    -                           lda  char_bitmap_bytes_right,y
-                                eor  #255
-                                and  cx16.VERA_DATA1
-                                sta  cx16.VERA_DATA0
-                                iny
-                                cpy  #8
-                                bne  -
-                            }}
-                        }
-                    }
-                    cx16.r3++
-                    xx += 8
-                }
-            }
-            4 -> {
+            1 -> {
                 ; lores 256c
                 while @(sctextptr) {
                     chardataptr = charset_addr + (@(sctextptr) as uword)*8
@@ -1131,7 +870,7 @@ skip:
                     sctextptr++
                 }
             }
-            6 -> {
+            2 -> {
                 ; hires 4c
                 ; we're going to use a few cx16 registers to make sure every variable is in zeropage in the inner loop.
                 cx16.r11L = color
@@ -1194,34 +933,21 @@ skip:
                 }
             }
         }
-
-        sub set_autoincrs_mode1_or_5() {
-            ; set autoincrements to go to next pixel row (40 or 80 increment)
-            if active_mode==1 {
-                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)
-            } 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)
-            }
-        }
     }
 
-    asmsub cs_innerloop640() clobbers(Y) {
+    asmsub cs_innerloop640(ubyte color @A) clobbers(Y) {
+        ; using verafx 32 bits writes here would make this faster but it's safer to
+        ; use verafx only explicitly when you know what you're doing.
         %asm {{
             ldy  #80
--           stz  cx16.VERA_DATA0
-            stz  cx16.VERA_DATA0
-            stz  cx16.VERA_DATA0
-            stz  cx16.VERA_DATA0
-            stz  cx16.VERA_DATA0
-            stz  cx16.VERA_DATA0
-            stz  cx16.VERA_DATA0
-            stz  cx16.VERA_DATA0
+-           sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
             dey
             bne  -
             rts

compiler/res/prog8lib/cx16/graphics.p8

@@ -5,13 +5,19 @@
 ; Wraps the graphics functions that are in ROM.
 ; Only lo-res 320x240 256 color mode for now.
 ; Unlike graphics module on the C64, you can use colors() to set new drawing colors for every draw operation.
-; For other resolutions or other color modes, use the "gfx2" module instead. (which is Cx16-specific)
+; For other resolutions or other color modes, use the "gfx2" or "monogfx" module instead. (which is Cx16-specific)
 ; Note: there is no color palette manipulation here, you have to do that yourself or use the "palette" module.
+;
+; 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!
+;
 
 
 graphics {
     %option no_symbol_prefixing
 
+    romsub $feff = FB_cursor_position2()  clobbers(A,X,Y)     ; alias for the normal FB_cursor_position() call but reuses existing r0 and r1
+
     const uword WIDTH = 320
     const ubyte HEIGHT = 240
 
@@ -69,6 +75,8 @@ graphics {
     }
 
     sub circle(uword xcenter, ubyte ycenter, ubyte radius) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
+
         ;cx16.r0 = xcenter - radius/2
         ;cx16.r1 = ycenter - radius/2
         ;cx16.r2 = radius*2
@@ -85,43 +93,47 @@ graphics {
         while xx>=yy {
             cx16.r0 = xcenter + xx
             cx16.r1 = ycenter + yy
-            cx16.FB_cursor_position2()
+            FB_cursor_position2()
             cx16.FB_set_pixel(stroke_color)
             cx16.r0 = xcenter - xx
-            cx16.FB_cursor_position2()
+            FB_cursor_position2()
             cx16.FB_set_pixel(stroke_color)
             cx16.r0 = xcenter + xx
             cx16.r1 = ycenter - yy
-            cx16.FB_cursor_position2()
+            FB_cursor_position2()
             cx16.FB_set_pixel(stroke_color)
             cx16.r0 = xcenter - xx
-            cx16.FB_cursor_position2()
+            FB_cursor_position2()
             cx16.FB_set_pixel(stroke_color)
             cx16.r0 = xcenter + yy
             cx16.r1 = ycenter + xx
-            cx16.FB_cursor_position2()
+            FB_cursor_position2()
             cx16.FB_set_pixel(stroke_color)
             cx16.r0 = xcenter - yy
-            cx16.FB_cursor_position2()
+            FB_cursor_position2()
             cx16.FB_set_pixel(stroke_color)
             cx16.r0 = xcenter + yy
             cx16.r1 = ycenter - xx
-            cx16.FB_cursor_position2()
+            FB_cursor_position2()
             cx16.FB_set_pixel(stroke_color)
             cx16.r0 = xcenter - yy
-            cx16.FB_cursor_position2()
+            FB_cursor_position2()
             cx16.FB_set_pixel(stroke_color)
+
             yy++
-            if decisionOver2<=0 {
-                decisionOver2 += (yy as word)*2+1
-            } else {
+            if decisionOver2>=0 {
                 xx--
-                decisionOver2 += (yy as word -xx)*2+1
+                decisionOver2 -= xx*$0002
             }
+            decisionOver2 += yy*$0002
+            decisionOver2++
         }
     }
 
     sub disc(uword xcenter, ubyte ycenter, ubyte radius) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
+        ; Midpoint algorithm, filled
+
         if radius==0
             return
         ubyte @zp yy = 0
@@ -132,13 +144,14 @@ graphics {
             horizontal_line(xcenter-radius, ycenter-yy, radius*2+1)
             horizontal_line(xcenter-yy, ycenter+radius, yy*2+1)
             horizontal_line(xcenter-yy, ycenter-radius, yy*2+1)
+
             yy++
-            if decisionOver2<=0
-                decisionOver2 += (yy as word)*2+1
-            else {
+            if decisionOver2>=0 {
                 radius--
-                decisionOver2 += (yy as word -radius)*2+1
+                decisionOver2 -= radius*$0002
             }
+            decisionOver2 += yy*$0002
+            decisionOver2++
         }
     }
 

compiler/res/prog8lib/cx16/monogfx.p8

@@ -0,0 +1,913 @@
+; Monochrome Bitmap pixel graphics routines for the CommanderX16
+; Using the full-screen 640x480 and 320x240 screen modes, in 1 bpp mode (black/white).
+;
+; No text layer is currently shown, but text can be drawn as part of the bitmap itself.
+; For color bitmap graphics, see the gfx2 library.
+;
+; NOTE: a lot of the code here is similar or the same to that in gfx2
+; 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!
+;
+
+monogfx {
+
+    %option no_symbol_prefixing
+
+    ; read-only control variables:
+    uword width = 0
+    uword height = 0
+    bool dont_stipple_flag = true            ; set to false to enable stippling mode
+
+    sub lores() {
+        ; enable 320*240 bitmap mode
+        cx16.VERA_CTRL=0
+        cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
+        cx16.VERA_DC_HSCALE = 64
+        cx16.VERA_DC_VSCALE = 64
+        cx16.VERA_L1_CONFIG = %00000100
+        cx16.VERA_L1_MAPBASE = 0
+        cx16.VERA_L1_TILEBASE = 0
+        width = 320
+        height = 240
+        clear_screen(0)
+    }
+
+    sub hires() {
+        ; enable 640*480 bitmap mode
+        cx16.VERA_CTRL=0
+        cx16.VERA_DC_VIDEO = (cx16.VERA_DC_VIDEO & %11001111) | %00100000      ; enable only layer 1
+        cx16.VERA_DC_HSCALE = 128
+        cx16.VERA_DC_VSCALE = 128
+        cx16.VERA_L1_CONFIG = %00000100
+        cx16.VERA_L1_MAPBASE = 0
+        cx16.VERA_L1_TILEBASE = %00000001
+        width = 640
+        height = 480
+        clear_screen(0)
+    }
+
+    sub textmode() {
+        ; back to normal 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
+    }
+
+    sub clear_screen(ubyte color) {
+        stipple(false)
+        position(0, 0)
+        when width {
+            320 -> {
+                repeat 240/2/8
+                    cs_innerloop640(color)
+            }
+            640 -> {
+                repeat 480/8
+                    cs_innerloop640(color)
+            }
+        }
+        position(0, 0)
+    }
+
+    sub stipple(bool enable) {
+        dont_stipple_flag = not enable
+    }
+
+    sub rect(uword xx, uword yy, uword rwidth, uword rheight, bool draw) {
+        if rwidth==0 or rheight==0
+            return
+        horizontal_line(xx, yy, rwidth, draw)
+        if rheight==1
+            return
+        horizontal_line(xx, yy+rheight-1, rwidth, draw)
+        vertical_line(xx, yy+1, rheight-2, draw)
+        if rwidth==1
+            return
+        vertical_line(xx+rwidth-1, yy+1, rheight-2, draw)
+    }
+
+    sub fillrect(uword xx, uword yy, uword rwidth, uword rheight, bool draw) {
+        ; Draw a filled rectangle of the given size and color.
+        ; To fill the whole screen, use clear_screen(color) instead - it is much faster.
+        if rwidth==0
+            return
+        repeat rheight {
+            horizontal_line(xx, yy, rwidth, draw)
+            yy++
+        }
+    }
+
+    sub horizontal_line(uword xx, uword yy, uword length, bool draw) {
+        ubyte[9] masked_starts = [ 0, %00000001, %00000011, %00000111, %00001111, %00011111, %00111111, %01111111, %11111111]
+        ubyte[9] masked_ends   = [ 0, %10000000, %11000000, %11100000, %11110000, %11111000, %11111100, %11111110, %11111111]
+
+        if length==0
+            return
+        if length<=8 {
+            ; just use 2 byte writes with shifted mask
+            position2(xx,yy,true)
+            %asm {{
+                ldy  length
+                lda  masked_ends,y
+                sta  cx16.r0L           ; save left byte
+                stz  P8ZP_SCRATCH_B1
+                lda  xx
+                and  #7
+                beq  +
+                tay
+                lda  cx16.r0L
+-               lsr  a
+                ror  P8ZP_SCRATCH_B1
+                dey
+                bne  -
+                sta  cx16.r0L           ; new left byte
++
+                lda  dont_stipple_flag
+                bne  _dontstipple
+                ; determine stipple pattern
+                lda  yy
+                and  #1
+                beq  +
+                lda  #%10101010
+                bne  ++
++               lda  #%01010101
++               sta  P8ZP_SCRATCH_REG
+                lda  cx16.r0L
+                and  P8ZP_SCRATCH_REG
+                sta  cx16.r0L
+                lda  P8ZP_SCRATCH_B1
+                and  P8ZP_SCRATCH_REG
+                sta  P8ZP_SCRATCH_B1
+_dontstipple
+                lda  draw
+                beq  _clear
+                lda  cx16.r0L           ; left byte
+                ora  cx16.VERA_DATA1
+                sta  cx16.VERA_DATA0
+                lda  P8ZP_SCRATCH_B1    ; right byte
+                ora  cx16.VERA_DATA1
+                sta  cx16.VERA_DATA0
+                rts
+_clear
+                lda  cx16.r0L           ; left byte
+                eor  #255
+                and  cx16.VERA_DATA1
+                sta  cx16.VERA_DATA0
+                lda  P8ZP_SCRATCH_B1    ; right byte
+                eor  #255
+                and  cx16.VERA_DATA1
+                sta  cx16.VERA_DATA0
+                rts
+            }}
+        }
+
+        ubyte separate_pixels = (8-lsb(xx)) & 7
+        if separate_pixels {
+            if dont_stipple_flag {
+                position(xx,yy)
+                cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off
+                if draw
+                    cx16.VERA_DATA0 |= masked_starts[separate_pixels]
+                else
+                    cx16.VERA_DATA0 &= ~masked_starts[separate_pixels]
+                xx += separate_pixels
+            } else {
+                repeat separate_pixels {
+                    plot(xx, yy, draw)
+                    xx++
+                }
+            }
+            length -= separate_pixels
+        }
+        if length {
+            position(xx, yy)
+            separate_pixels = lsb(length) & 7
+            xx += length & $fff8
+            %asm {{
+                lsr  length+1
+                ror  length
+                lsr  length+1
+                ror  length
+                lsr  length+1
+                ror  length
+                lda  draw
+                bne  +
+                ldy  #0     ; black
+                bra  _loop
++               lda  dont_stipple_flag
+                beq  _stipple
+                ldy  #255       ; don't stipple
+                bra  _loop
+_stipple        lda  yy
+                and  #1         ; determine stipple pattern to use
+                bne  +
+                ldy  #%01010101
+                bra  _loop
++               ldy  #%10101010
+_loop           lda  length
+                ora  length+1
+                beq  _done
+                sty  cx16.VERA_DATA0
+                lda  length
+                bne  +
+                dec  length+1
++               dec  length
+                bra  _loop
+_done
+            }}
+
+            if dont_stipple_flag {
+                cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off
+                if draw
+                    cx16.VERA_DATA0 |= masked_ends[separate_pixels]
+                else
+                    cx16.VERA_DATA0 &= ~masked_ends[separate_pixels]
+            } else {
+                repeat separate_pixels {
+                    plot(xx, yy, draw)
+                    xx++
+                }
+            }
+        }
+        cx16.VERA_ADDR_H &= %00000111   ; vera auto-increment off again
+    }
+
+    sub safe_horizontal_line(uword xx, uword yy, uword length, bool draw) {
+        ; does bounds checking and clipping
+        if msb(yy)&$80!=0 or yy>=height
+            return
+        if msb(xx)&$80!=0 {
+            length += xx
+            xx = 0
+        }
+        if xx>=width
+            return
+        if xx+length>width
+            length = width-xx
+        if length>width
+            return
+
+        horizontal_line(xx, yy, length, draw)
+    }
+
+    sub vertical_line(uword xx, uword yy, uword lheight, bool draw) {
+        cx16.r15L = monogfx.plot.maskbits[xx as ubyte & 7]           ; bitmask
+        if draw {
+            if dont_stipple_flag {
+                ; draw continuous line.
+                position2(xx,yy,true)
+                if width==320
+                    set_both_strides(11)    ; 40 increment = 1 line in 320 px monochrome
+                else
+                    set_both_strides(12)    ; 80 increment = 1 line in 640 px monochrome
+                repeat lheight {
+                    %asm {{
+                        lda  cx16.VERA_DATA0
+                        ora  cx16.r15L
+                        sta  cx16.VERA_DATA1
+                    }}
+                }
+            } else {
+                ; draw stippled line.
+                if (xx ^ yy)&1==0  {
+                    yy++
+                    lheight--
+                }
+                lheight++   ; because it is divided by 2 later, don't round off the last pixel
+                position2(xx,yy,true)
+                if width==320
+                    set_both_strides(12)    ; 80 increment = 2 line in 320 px monochrome
+                else
+                    set_both_strides(13)    ; 160 increment = 2 line in 640 px monochrome
+                repeat lheight/2 {
+                    %asm {{
+                        lda  cx16.VERA_DATA0
+                        ora  cx16.r15L
+                        sta  cx16.VERA_DATA1
+                    }}
+                }
+            }
+        } else {
+            position2(xx,yy,true)
+            cx16.r15 = ~cx16.r15    ; erase pixels
+            if width==320
+                set_both_strides(11)    ; 40 increment = 1 line in 320 px monochrome
+            else
+                set_both_strides(12)    ; 80 increment = 1 line in 640 px monochrome
+            repeat lheight {
+                %asm {{
+                    lda  cx16.VERA_DATA0
+                    and  cx16.r15L
+                    sta  cx16.VERA_DATA1
+                }}
+            }
+        }
+
+        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
+        }
+
+    }
+
+    sub line(uword @zp x1, uword @zp y1, uword @zp x2, uword @zp y2, bool draw) {
+        ; Bresenham algorithm.
+        ; This code special-cases various quadrant loops to allow simple ++ and -- operations.
+        if y1>y2 {
+            ; make sure dy is always positive to have only 4 instead of 8 special cases
+            cx16.r0 = x1
+            x1 = x2
+            x2 = cx16.r0
+            cx16.r0 = y1
+            y1 = y2
+            y2 = cx16.r0
+        }
+        word @zp dx = (x2 as word)-x1
+        word @zp dy = (y2 as word)-y1
+
+        if dx==0 {
+            vertical_line(x1, y1, abs(dy) as uword +1, draw)
+            return
+        }
+        if dy==0 {
+            if x1>x2
+                x1=x2
+            horizontal_line(x1, y1, abs(dx) as uword +1, draw)
+            return
+        }
+
+        word @zp d = 0
+        cx16.r1L = true      ; 'positive_ix'
+        if dx < 0 {
+            dx = -dx
+            cx16.r1L = false
+        }
+        word @zp dx2 = dx*2
+        word @zp dy2 = dy*2
+        cx16.r14 = x1       ; internal plot X
+
+        if dx >= dy {
+            if cx16.r1L {
+                repeat {
+                    plot(cx16.r14, y1, draw)
+                    if cx16.r14==x2
+                        return
+                    cx16.r14++
+                    d += dy2
+                    if d > dx {
+                        y1++
+                        d -= dx2
+                    }
+                }
+            } else {
+                repeat {
+                    plot(cx16.r14, y1, draw)
+                    if cx16.r14==x2
+                        return
+                    cx16.r14--
+                    d += dy2
+                    if d > dx {
+                        y1++
+                        d -= dx2
+                    }
+                }
+            }
+        }
+        else {
+            if cx16.r1L {
+                repeat {
+                    plot(cx16.r14, y1, draw)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx2
+                    if d > dy {
+                        cx16.r14++
+                        d -= dy2
+                    }
+                }
+            } else {
+                repeat {
+                    plot(cx16.r14, y1, draw)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx2
+                    if d > dy {
+                        cx16.r14--
+                        d -= dy2
+                    }
+                }
+            }
+        }
+    }
+
+    sub circle(uword @zp xcenter, uword @zp ycenter, ubyte radius, bool draw) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
+        ; Midpoint algorithm.
+        if radius==0
+            return
+
+        ubyte @zp xx = radius
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-xx
+        ; R14 = internal plot X
+        ; R15 = internal plot Y
+
+        while xx>=yy {
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter + yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter - yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter + xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter - xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+
+            yy++
+            if decisionOver2>=0 {
+                xx--
+                decisionOver2 -= xx*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+
+        sub plotq() {
+            ; cx16.r14 = x, cx16.r15 = y, draw=draw
+            plot(cx16.r14, cx16.r15, draw)
+        }
+    }
+
+    sub safe_circle(uword @zp xcenter, uword @zp ycenter, ubyte radius, bool draw) {
+        ; Does bounds checking and clipping.
+        ; Midpoint algorithm.
+        if radius==0
+            return
+
+        ubyte @zp xx = radius
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-xx
+        ; R14 = internal plot X
+        ; R15 = internal plot Y
+
+        while xx>=yy {
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter + yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter - yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter + xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter - xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+
+            yy++
+            if decisionOver2>=0 {
+                xx--
+                decisionOver2 -= xx*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+
+        sub plotq() {
+            ; cx16.r14 = x, cx16.r15 = y, draw=draw
+            safe_plot(cx16.r14, cx16.r15, draw)
+        }
+    }
+
+    sub disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, bool draw) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
+        ; Midpoint algorithm, filled
+        if radius==0
+            return
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-radius
+
+        while radius>=yy {
+            horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, draw)
+            horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, draw)
+            horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
+            yy++
+            if decisionOver2>=0 {
+                radius--
+                decisionOver2 -= radius*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+    }
+
+    sub safe_disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, bool draw) {
+        ; Does bounds checking and clipping.
+        ; Midpoint algorithm, filled
+        if radius==0
+            return
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-radius
+
+        while radius>=yy {
+            safe_horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, draw)
+            safe_horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, draw)
+            safe_horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
+            safe_horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
+            yy++
+            if decisionOver2>=0 {
+                radius--
+                decisionOver2 -= radius*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+    }
+
+    sub plot(uword @zp xx, uword @zp yy, bool @zp draw) {
+        ubyte[8] @shared maskbits = [128, 64, 32, 16, 8, 4, 2, 1]
+        if draw {
+            ; solid color or perhaps stipple
+            %asm {{
+                lda  xx
+                eor  yy
+                ora  dont_stipple_flag
+                and  #1
+            }}
+            if_nz {
+                prepare()
+                %asm {{
+                    tsb  cx16.VERA_DATA0
+                }}
+            }
+        } else {
+            ; only erase
+            prepare()
+            %asm {{
+                trb  cx16.VERA_DATA0
+            }}
+        }
+
+        sub prepare() {
+            %asm {{
+                lda  xx
+                and  #7
+                pha     ; xbits
+            }}
+            xx /= 8
+            if width==320
+                xx += yy*(320/8)
+            else
+                xx += yy*(640/8)
+            %asm {{
+                stz  cx16.VERA_CTRL
+                stz  cx16.VERA_ADDR_H
+                lda  xx+1
+                sta  cx16.VERA_ADDR_M
+                lda  xx
+                sta  cx16.VERA_ADDR_L
+                ply     ; xbits
+                lda  maskbits,y
+            }}
+        }
+    }
+
+    sub safe_plot(uword xx, uword yy, bool draw) {
+        ; A plot that does bounds checks to see if the pixel is inside the screen.
+        if msb(xx)&$80!=0 or msb(yy)&$80!=0
+            return
+        if xx >= width or yy >= height
+            return
+        plot(xx, yy, draw)
+    }
+
+    sub pget(uword @zp xx, uword yy) -> ubyte {
+        %asm {{
+            lda  xx
+            and  #7
+            pha     ; xbits
+        }}
+        xx /= 8
+        if width==320
+            xx += yy*(320/8)
+        else
+            xx += yy*(640/8)
+
+        %asm {{
+            stz  cx16.VERA_CTRL
+            stz  cx16.VERA_ADDR_H
+            lda  xx+1
+            sta  cx16.VERA_ADDR_M
+            lda  xx
+            sta  cx16.VERA_ADDR_L
+            ply         ; xbits
+            lda  plot.maskbits,y
+            and  cx16.VERA_DATA0
+            beq  +
+            lda  #1
++           rts
+        }}
+    }
+
+    sub fill(uword x, uword y, bool draw) {
+        ; 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
+        word @zp xx = x as word
+        word @zp yy = y as word
+        word[MAXDEPTH] @split @shared stack_xl
+        word[MAXDEPTH] @split @shared stack_xr
+        word[MAXDEPTH] @split @shared stack_y
+        byte[MAXDEPTH] @shared stack_dy
+        cx16.r12L = 0       ; stack pointer
+        word x1
+        word x2
+        byte dy
+        cx16.r10L = draw as ubyte
+        sub push_stack(word sxl, word sxr, word sy, byte sdy) {
+            if cx16.r12L==MAXDEPTH
+                return
+            cx16.r0s = sy+sdy
+            if cx16.r0s>=0 and cx16.r0s<=height-1 {
+;;                stack_xl[cx16.r12L] = sxl
+;;                stack_xr[cx16.r12L] = sxr
+;;                stack_y[cx16.r12L] = sy
+;;                stack_dy[cx16.r12L] = sdy
+;;                cx16.r12L++
+                %asm {{
+                    ldy  cx16.r12L
+                    lda  sxl
+                    sta  stack_xl_lsb,y
+                    lda  sxl+1
+                    sta  stack_xl_msb,y
+                    lda  sxr
+                    sta  stack_xr_lsb,y
+                    lda  sxr+1
+                    sta  stack_xr_msb,y
+                    lda  sy
+                    sta  stack_y_lsb,y
+                    lda  sy+1
+                    sta  stack_y_msb,y
+                    ldy  cx16.r12L
+                    lda  sdy
+                    sta  stack_dy,y
+                    inc  cx16.r12L
+                }}
+            }
+        }
+        sub pop_stack() {
+;;            cx16.r12L--
+;;            x1 = stack_xl[cx16.r12L]
+;;            x2 = stack_xr[cx16.r12L]
+;;            y = stack_y[cx16.r12L]
+;;            dy = stack_dy[cx16.r12L]
+            %asm {{
+                dec  cx16.r12L
+                ldy  cx16.r12L
+                lda  stack_xl_lsb,y
+                sta  x1
+                lda  stack_xl_msb,y
+                sta  x1+1
+                lda  stack_xr_lsb,y
+                sta  x2
+                lda  stack_xr_msb,y
+                sta  x2+1
+                lda  stack_y_lsb,y
+                sta  yy
+                lda  stack_y_msb,y
+                sta  yy+1
+                ldy  cx16.r12L
+                lda  stack_dy,y
+                sta  dy
+            }}
+            yy+=dy
+        }
+        cx16.r11L = pget(xx as uword, yy as uword)        ; old_color
+        if cx16.r11L == cx16.r10L
+            return
+        if xx<0 or xx>width-1 or yy<0 or yy>height-1
+            return
+        push_stack(xx, xx, yy, 1)
+        push_stack(xx, xx, yy + 1, -1)
+        word left = 0
+        while cx16.r12L {
+            pop_stack()
+            xx = x1
+            while xx >= 0 {
+                if pget(xx as uword, yy as uword) != cx16.r11L
+                    break
+                xx--
+            }
+            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.r9 = xx
+                while xx <= width-1 {
+                    if pget(xx as uword, yy as uword) != cx16.r11L
+                        break
+                    xx++
+                }
+                if cx16.r9!=xx
+                    horizontal_line(cx16.r9, yy as uword, (xx as uword)-cx16.r9, cx16.r10L)
+
+                push_stack(left, xx - 1, yy, dy)
+                if xx > x2 + 1
+                    push_stack(x2 + 1, xx - 1, yy, -dy)
+skip:
+                xx++
+                while xx <= x2 {
+                    if pget(xx as uword, yy as uword) == cx16.r11L
+                        break
+                    xx++
+                }
+                left = xx
+            } until xx>x2
+        }
+    }
+
+    sub position(uword @zp xx, uword yy) {
+        if width==320
+            cx16.r0 = yy*(320/8)
+        else
+            cx16.r0 = yy*(640/8)
+        cx16.vaddr(0, cx16.r0+(xx/8), 0, 1)
+    }
+
+    sub position2(uword @zp xx, uword yy, bool also_port_1) {
+        position(xx, yy)
+        if also_port_1
+            cx16.vaddr_clone(0)
+    }
+
+    const ubyte charset_bank = $1
+    const uword charset_addr = $f000       ; in bank 1, so $1f000
+
+    sub text_charset(ubyte charset) {
+        ; -- select the text charset to use with the text() routine
+        ;    the charset number is the same as for the cx16.screen_set_charset() ROM function.
+        ;    1 = ISO charset, 2 = PETSCII uppercase+graphs, 3= PETSCII uppercase+lowercase.
+        cx16.screen_set_charset(charset, 0)
+    }
+
+    sub text(uword @zp xx, uword yy, bool draw, uword sctextptr) {
+        ; -- Write some text at the given pixel position. The text string must be in screencode encoding (not petscii!).
+        ;    You must also have called text_charset() first to select and prepare the character set to use.
+        uword chardataptr
+        ubyte[8] @shared char_bitmap_bytes_left
+        ubyte[8] @shared char_bitmap_bytes_right
+
+        cx16.r3 = sctextptr
+        while @(cx16.r3) {
+            chardataptr = charset_addr + @(cx16.r3) * $0008
+            ; copy the character bitmap into RAM
+            cx16.vaddr_autoincr(charset_bank, chardataptr, 0, 1)
+            %asm {{
+                ; pre-shift the bits
+                lda  text.xx
+                and  #7
+                sta  P8ZP_SCRATCH_B1
+                ldy  #0
+-               lda  cx16.VERA_DATA0
+                stz  P8ZP_SCRATCH_REG
+                ldx  P8ZP_SCRATCH_B1
+                cpx  #0
+                beq  +
+-               lsr  a
+                ror  P8ZP_SCRATCH_REG
+                dex
+                bne  -
++               sta  char_bitmap_bytes_left,y
+                lda  P8ZP_SCRATCH_REG
+                sta  char_bitmap_bytes_right,y
+                iny
+                cpy  #8
+                bne  --
+            }}
+            ; left part of shifted char
+            position2(xx, yy, true)
+            set_autoincrs()
+            if draw {
+                %asm {{
+                    ldy  #0
+-                   lda  char_bitmap_bytes_left,y
+                    ora  cx16.VERA_DATA1
+                    sta  cx16.VERA_DATA0
+                    iny
+                    cpy  #8
+                    bne  -
+                }}
+            } else {
+                %asm {{
+                    ldy  #0
+-                   lda  char_bitmap_bytes_left,y
+                    eor  #255
+                    and  cx16.VERA_DATA1
+                    sta  cx16.VERA_DATA0
+                    iny
+                    cpy  #8
+                    bne  -
+                }}
+            }
+            ; right part of shifted char
+            if lsb(xx) & 7 {
+                position2(xx+8, yy, true)
+                set_autoincrs()
+                if draw {
+                    %asm {{
+                        ldy  #0
+-                       lda  char_bitmap_bytes_right,y
+                        ora  cx16.VERA_DATA1
+                        sta  cx16.VERA_DATA0
+                        iny
+                        cpy  #8
+                        bne  -
+                    }}
+                } else {
+                    %asm {{
+                        ldy  #0
+-                       lda  char_bitmap_bytes_right,y
+                        eor  #255
+                        and  cx16.VERA_DATA1
+                        sta  cx16.VERA_DATA0
+                        iny
+                        cpy  #8
+                        bne  -
+                    }}
+                }
+            }
+            cx16.r3++
+            xx += 8
+        }
+
+        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)
+            } 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)
+            }
+        }
+    }
+
+    asmsub cs_innerloop640(ubyte color @A) clobbers(Y) {
+        ; using verafx 32 bits writes here would make this faster but it's safer to
+        ; use verafx only explicitly when you know what you're doing.
+        %asm {{
+            cmp  #0
+            beq  +
+            lda  #255
++           ldy  #80
+-           sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            sta  cx16.VERA_DATA0
+            dey
+            bne  -
+            rts
+        }}
+    }
+}

compiler/res/prog8lib/cx16/palette.p8

@@ -1,11 +1,11 @@
 ; Manipulate the Commander X16's display color palette.
-; Should you want to restore the default palette, you have to reinitialize the Vera yourself.
+; Should you want to restore the full default palette, you can call cbm.CINT()
+; The first 16 colors can be restored to their default with set_default16()
 
 palette {
     %option no_symbol_prefixing
 
     uword vera_palette_ptr
-    ubyte cc
 
     sub set_color(ubyte index, uword color) {
         vera_palette_ptr = $fa00+(index as uword * 2)
@@ -42,19 +42,30 @@ palette {
         ubyte red
         ubyte greenblue
         repeat num_colors {
-            red = @(palette_bytes_ptr) >> 4
-            palette_bytes_ptr++
-            greenblue = @(palette_bytes_ptr) & %11110000
-            palette_bytes_ptr++
-            greenblue |= @(palette_bytes_ptr) >> 4    ; add Blue
-            palette_bytes_ptr++
-            cx16.vpoke(1, vera_palette_ptr, greenblue)
+            cx16.r1 = color8to4(palette_bytes_ptr)
+            palette_bytes_ptr+=3
+            cx16.vpoke(1, vera_palette_ptr, cx16.r1H)       ; $GB
             vera_palette_ptr++
-            cx16.vpoke(1, vera_palette_ptr, red)
+            cx16.vpoke(1, vera_palette_ptr, cx16.r1L)       ; $0R
             vera_palette_ptr++
         }
     }
 
+    sub color8to4(uword colorpointer) -> uword {
+        ; accurately convert 24 bits (3 bytes) RGB color, in that order in memory, to 16 bits $GB;$0R colorvalue
+        cx16.r1 = colorpointer
+        cx16.r0 = channel8to4(@(cx16.r1))         ; (red)   -> $00:0R
+        cx16.r0H = channel8to4(@(cx16.r1+1))<<4   ; (green) -> $G0:0R
+        cx16.r0H |= channel8to4(@(cx16.r1+2))     ; (blue)  -> $GB:0R
+        return cx16.r0
+    }
+
+    sub channel8to4(ubyte channelvalue) -> ubyte {
+        ; accurately convert a single 8 bit color channel value to 4 bits,  see https://threadlocalmutex.com/?p=48
+        return msb(channelvalue * $000f + 135)
+    }
+
+
     sub set_monochrome(uword screencolorRGB, uword drawcolorRGB) {
         vera_palette_ptr = $fa00
         cx16.vpoke(1, vera_palette_ptr, lsb(screencolorRGB))   ; G,B
@@ -78,113 +89,84 @@ palette {
     }
 
     sub set_grayscale() {
+        ; set first 16 colors to a grayscale gradient from black to white
         vera_palette_ptr = $fa00
+        cx16.r2L=0
         repeat 16 {
-            cc=0
-            repeat 16 {
-                cx16.vpoke(1, vera_palette_ptr, cc)
-                vera_palette_ptr++
-                cx16.vpoke(1, vera_palette_ptr, cc)
-                vera_palette_ptr++
-                cc += $11
-            }
+            cx16.vpoke(1, vera_palette_ptr, cx16.r2L)
+            vera_palette_ptr++
+            cx16.vpoke(1, vera_palette_ptr, cx16.r2L)
+            vera_palette_ptr++
+            cx16.r2L += $11
         }
     }
 
-    uword[] C64_colorpalette_dark = [   ; this is a darker palette with more contrast
-        $000,  ; 0 = black
-        $FFF,  ; 1 = white
-        $632,  ; 2 = red
-        $7AB,  ; 3 = cyan
-        $638,  ; 4 = purple
-        $584,  ; 5 = green
-        $327,  ; 6 = blue
-        $BC6,  ; 7 = yellow
-        $642,  ; 8 = orange
-        $430,  ; 9 = brown
-        $965,  ; 10 = light red
-        $444,  ; 11 = dark grey
-        $666,  ; 12 = medium grey
-        $9D8,  ; 13 = light green
-        $65B,  ; 14 = light blue
-        $999   ; 15 = light grey
-    ]
-
-    uword[] C64_colorpalette_pepto = [  ; # this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
-        $000,  ; 0 = black
-        $FFF,  ; 1 = white
-        $833,  ; 2 = red
-        $7cc,  ; 3 = cyan
-        $839,  ; 4 = purple
-        $5a4,  ; 5 = green
-        $229,  ; 6 = blue
-        $ef7,  ; 7 = yellow
-        $852,  ; 8 = orange
-        $530,  ; 9 = brown
-        $c67,  ; 10 = light red
-        $444,  ; 11 = dark grey
-        $777,  ; 12 = medium grey
-        $af9,  ; 13 = light green
-        $76e,  ; 14 = light blue
-        $bbb   ; 15 = light grey
-    ]
-
-    uword[] C64_colorpalette_light = [  ; this is a lighter palette
-        $000,  ; 0 = black
-        $FFF,  ; 1 = white
-        $944,  ; 2 = red
-        $7CC,  ; 3 = cyan
-        $95A,  ; 4 = purple
-        $6A5,  ; 5 = green
-        $549,  ; 6 = blue
-        $CD8,  ; 7 = yellow
-        $963,  ; 8 = orange
-        $650,  ; 9 = brown
-        $C77,  ; 10 = light red
-        $666,  ; 11 = dark grey
-        $888,  ; 12 = medium grey
-        $AE9,  ; 13 = light green
-        $87C,  ; 14 = light blue
-        $AAA   ; 15 = light grey
-    ]
-
     sub set_c64pepto() {
-        vera_palette_ptr = $fa00
-        repeat 16 {
-            for cc in 0 to 15 {
-                uword ccp = C64_colorpalette_pepto[cc]
-                cx16.vpoke(1, vera_palette_ptr, lsb(ccp))     ; G, B
-                vera_palette_ptr++
-                cx16.vpoke(1, vera_palette_ptr, msb(ccp))     ; R
-                vera_palette_ptr++
-            }
-        }
+        ; set first 16 colors to the "Pepto" PAL commodore-64 palette  http://www.pepto.de/projects/colorvic/
+        uword[] colors = [
+            $000,  ; 0 = black
+            $FFF,  ; 1 = white
+            $833,  ; 2 = red
+            $7cc,  ; 3 = cyan
+            $839,  ; 4 = purple
+            $5a4,  ; 5 = green
+            $229,  ; 6 = blue
+            $ef7,  ; 7 = yellow
+            $852,  ; 8 = orange
+            $530,  ; 9 = brown
+            $c67,  ; 10 = light red
+            $444,  ; 11 = dark grey
+            $777,  ; 12 = medium grey
+            $af9,  ; 13 = light green
+            $76e,  ; 14 = light blue
+            $bbb   ; 15 = light grey
+        ]
+        set_rgb(colors, len(colors))
     }
 
-    sub set_c64light() {
-        vera_palette_ptr = $fa00
-        repeat 16 {
-            for cc in 0 to 15 {
-                uword ccp = C64_colorpalette_light[cc]
-                cx16.vpoke(1, vera_palette_ptr, lsb(ccp))     ; G, B
-                vera_palette_ptr++
-                cx16.vpoke(1, vera_palette_ptr, msb(ccp))     ; R
-                vera_palette_ptr++
-            }
-        }
+    sub set_c64ntsc() {
+        ; set first 16 colors to a NTSC commodore-64 palette
+        uword[] colors = [
+            $000,   ; 0 = black
+            $FFF,   ; 1 = white
+            $934,   ; 2 = red
+            $9ff,   ; 3 = cyan
+            $73f,   ; 4 = purple
+            $4b1,   ; 5 = green
+            $20c,   ; 6 = blue
+            $ee6,   ; 7 = yellow
+            $b53,   ; 8 = orange
+            $830,   ; 9 = brown
+            $f8a,   ; 10 = light red
+            $444,   ; 11 = dark grey
+            $999,   ; 12 = medium grey
+            $9f9,   ; 13 = light green
+            $36f,   ; 14 = light blue
+            $ccc    ; 15 = light grey
+        ]
+        set_rgb(colors, len(colors))
     }
 
-    sub set_c64dark() {
-        vera_palette_ptr = $fa00
-        repeat 16 {
-            for cc in 0 to 15 {
-                uword ccp = C64_colorpalette_dark[cc]
-                cx16.vpoke(1, vera_palette_ptr, lsb(ccp))     ; G, B
-                vera_palette_ptr++
-                cx16.vpoke(1, vera_palette_ptr, msb(ccp))     ; R
-                vera_palette_ptr++
-            }
-        }
+    sub set_default16() {
+        ; set first 16 colors to the defaults on the X16
+        uword[] colors = [
+            $000,   ; 0 = black
+            $fff,   ; 1 = white
+            $800,   ; 2 = red
+            $afe,   ; 3 = cyan
+            $c4c,   ; 4 = purple
+            $0c5,   ; 5 = green
+            $00a,   ; 6 = blue
+            $ee7,   ; 7 = yellow
+            $d85,   ; 8 = orange
+            $640,   ; 9 = brown
+            $f77,   ; 10 = light red
+            $333,   ; 11 = dark grey
+            $777,   ; 12 = medium grey
+            $af6,   ; 13 = light green
+            $08f,   ; 14 = light blue
+            $bbb    ; 15 = light grey
+        ]
+        set_rgb(colors, len(colors))
     }
-
 }

compiler/res/prog8lib/cx16/psg.p8

@@ -104,11 +104,11 @@ psg {
         }
     }
 
-    sub envelopes_irq() {
+    sub envelopes_irq() -> bool {
         ; If you want to use real-time volume envelopes (Attack-Sustain-Release),
         ; you have to call this routine every 1/60th second, for example from your vsync irq handler,
         ; or just install this routine as the only irq handler if you don't have to do other things there.
-        ; Example: cx16.set_irq(&psg.envelopes_irq, true)
+        ; Example: cx16.set_vsync_irq_handler(&psg.envelopes_irq)
         ; NOTE: this routine calls save/restore_vera_context() for you, don't nest this or call it yourself!
 
         ; cx16.r0 = the volume word (volume scaled by 256)
@@ -170,6 +170,7 @@ psg {
         pop(cx16.r2L)
         pop(cx16.r1L)
         popw(cx16.r0)
+        return true     ; run the system IRQ handler afterwards
     }
 
     ubyte[16] envelope_states

compiler/res/prog8lib/cx16/sprites.p8

@@ -81,6 +81,33 @@ sprites {
         cx16.vpoke(1, sprite_reg+1, msb(ypos))
     }
 
+    sub move(ubyte spritenum, word dx, word dy) {
+        ; move a sprite based on its current position
+        sprite_reg = VERA_SPRITEREGS + 2 + spritenum*$0008
+        cx16.r1 = mkword(cx16.vpeek(1, sprite_reg+1), cx16.vpeek(1, sprite_reg)) as word + dx
+        cx16.r2 = mkword(cx16.vpeek(1, sprite_reg+3), cx16.vpeek(1, sprite_reg+2)) as word + dy
+        cx16.vpoke(1, sprite_reg, cx16.r1L)
+        cx16.vpoke(1, sprite_reg+1, cx16.r1H)
+        cx16.vpoke(1, sprite_reg+2, cx16.r2L)
+        cx16.vpoke(1, sprite_reg+3, cx16.r2H)
+    }
+
+    sub movex(ubyte spritenum, word dx) {
+        ; move a sprite horizontally based on its current position
+        sprite_reg = VERA_SPRITEREGS + 2 + spritenum*$0008
+        cx16.r1 = mkword(cx16.vpeek(1, sprite_reg+1), cx16.vpeek(1, sprite_reg)) as word + dx
+        cx16.vpoke(1, sprite_reg, cx16.r1L)
+        cx16.vpoke(1, sprite_reg+1, cx16.r1H)
+    }
+
+    sub movey(ubyte spritenum, word dy) {
+        ; move a sprite vertically based on its current position
+        sprite_reg = VERA_SPRITEREGS + 4 + spritenum*$0008
+        cx16.r1 = mkword(cx16.vpeek(1, sprite_reg+1), cx16.vpeek(1, sprite_reg)) as word + dy
+        cx16.vpoke(1, sprite_reg, cx16.r1L)
+        cx16.vpoke(1, sprite_reg+1, cx16.r1H)
+    }
+
     sub getx(ubyte spritenum) -> word {
         sprite_reg = VERA_SPRITEREGS + 2 + spritenum*$0008
         return mkword(cx16.vpeek(1, sprite_reg+1), cx16.vpeek(1, sprite_reg)) as word
@@ -104,7 +131,6 @@ sprites {
     }
 
     sub set_palette_offset(ubyte spritenum, ubyte offset) {
-        sprite_reg = VERA_SPRITEREGS + 7 + spritenum*$0008
-        cx16.vpoke_mask(1, sprite_reg, %11110000, offset>>4)
+        cx16.vpoke_mask(1, VERA_SPRITEREGS + 7 + spritenum*$0008, %11110000, offset>>4)
     }
 }

compiler/res/prog8lib/cx16/syslib.p8

@@ -11,9 +11,9 @@ cbm {
 ; CLEARSCR -> use txt.clear_screen
 ; HOMECRSR -> use txt.home or txt.plot
 
-romsub $FF81 = CINT() clobbers(A,X,Y)                           ; (alias: SCINIT) initialize screen editor and video chip
-romsub $FF84 = IOINIT() clobbers(A, X)                          ; initialize I/O devices (CIA, SID, IRQ)
-romsub $FF87 = RAMTAS() clobbers(A,X,Y)                         ; initialize RAM, tape buffer, screen
+romsub $FF81 = CINT() clobbers(A,X,Y)                           ; (alias: SCINIT) initialize screen editor and video chip, including resetting to the default color palette
+romsub $FF84 = IOINIT() clobbers(A, X)                          ; initialize I/O devices (CIA, IRQ, ...)
+romsub $FF87 = RAMTAS() clobbers(A,X,Y)                         ; initialize RAM, screen
 romsub $FF8A = RESTOR() clobbers(A,X,Y)                         ; restore default I/O vectors
 romsub $FF8D = VECTOR(uword userptr @ XY, bool dir @ Pc) clobbers(A,Y)     ; read/set I/O vector table
 romsub $FF90 = SETMSG(ubyte value @ A)                          ; set Kernal message control flag
@@ -21,7 +21,7 @@ romsub $FF93 = SECOND(ubyte address @ A) clobbers(A)            ; (alias: LSTNSA
 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 $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
+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
 romsub $FFA5 = ACPTR() -> ubyte @ A                             ; (alias: IECIN) input byte from serial bus
 romsub $FFA8 = CIOUT(ubyte databyte @ A)                        ; (alias: IECOUT) output byte to serial bus
@@ -40,7 +40,7 @@ romsub $FFCC = CLRCHN() clobbers(A,X)                           ; (via 802 ($322
 romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A   ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
 romsub $FFD2 = CHROUT(ubyte character @ A)                           ; (via 806 ($326)) output a character
 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
+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)
@@ -120,6 +120,9 @@ cx16 {
     &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
+
 
 ; the sixteen virtual 16-bit registers in both normal unsigned mode and signed mode (s)
     &uword r0  = $0002
@@ -235,7 +238,8 @@ cx16 {
     &ubyte  VERA_CTRL           = VERA_BASE + $0005
     &ubyte  VERA_IEN            = VERA_BASE + $0006
     &ubyte  VERA_ISR            = VERA_BASE + $0007
-    &ubyte  VERA_IRQ_LINE_L     = VERA_BASE + $0008
+    &ubyte  VERA_IRQLINE_L      = VERA_BASE + $0008 ; write only
+    &ubyte  VERA_SCANLINE_L     = VERA_BASE + $0008 ; read only
     &ubyte  VERA_DC_VIDEO       = VERA_BASE + $0009 ; DCSEL= 0
     &ubyte  VERA_DC_HSCALE      = VERA_BASE + $000A ; DCSEL= 0
     &ubyte  VERA_DC_VSCALE      = VERA_BASE + $000B ; DCSEL= 0
@@ -267,6 +271,32 @@ cx16 {
     &ubyte  VERA_AUDIO_DATA     = VERA_BASE + $001D
     &ubyte  VERA_SPI_DATA       = VERA_BASE + $001E
     &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
+    &ubyte VERA_FX_Y_INCR_L     = VERA_BASE + $000b
+    &ubyte VERA_FX_Y_INCR_H     = VERA_BASE + $000c
+    &ubyte VERA_FX_X_POS_L      = VERA_BASE + $0009
+    &ubyte VERA_FX_X_POS_H      = VERA_BASE + $000a
+    &ubyte VERA_FX_Y_POS_L      = VERA_BASE + $000b
+    &ubyte VERA_FX_Y_POS_H      = VERA_BASE + $000c
+    &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
+    &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
 ; VERA_PALETTE_BASE = $1FA00
 ; VERA_SPRITES_BASE = $1FC00
@@ -320,17 +350,16 @@ cx16 {
 ; 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 $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 $ff6e = jsrfar()  ; following word = address to call, byte after that=rom/ram bank it is in
+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 $ff7a = cmpare(ubyte data @A, ubyte bank @X, ubyte index @Y)  clobbers(X)
-romsub $ff7d = primm()
+romsub $ff7d = PRIMM()
 
 ; It's not documented what registers are clobbered, so we assume the worst for all following kernal routines...:
 
@@ -354,7 +383,6 @@ romsub $fef6 = FB_init()  clobbers(A,X,Y)
 romsub $fef9 = FB_get_info()  clobbers(X,Y) -> byte @A, uword @R0, uword @R1    ; width=r0, height=r1
 romsub $fefc = FB_set_palette(uword pointer @R0, ubyte index @A, ubyte colorcount @X)  clobbers(A,X,Y)
 romsub $feff = FB_cursor_position(uword x @R0, uword y @R1)  clobbers(A,X,Y)
-romsub $feff = FB_cursor_position2()  clobbers(A,X,Y)           ;  alias for the previous routine, but avoiding having to respecify both x and y every time
 romsub $ff02 = FB_cursor_next_line(uword x @R0)  clobbers(A,X,Y)
 romsub $ff05 = FB_get_pixel()  clobbers(X,Y) -> ubyte @A
 romsub $ff08 = FB_get_pixels(uword pointer @R0, uword count @R1)  clobbers(A,X,Y)
@@ -384,10 +412,11 @@ romsub $fed5 = console_set_paging_message(uword msgptr @R0)  clobbers(A,X,Y)
 romsub $fecf = entropy_get() -> ubyte @A, ubyte @X, ubyte @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 $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 $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, ubyte jiffies @R3)  clobbers(A, X, Y)
-romsub $ff50 = clock_get_date_time()  clobbers(A, X, Y)  -> uword @R0, uword @R1, uword @R2, ubyte @R3   ; result registers see clock_set_date_time()
+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()
 
 ; keyboard, mouse, joystick
 ; note: also see the kbdbuf_clear() helper routine below!
@@ -396,7 +425,7 @@ romsub $febd = kbdbuf_peek2() -> uword @AX             ; alternative to above to
 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(ubyte shape @A, ubyte resX @X, ubyte resY @Y)  clobbers (A, X, Y)
+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 $ff71 = mouse_scan()  clobbers(A, X, Y)
 romsub $ff53 = joystick_scan()  clobbers(A, X, Y)
@@ -439,7 +468,7 @@ asmsub kbdbuf_clear() {
     }}
 }
 
-asmsub mouse_config2(ubyte shape @A) clobbers (A, X, Y) {
+asmsub mouse_config2(byte shape @A) clobbers (A, X, Y) {
     ; -- convenience wrapper function that handles the screen resolution for mouse_config() for you
     %asm {{
         pha                         ; save shape
@@ -515,16 +544,12 @@ asmsub vpeek(ubyte bank @A, uword address @XY) -> ubyte @A {
         ; -- get a byte from VERA's video memory
         ;    note: inefficient when reading multiple sequential bytes!
         %asm {{
-                pha
-                lda  cx16.VERA_CTRL
-                ora  #1
-                sta  cx16.VERA_CTRL
-                pla
+                stz  cx16.VERA_CTRL
                 and  #1
                 sta  cx16.VERA_ADDR_H
                 sty  cx16.VERA_ADDR_M
                 stx  cx16.VERA_ADDR_L
-                lda  cx16.VERA_DATA1
+                lda  cx16.VERA_DATA0
                 rts
             }}
 }
@@ -558,7 +583,6 @@ asmsub vaddr(ubyte bank @A, uword address @R0, ubyte addrsel @R1, byte autoIncrO
 
 asmsub vaddr_clone(ubyte port @A) clobbers (A,X,Y) {
     ; -- clones Vera addresses from the given source port to the other one.
-    ;    leaves CTRL on the destination port.
     %asm {{
         sta  VERA_CTRL
         ldx  VERA_ADDR_L
@@ -571,6 +595,8 @@ asmsub vaddr_clone(ubyte port @A) clobbers (A,X,Y) {
         sty  VERA_ADDR_M
         ply
         sty  VERA_ADDR_H
+        eor  #1
+        sta  VERA_CTRL
         rts
     }}
 }
@@ -821,8 +847,219 @@ 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
+        %asm {{
+            sei
+            sta  P8ZP_SCRATCH_REG
+            lda  $00
+            pha
+            stz  $00
+            lda  P8ZP_SCRATCH_REG
+            sta  cx16.edkeybk
+            stx  cx16.edkeyvec
+            sty  cx16.edkeyvec+1
+            pla
+            sta  $00
+            cli
+            rts
+        }}
+    }
+
+    asmsub get_chrin_keyhandler() -> ubyte @R0, uword @R1 {
+        ; --- retrieve the currently set CHRIN keyhandler in a safe manner, bank in r0L, handler address in R1.
+        %asm {{
+            sei
+            lda  $00
+            pha
+            stz  $00
+            lda  cx16.edkeybk
+            sta  cx16.r0L
+            lda  cx16.edkeyvec
+            ldy  cx16.edkeyvec+1
+            sta  cx16.r1
+            sty  cx16.r1+1
+            pla
+            sta  $00
+            cli
+            rts
+        }}
+    }
+
+
+    ; Commander X16 IRQ dispatcher routines
+
+inline asmsub  disable_irqs() clobbers(A) {
+    ; Disable all Vera IRQ sources. Note that it does NOT set the CPU IRQ disabled status bit!
+    %asm {{
+        lda  #%00001111
+        trb  cx16.VERA_IEN
+    }}
 }
 
+asmsub  enable_irq_handlers(bool disable_all_irq_sources @Pc) clobbers(A,Y)  {
+    ; Install the "master IRQ handler" that will dispatch IRQs
+    ; to the registered handler for each type.  (Only Vera IRQs supported for now).
+    ; The handlers don't need to clear its ISR bit, but have to return 0 or 1 in A,
+    ; where 1 means: continue with the system IRQ handler, 0 means: don't call that.
+	%asm {{
+        php
+        sei
+        bcc  +
+        lda  #%00001111
+        trb  cx16.VERA_IEN      ; disable all IRQ sources
++       lda  #<_irq_dispatcher
+        ldy  #>_irq_dispatcher
+        sta  cx16.CINV
+        sty  cx16.CINV+1
+        plp
+        rts
+
+_irq_dispatcher
+        ; order of handling: LINE, SPRCOL, AFLOW, VSYNC.
+        jsr  sys.save_prog8_internals
+        cld
+        lda  cx16.VERA_ISR
+        and  cx16.VERA_IEN          ; only consider the bits for sources that can actually raise the IRQ
+
+        bit  #2
+        beq  +
+_mod_line_jump
+        jsr  _default_line_handler      ; modified
+        ldy  #2
+        sty  cx16.VERA_ISR
+        bra  _dispatch_end
++
+        bit  #4
+        beq  +
+_mod_sprcol_jump
+        jsr  _default_sprcol_handler      ; modified
+        ldy  #4
+        sty  cx16.VERA_ISR
+        bra  _dispatch_end
++
+        bit  #8
+        beq  +
+_mod_aflow_jump
+        jsr  _default_aflow_handler      ; modified
+        ; note: AFLOW can only be cleared by filling the audio FIFO for at least 1/4. Not via the ISR bit.
+        bra  _dispatch_end
++
+        bit  #1
+        beq  +
+_mod_vsync_jump
+        jsr  _default_vsync_handler      ; modified
+        cmp  #0
+        bne  _dispatch_end
+        ldy  #1
+        sty  cx16.VERA_ISR
+        bra  _return_irq
++
+        lda  #0
+_dispatch_end
+        cmp  #0
+        beq  _return_irq
+        jsr  sys.restore_prog8_internals
+		jmp  (sys.restore_irq._orig_irqvec)   ; continue with normal kernal irq routine
+_return_irq
+        jsr  sys.restore_prog8_internals
+		ply
+		plx
+		pla
+		rti
+
+_default_vsync_handler
+        lda  #1
+        rts
+_default_line_handler
+        lda  #0
+        rts
+_default_sprcol_handler
+        lda  #0
+        rts
+_default_aflow_handler
+        lda  #0
+        rts
+    }}
+}
+
+asmsub set_vsync_irq_handler(uword address @AY) clobbers(A) {
+    ; Sets the VSYNC irq handler to use with enable_irq_handlers().  Also enables VSYNC irqs.
+    ; NOTE: unless a proper irq handler is already running, you should enclose this call in set_irqd() / clear_irqd() to avoid system crashes.
+    %asm {{
+        php
+        sei
+        sta  enable_irq_handlers._mod_vsync_jump+1
+        sty  enable_irq_handlers._mod_vsync_jump+2
+        lda  #1
+        tsb  cx16.VERA_IEN
+        plp
+        rts
+    }}
+}
+
+asmsub set_line_irq_handler(uword rasterline @R0, uword address @AY) clobbers(A,Y) {
+    ; Sets the LINE irq handler to use with enable_irq_handlers(), for the given rasterline.  Also enables LINE irqs.
+    ; You can use sys.set_rasterline() later to adjust the rasterline on which to trigger.
+    ; NOTE: unless a proper irq handler is already running, you should enclose this call in set_irqd() / clear_irqd() to avoid system crashes.
+    %asm {{
+        php
+        sei
+        sta  enable_irq_handlers._mod_line_jump+1
+        sty  enable_irq_handlers._mod_line_jump+2
+        lda  cx16.r0
+        ldy  cx16.r0+1
+        jsr  sys.set_rasterline
+        lda  #2
+        tsb  cx16.VERA_IEN
+        plp
+        rts
+    }}
+}
+
+asmsub set_sprcol_irq_handler(uword address @AY) clobbers(A) {
+    ; Sets the SPRCOL irq handler to use with enable_irq_handlers().  Also enables SPRCOL irqs.
+    ; NOTE: unless a proper irq handler is already running, you should enclose this call in set_irqd() / clear_irqd() to avoid system crashes.
+    %asm {{
+        php
+        sei
+        sta  enable_irq_handlers._mod_sprcol_jump+1
+        sty  enable_irq_handlers._mod_sprcol_jump+2
+        lda  #4
+        tsb  cx16.VERA_IEN
+        plp
+        rts
+    }}
+}
+
+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.
+    %asm {{
+        php
+        sei
+        sta  enable_irq_handlers._mod_aflow_jump+1
+        sty  enable_irq_handlers._mod_aflow_jump+2
+        lda  #8
+        tsb  cx16.VERA_IEN
+        plp
+        rts
+    }}
+}
+
+
+inline asmsub  disable_irq_handlers() {
+    ; back to the system default IRQ handler.
+    %asm {{
+        jsr  sys.restore_irq
+    }}
+}
+
+}
+
+
 sys {
     ; ------- lowlevel system routines --------
 
@@ -862,6 +1099,8 @@ asmsub  init_system()  {
         jsr  cbm.CHROUT
         lda  #147       ; clear screen
         jsr  cbm.CHROUT
+        lda  #8         ; disable charset case switch
+        jsr  cbm.CHROUT
         lda  #PROG8_VARSHIGH_RAMBANK
         sta  $00    ; select ram bank
         lda  #0
@@ -900,79 +1139,38 @@ asmsub  cleanup_at_exit() {
     }}
 }
 
-asmsub  set_irq(uword handler @AY, bool useKernal @Pc) clobbers(A)  {
+asmsub  set_irq(uword handler @AY) clobbers(A)  {
+    ; Sets the handler for the VSYNC interrupt, and enable that interrupt.
 	%asm {{
-	        sta  _modified+1
-	        sty  _modified+2
-	        lda  #0
-	        rol  a
-	        sta  _use_kernal
-		sei
-		lda  #<_irq_handler
-		sta  cx16.CINV
-		lda  #>_irq_handler
-		sta  cx16.CINV+1
-                lda  cx16.VERA_IEN
-                ora  #%00000001     ; enable the vsync irq
-                sta  cx16.VERA_IEN
-		cli
-		rts
+        sei
+        sta  _modified+1
+        sty  _modified+2
+        lda  #<_irq_handler
+        sta  cx16.CINV
+        lda  #>_irq_handler
+        sta  cx16.CINV+1
+        lda  #1
+        tsb  cx16.VERA_IEN      ; enable the vsync irq
+        cli
+        rts
 
-_irq_handler    jsr  _irq_handler_init
-_modified	jsr  $ffff                      ; modified
-		jsr  _irq_handler_end
-		lda  _use_kernal
-		bne  +
-		; end irq processing - don't use kernal's irq handling
-		lda  #1
+_irq_handler
+        jsr  sys.save_prog8_internals
+        cld
+_modified
+        jsr  $ffff                      ; modified
+        pha
+		jsr  sys.restore_prog8_internals
+		pla
+		beq  +
+		jmp  (restore_irq._orig_irqvec)   ; continue with normal kernal irq routine
++		lda  #1
 		sta  cx16.VERA_ISR      ; clear Vera Vsync irq status
 		ply
 		plx
 		pla
 		rti
-+		jmp  (restore_irq._orig_irqvec)   ; continue with normal kernal irq routine
-
-_use_kernal     .byte  0
-
-_irq_handler_init
-		; save all zp scratch registers as these might be clobbered by the irq routine
-		lda  P8ZP_SCRATCH_B1
-		sta  IRQ_SCRATCH_ZPB1
-		lda  P8ZP_SCRATCH_REG
-		sta  IRQ_SCRATCH_ZPREG
-		lda  P8ZP_SCRATCH_W1
-		sta  IRQ_SCRATCH_ZPWORD1
-		lda  P8ZP_SCRATCH_W1+1
-		sta  IRQ_SCRATCH_ZPWORD1+1
-		lda  P8ZP_SCRATCH_W2
-		sta  IRQ_SCRATCH_ZPWORD2
-		lda  P8ZP_SCRATCH_W2+1
-		sta  IRQ_SCRATCH_ZPWORD2+1
-		cld
-		rts
-
-_irq_handler_end
-		; restore all zp scratch registers
-		lda  IRQ_SCRATCH_ZPB1
-		sta  P8ZP_SCRATCH_B1
-		lda  IRQ_SCRATCH_ZPREG
-		sta  P8ZP_SCRATCH_REG
-		lda  IRQ_SCRATCH_ZPWORD1
-		sta  P8ZP_SCRATCH_W1
-		lda  IRQ_SCRATCH_ZPWORD1+1
-		sta  P8ZP_SCRATCH_W1+1
-		lda  IRQ_SCRATCH_ZPWORD2
-		sta  P8ZP_SCRATCH_W2
-		lda  IRQ_SCRATCH_ZPWORD2+1
-		sta  P8ZP_SCRATCH_W2+1
-		rts
-
-IRQ_SCRATCH_ZPB1	.byte  0
-IRQ_SCRATCH_ZPREG	.byte  0
-IRQ_SCRATCH_ZPWORD1	.word  0
-IRQ_SCRATCH_ZPWORD2	.word  0
-
-		}}
+    }}
 }
 
 asmsub  restore_irq() clobbers(A) {
@@ -983,8 +1181,8 @@ asmsub  restore_irq() clobbers(A) {
 	    lda  _orig_irqvec+1
 	    sta  cx16.CINV+1
 	    lda  cx16.VERA_IEN
-	    and  #%11110000     ; disable all Vera IRQs
-	    ora  #%00000001     ; enable only the vsync Irq
+	    and  #%11110000     ; disable all Vera IRQs but the vsync
+	    ora  #%00000001
 	    sta  cx16.VERA_IEN
 	    cli
 	    rts
@@ -993,15 +1191,16 @@ _orig_irqvec    .word  0
 }
 
 asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0) clobbers(A) {
+    ; Sets the handler for the LINE interrupt, and enable (only) that interrupt.
 	%asm {{
+            sei
             sta  _modified+1
             sty  _modified+2
             lda  cx16.r0
             ldy  cx16.r0+1
-            sei
             lda  cx16.VERA_IEN
-            and  #%11110000     ; clear other IRQs
-            ora  #%00000010     ; enable the line (raster) irq
+            and  #%11110000     ; disable all irqs but the line(raster) one
+            ora  #%00000010
             sta  cx16.VERA_IEN
             lda  cx16.r0
             ldy  cx16.r0+1
@@ -1014,13 +1213,13 @@ asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0) clobbers(A) {
             rts
 
 _raster_irq_handler
-            jsr  set_irq._irq_handler_init
-_modified   jsr  $ffff                      ; modified
-            jsr  set_irq._irq_handler_end
+            jsr  sys.save_prog8_internals
+            cld
+_modified   jsr  $ffff    ; modified
+            jsr  sys.restore_prog8_internals
             ; end irq processing - don't use kernal's irq handling
-            lda  cx16.VERA_ISR
-            ora  #%00000010
-            sta  cx16.VERA_ISR      ; clear Vera line irq status
+            lda  #2
+            tsb  cx16.VERA_ISR      ; clear Vera line irq status
             ply
             plx
             pla
@@ -1030,16 +1229,19 @@ _modified   jsr  $ffff                      ; modified
 
 asmsub  set_rasterline(uword line @AY) {
     %asm {{
-        sta  cx16.VERA_IRQ_LINE_L
-        lda  cx16.VERA_IEN
-        and  #%01111111
-        sta  cx16.VERA_IEN
+        php
+        sei
+        sta  cx16.VERA_IRQLINE_L
         tya
         lsr  a
-        ror  a
-        and  #%10000000
-        ora  cx16.VERA_IEN
-        sta  cx16.VERA_IEN
+        bcs  +
+        lda  #%10000000
+        trb  cx16.VERA_IEN
+        plp
+        rts
++       lda  #%10000000
+        tsb  cx16.VERA_IEN
+        plp
         rts
     }}
 }
@@ -1239,7 +1441,61 @@ _longcopy
         }}
     }
 
-    inline asmsub exit(ubyte returnvalue @A) {
+    inline asmsub disable_caseswitch() {
+        %asm {{
+            lda  #8
+            jsr  cbm.CHROUT
+        }}
+    }
+
+    inline asmsub enable_caseswitch() {
+        %asm {{
+            lda  #9
+            jsr  cbm.CHROUT
+        }}
+    }
+
+    asmsub save_prog8_internals() {
+        %asm {{
+            lda  P8ZP_SCRATCH_B1
+            sta  save_SCRATCH_ZPB1
+            lda  P8ZP_SCRATCH_REG
+            sta  save_SCRATCH_ZPREG
+            lda  P8ZP_SCRATCH_W1
+            sta  save_SCRATCH_ZPWORD1
+            lda  P8ZP_SCRATCH_W1+1
+            sta  save_SCRATCH_ZPWORD1+1
+            lda  P8ZP_SCRATCH_W2
+            sta  save_SCRATCH_ZPWORD2
+            lda  P8ZP_SCRATCH_W2+1
+            sta  save_SCRATCH_ZPWORD2+1
+            rts
+save_SCRATCH_ZPB1	.byte  0
+save_SCRATCH_ZPREG	.byte  0
+save_SCRATCH_ZPWORD1	.word  0
+save_SCRATCH_ZPWORD2	.word  0
+        }}
+    }
+
+    asmsub restore_prog8_internals() {
+        %asm {{
+            lda  save_prog8_internals.save_SCRATCH_ZPB1
+            sta  P8ZP_SCRATCH_B1
+            lda  save_prog8_internals.save_SCRATCH_ZPREG
+            sta  P8ZP_SCRATCH_REG
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1
+            sta  P8ZP_SCRATCH_W1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1+1
+            sta  P8ZP_SCRATCH_W1+1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2
+            sta  P8ZP_SCRATCH_W2
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2+1
+            sta  P8ZP_SCRATCH_W2+1
+            rts
+        }}
+    }
+
+    asmsub exit(ubyte returnvalue @A) {
         ; -- immediately exit the program with a return code in the A register
         %asm {{
             jsr  cbm.CLRCHN		; reset i/o channels

compiler/res/prog8lib/cx16/textio.p8

@@ -1,4 +1,6 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the CommanderX16
+; All routines work with Screencode character encoding, except `print`, `chrout` and `input_chars`,
+; these work with PETSCII encoding instead.
 
 %import syslib
 %import conv
@@ -42,6 +44,43 @@ asmsub column(ubyte col @A) clobbers(A, X, Y) {
     }}
 }
 
+asmsub get_column() -> ubyte @Y {
+    %asm {{
+        sec
+        jmp cbm.PLOT
+    }}
+}
+
+asmsub row(ubyte rownum @A) clobbers(A, X, Y) {
+    ; ---- set the cursor on the given row (starting with 0) on the current line
+    %asm {{
+        sec
+        jsr  cbm.PLOT
+        tax
+        clc
+        jmp  cbm.PLOT
+    }}
+}
+
+asmsub get_row() -> ubyte @X {
+    %asm {{
+        sec
+        jmp cbm.PLOT
+    }}
+}
+
+sub get_cursor(uword colptr, uword rowptr) {
+    %asm {{
+        sec
+        jsr cbm.PLOT
+        tya
+        ldy #$00
+        sta (colptr),y
+        txa
+        sta (rowptr),y
+    }}
+}
+
 asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A, X)  {
 	; ---- fill the character screen with the given fill character and character color.
 	%asm {{
@@ -384,10 +423,10 @@ _nextline
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
+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 from 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.
@@ -572,7 +611,8 @@ asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 }
 
 asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
-	; ---- Input a string (max. 80 chars) from the keyboard. Returns length in Y. (string is terminated with a 0 byte as well)
+	; ---- 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 {{
@@ -756,4 +796,11 @@ asmsub height() clobbers(X, Y) -> ubyte @A {
     }}
 }
 
+asmsub waitkey() -> ubyte @A {
+    %asm {{
+-       jsr cbm.GETIN
+        beq -
+        rts
+    }}
+}
 }

compiler/res/prog8lib/cx16/verafx.p8

@@ -0,0 +1,131 @@
+; Experimental Vera FX support.
+; Docs:
+; https://github.com/X16Community/x16-docs/blob/master/VERA%20FX%20Reference.md
+; https://docs.google.com/document/d/1q34uWOiM3Be2pnaHRVgSdHySI-qsiQWPTo_gfE54PTg/edit
+
+verafx {
+    %option no_symbol_prefixing
+
+    sub available() -> bool {
+        ; returns true if Vera FX is available (Vera V0.3.1 or later), false if not.
+        cx16.r1L = 0
+        cx16.r0L = cx16.VERA_CTRL
+        cx16.VERA_CTRL = $7e
+        if cx16.VERA_DC_VER0 == $56 {
+            ; Vera version number is valid.
+            ; Vera fx is available on Vera version 0.3.1 and later,
+            ; so no need to even check VERA_DC_VER1, which contains 0 (or higher)
+            cx16.r1L = mkword(cx16.VERA_DC_VER2, cx16.VERA_DC_VER3) >= $0301
+        }
+        cx16.VERA_CTRL = cx16.r0L
+        return cx16.r1L
+    }
+
+    sub clear(ubyte vbank, uword vaddr, ubyte data, uword amountof32bits) {
+        ; use cached 4-byte write to quickly clear a portion of the video memory to a given byte value
+        ; this routine is around 3 times faster as gfx2.clear_screen()
+        cx16.VERA_CTRL = 0
+        cx16.VERA_ADDR_H = vbank | %00110000       ; 4-byte increment
+        cx16.VERA_ADDR_M = msb(vaddr)
+        cx16.VERA_ADDR_L = lsb(vaddr)
+        cx16.VERA_CTRL = 6<<1       ; dcsel = 6, fill the 32 bits cache
+        cx16.VERA_FX_CACHE_L = data
+        cx16.VERA_FX_CACHE_M = data
+        cx16.VERA_FX_CACHE_H = data
+        cx16.VERA_FX_CACHE_U = data
+        cx16.VERA_CTRL = 2<<1       ; dcsel = 2
+        cx16.VERA_FX_MULT = 0
+        cx16.VERA_FX_CTRL = %01000000    ; cache write enable
+
+        if (amountof32bits & %1111110000000011) == 0 {
+            repeat lsb(amountof32bits >> 2)
+                unroll 4 cx16.VERA_DATA0=0       ; write 4*4 bytes at a time, unrolled
+        }
+        else if (amountof32bits & %1111111000000001) == 0 {
+            repeat lsb(amountof32bits >> 1)
+                unroll 2 cx16.VERA_DATA0=0       ; write 2*4 bytes at a time, unrolled
+        }
+        else if (lsb(amountof32bits) & 3) == 0 {
+            repeat amountof32bits >> 2
+                unroll 4 cx16.VERA_DATA0=0       ; write 4*4 bytes at a time, unrolled
+        }
+        else if (lsb(amountof32bits) & 1) == 0 {
+            repeat amountof32bits >> 1
+                unroll 2 cx16.VERA_DATA0=0       ; write 2*4 bytes at a time, unrolled
+        }
+        else {
+            repeat amountof32bits
+                cx16.VERA_DATA0=0       ; write 4 bytes at a time
+        }
+
+        cx16.VERA_FX_CTRL = 0       ; cache write disable
+        cx16.VERA_CTRL = 0
+    }
+
+    ; 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
+    }
+
+    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.
+        %asm {{
+            lda  #(2 << 1)
+            sta  cx16.VERA_CTRL        ; $9F25
+            stz  cx16.VERA_FX_CTRL     ; $9F29 (mainly to reset Addr1 Mode to 0)
+            lda  #%00010000
+            sta  cx16.VERA_FX_MULT     ; $9F2C
+            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.r1
+            ldy  cx16.r1+1
+            sta  cx16.VERA_FX_CACHE_H  ; $9F2B
+            sty  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
+            ; (these are the 4 bytes just before the PSG registers start)
+            lda  #(2 << 1)
+            sta  cx16.VERA_CTRL
+            lda  #%01000000           ; Cache Write Enable
+            sta  cx16.VERA_FX_CTRL
+            lda  #$bc
+            sta  cx16.VERA_ADDR_L
+            lda  #$f9
+            sta  cx16.VERA_ADDR_M
+            lda  #$01
+            sta  cx16.VERA_ADDR_H     ; no increment
+            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
+            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
+            stx  cx16.r0+1
+            stz  cx16.VERA_FX_CTRL    ; Cache write disable
+            stz  cx16.VERA_CTRL       ; reset DCSEL
+            rts
+        }}
+    }
+
+    sub transparency(bool enable) {
+        cx16.VERA_CTRL = 2<<1       ; dcsel = 2
+        if enable
+            cx16.VERA_FX_CTRL |= %10000000
+        else
+            cx16.VERA_FX_CTRL &= %01111111
+        cx16.VERA_CTRL = 0
+    }
+}

compiler/res/prog8lib/diskio.p8

@@ -7,22 +7,29 @@
 diskio {
     %option no_symbol_prefixing
 
-    ubyte drivenumber = 8
+    const ubyte READ_IO_CHANNEL=12
+    const ubyte WRITE_IO_CHANNEL=13
 
-    sub set_drive(ubyte number) {
-        drivenumber = number
+    ubyte drivenumber = 8           ; user programs can set this to the drive number they want to load/save to!
+
+    sub reset_read_channel() {
+        void cbm.CHKIN(READ_IO_CHANNEL)
+    }
+
+    sub reset_write_channel() {
+        cbm.CHKOUT(WRITE_IO_CHANNEL)
     }
 
     sub directory() -> bool {
         ; -- Prints the directory contents to the screen. Returns success.
 
         cbm.SETNAM(1, "$")
-        cbm.SETLFS(12, drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
         ubyte status = 1
         void cbm.OPEN()          ; open 12,8,0,"$"
         if_cs
             goto io_error
-        void cbm.CHKIN(12)        ; use #12 as input channel
+        reset_read_channel()
         if_cs
             goto io_error
 
@@ -60,7 +67,7 @@ diskio {
 
 io_error:
         cbm.CLRCHN()        ; restore default i/o devices
-        cbm.CLOSE(12)
+        cbm.CLOSE(READ_IO_CHANNEL)
 
         if status and status & $40 == 0 {            ; bit 6=end of file
             txt.print("\ni/o error, status: ")
@@ -76,12 +83,12 @@ io_error:
         ; -- Returns pointer to disk name string or 0 if failure.
 
         cbm.SETNAM(1, "$")
-        cbm.SETLFS(12, drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
         ubyte okay = false
         void cbm.OPEN()          ; open 12,8,0,"$"
         if_cs
             goto io_error
-        void cbm.CHKIN(12)        ; use #12 as input channel
+        reset_read_channel()
         if_cs
             goto io_error
 
@@ -96,7 +103,7 @@ io_error:
             @(cx16.r0) = cbm.CHRIN()
             if @(cx16.r0)=='"' {
                 @(cx16.r0) = ' '
-                while @(cx16.r0)==' ' and cx16.r0>=&diskio.list_filename {
+                while @(cx16.r0)==' ' and cx16.r0>=&list_filename {
                     @(cx16.r0) = 0
                     cx16.r0--
                 }
@@ -108,7 +115,7 @@ io_error:
 
 io_error:
         cbm.CLRCHN()        ; restore default i/o devices
-        cbm.CLOSE(12)
+        cbm.CLOSE(READ_IO_CHANNEL)
         if okay
             return &list_filename
         return 0
@@ -126,7 +133,7 @@ io_error:
 
     sub list_filenames(uword pattern_ptr, uword filenames_buffer, uword filenames_buf_size) -> ubyte {
         ; -- fill the provided buffer with the names of the files on the disk (until buffer is full).
-        ;    Files in the buffer are separeted by a 0 byte. You can provide an optional pattern to match against.
+        ;    Files in the buffer are separated by a 0 byte. You can provide an optional pattern to match against.
         ;    After the last filename one additional 0 byte is placed to indicate the end of the list.
         ;    Returns number of files (it skips 'dir' entries i.e. subdirectories).
         ;    Also sets carry on exit: Carry clear = all files returned, Carry set = directory has more files that didn't fit in the buffer.
@@ -152,7 +159,7 @@ io_error:
         return files_found
     }
 
-    ; ----- iterative file lister functions (uses io channel 12) -----
+    ; ----- iterative file lister functions (uses the read io channel) -----
 
     sub lf_start_list(uword pattern_ptr) -> bool {
         ; -- start an iterative file listing with optional pattern matching.
@@ -163,11 +170,11 @@ io_error:
         iteration_in_progress = true
 
         cbm.SETNAM(1, "$")
-        cbm.SETLFS(12, drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
         void cbm.OPEN()          ; open 12,8,0,"$"
         if_cs
             goto io_error
-        void cbm.CHKIN(12)        ; use #12 as input channel
+        reset_read_channel()
         if_cs
             goto io_error
 
@@ -192,7 +199,7 @@ io_error:
             return false
 
         repeat {
-            void cbm.CHKIN(12)        ; use #12 as input channel again
+            reset_read_channel()        ; use the input io channel again
 
             uword nameptr = &list_filename
             ubyte blocks_lsb = cbm.CHRIN()
@@ -253,32 +260,36 @@ close_end:
         ; -- end an iterative file listing session (close channels).
         if iteration_in_progress {
             cbm.CLRCHN()
-            cbm.CLOSE(12)
+            cbm.CLOSE(READ_IO_CHANNEL)
             iteration_in_progress = false
         }
     }
 
 
-    ; ----- iterative file loader functions (uses io channel 12) -----
+    ; ----- iterative file loader functions (uses the input io channel) -----
 
     sub f_open(uword filenameptr) -> bool {
         ; -- open a file for iterative reading with f_read
         ;    note: only a single iteration loop can be active at a time!
+        ;    Returns true if the file is successfully opened and readable.
+        ;    No need to check status(), unlike f_open_w() !
+        ;    NOTE: the default input isn't yet set to this logical file, you must use reset_read_channel() to do this,
+        ;          if you're going to read from it yourself instead of using f_read()!
         f_close()
 
         cbm.SETNAM(string.length(filenameptr), filenameptr)
-        cbm.SETLFS(12, drivenumber, 12)     ; note: has to be 12,x,12 because otherwise f_seek doesn't work
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, READ_IO_CHANNEL)     ; note: has to be Channel,x,Channel because otherwise f_seek doesn't work
         void cbm.OPEN()          ; open 12,8,12,"filename"
         if_cc {
             if cbm.READST()==0 {
                 iteration_in_progress = true
-                void cbm.CHKIN(12)          ; use #12 as input channel
+                reset_read_channel()
                 if_cc {
                     void cbm.CHRIN()        ; read first byte to test for file not found
                     if not cbm.READST() {
-                        cbm.CLOSE(12)           ; close file because we already consumed first byte
+                        cbm.CLOSE(READ_IO_CHANNEL)           ; close file because we already consumed first byte
                         void cbm.OPEN()         ; re-open the file
-                        void cbm.CHKIN(12)
+                        cbm.CLRCHN()            ; reset default i/o channels
                         return true
                     }
                 }
@@ -294,6 +305,7 @@ close_end:
         if not iteration_in_progress or not num_bytes
             return 0
 
+        reset_read_channel()
         list_blocks = 0     ; we reuse this variable for the total number of bytes read
 
         %asm {{
@@ -328,6 +340,7 @@ m_in_buffer     sta  $ffff
         if not iteration_in_progress
             return 0
 
+        reset_read_channel()
         uword total_read = 0
         while not cbm.READST() {
             cx16.r0 = f_read(bufferpointer, 256)
@@ -346,8 +359,7 @@ m_in_buffer     sta  $ffff
         %asm {{
             sta  P8ZP_SCRATCH_W1
             sty  P8ZP_SCRATCH_W1+1
-            ldx  #12
-            jsr  cbm.CHKIN              ; use channel 12 again for input
+            jsr  reset_read_channel
             ldy  #0
 _loop       jsr  cbm.CHRIN
             sta  (P8ZP_SCRATCH_W1),y
@@ -368,25 +380,28 @@ _end        rts
         ; -- end an iterative file loading session (close channels).
         if iteration_in_progress {
             cbm.CLRCHN()
-            cbm.CLOSE(12)
+            cbm.CLOSE(READ_IO_CHANNEL)
             iteration_in_progress = false
         }
     }
 
 
-    ; ----- iterative file writing functions (uses io channel 13) -----
+    ; ----- iterative file writing functions (uses write io channel) -----
 
     sub f_open_w(uword filenameptr) -> bool {
         ; -- open a file for iterative writing with f_write
+        ;    WARNING: returns true if the open command was received by the device,
+        ;    but this can still mean the file wasn't successfully opened for writing!
+        ;    (for example, if it already exists). This is different than f_open()!
+        ;    To be 100% sure if this call was successful, you have to use status()
+        ;    and check the drive's status message!
         f_close_w()
 
         cbm.SETNAM(string.length(filenameptr), filenameptr)
-        cbm.SETLFS(13, drivenumber, 1)
+        cbm.SETLFS(WRITE_IO_CHANNEL, drivenumber, 1)
         void cbm.OPEN()             ; open 13,8,1,"filename"
-        if_cc {
-            cbm.CHKOUT(13)          ; use #13 as output channel
+        if_cc
             return not cbm.READST()
-        }
         f_close_w()
         return false
     }
@@ -394,7 +409,7 @@ _end        rts
     sub f_write(uword bufferpointer, uword num_bytes) -> bool {
         ; -- write the given number of bytes to the currently open file
         if num_bytes!=0 {
-            cbm.CHKOUT(13)        ; use #13 as output channel again
+            reset_write_channel()
             repeat num_bytes {
                 cbm.CHROUT(@(bufferpointer))
                 bufferpointer++
@@ -407,7 +422,7 @@ _end        rts
     sub f_close_w() {
         ; -- end an iterative file writing session (close channels).
         cbm.CLRCHN()
-        cbm.CLOSE(13)
+        cbm.CLOSE(WRITE_IO_CHANNEL)
     }
 
 
@@ -466,9 +481,6 @@ io_error:
         if_cc
             cx16.r0L = cbm.READST()==0
 
-        cbm.CLRCHN()
-        cbm.CLOSE(1)
-
         return cx16.r0L
     }
 
@@ -496,8 +508,6 @@ io_error:
 +
         }}
 
-        cbm.CLRCHN()
-        cbm.CLOSE(1)
         return cx16.r1
     }
 

compiler/res/prog8lib/floats_functions.p8

@@ -2,15 +2,10 @@ floats {
     ; the floating point functions shared across compiler targets
     %option merge, no_symbol_prefixing
 
-sub print_f(float value) {
-	; ---- prints the floating point value (without a newline).
+asmsub print_f(float value @FAC1) clobbers(A,X,Y) {
+	; ---- prints the floating point value (without a newline). No leading space (unlike BASIC)!
 	%asm {{
-		lda  #<value
-		ldy  #>value
-		jsr  MOVFM		; load float into fac1
-		jsr  FOUT		; fac1 to string in A/Y
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
+	    jsr  str_f
 		ldy  #0
 -		lda  (P8ZP_SCRATCH_W1),y
 		beq  +
@@ -21,6 +16,25 @@ sub print_f(float value) {
 	}}
 }
 
+asmsub str_f(float value @FAC1) clobbers(X) -> str @AY {
+    ; ---- converts the floating point value to a string. No leading space!
+    %asm {{
+        jsr  FOUT
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  #0
+		lda  (P8ZP_SCRATCH_W1),y
+		cmp  #' '
+		bne  +
+		inc  P8ZP_SCRATCH_W1
+		bne  +
+		inc  P8ZP_SCRATCH_W1+1
++		lda  P8ZP_SCRATCH_W1
+		ldy  P8ZP_SCRATCH_W1+1
+		rts
+    }}
+}
+
 sub pow(float value, float power) -> float {
     %asm {{
         stx  P8ZP_SCRATCH_W1

compiler/res/prog8lib/math.asm

@@ -64,6 +64,7 @@ multiply_words	.proc
 	;       but there currently is no way to use 4 consecutive bytes in ZP (without disabling irq and saving/restoring them)...
 
 ; mult62.a
+; from: https://github.com/TobyLobster/multiply_test/blob/main/tests/mult62.a
 ; based on Dr Jefyll, http://forum.6502.org/viewtopic.php?f=9&t=689&start=0#p19958
 ; - adjusted to use fixed zero page addresses
 ; - removed 'decrement to avoid clc' as this is slower on average
@@ -73,7 +74,7 @@ multiply_words	.proc
 ; - unrolled the two inner loops once
 ;
 ; 16 bit x 16 bit unsigned multiply, 32 bit result
-; Average cycles:
+; Average cycles: ~442 ?
 ; 93 bytes
 
 _multiplicand    = P8ZP_SCRATCH_W2   ; 2 bytes

compiler/res/prog8lib/math.p8

@@ -1,4 +1,6 @@
 ; Internal Math library routines - always included by the compiler
+; note: some functions you might expect here are builtin functions,
+;       such as abs, sqrt, clamp, min, max for example.
 
 math {
     %option no_symbol_prefixing
@@ -140,6 +142,21 @@ _sinecosR8	.char  trunc(127.0 * sin(range(180+45) * rad(360.0/180.0)))
         }}
     }
 
+    asmsub mul16_last_upper() -> uword @AY {
+        ; This routine peeks into the internal 32 bits multiplication result buffer of the
+        ; 16*16 bits multiplication routine, to fetch the upper 16 bits of the last calculation.
+        ; Notes:
+        ;   - to avoid interference it's best to fetch and store this value immediately after the multiplication expression.
+        ;     for instance, simply printing a number may already result in new multiplication calls being performed
+        ;   - not all multiplications in the source code result in an actual multiplication call:
+        ;     some simpler multiplications will be optimized away into faster routines. These will not set the upper 16 bits at all!
+        %asm {{
+            lda  multiply_words.result+2
+            ldy  multiply_words.result+3
+            rts
+        }}
+    }
+
 sub direction_sc(byte x1, byte y1, byte x2, byte y2) -> ubyte {
     ; From a pair of signed coordinates around the origin, calculate discrete direction between 0 and 23 into A.
     cx16.r0L = 3        ; quadrant
@@ -430,4 +447,41 @@ log2_tab
     }}
 }
 
+    asmsub diff(ubyte v1 @A, ubyte v2 @Y) -> ubyte @A {
+        ; -- returns the (absolute) difference, or distance, between the two bytes
+        %asm {{
+            sty  P8ZP_SCRATCH_REG
+            sec
+            sbc  P8ZP_SCRATCH_REG
+            bcs  +
+            eor  #255
+            inc  a
++           rts
+        }}
+    }
+
+    asmsub diffw(uword w1 @R0, uword w2 @AY) -> uword @AY {
+        ; -- returns the (absolute) difference, or distance, between the two words
+        %asm {{
+            sec
+            sbc  cx16.r0L
+            sta  cx16.r0L
+            tya
+            sbc  cx16.r0H
+            sta  cx16.r0H
+            bcs  +
+            eor  #255
+            sta  cx16.r0H
+            lda  cx16.r0L
+            eor  #255
+            inc  a
+            sta  cx16.r0L
+            bne  +
+            inc  cx16.r0H
++           lda  cx16.r0L
+            ldy  cx16.r0H
+            rts
+        }}
+    }
+
 }

compiler/res/prog8lib/pet32/syslib.p8

@@ -297,6 +297,54 @@ _longcopy
         }}
     }
 
+    sub disable_caseswitch() {
+        ; PET doesn't have a key to swap case, so no-op
+    }
+
+    sub enable_caseswitch() {
+        ; PET doesn't have a key to swap case, so no-op
+    }
+
+    asmsub save_prog8_internals() {
+        %asm {{
+            lda  P8ZP_SCRATCH_B1
+            sta  save_SCRATCH_ZPB1
+            lda  P8ZP_SCRATCH_REG
+            sta  save_SCRATCH_ZPREG
+            lda  P8ZP_SCRATCH_W1
+            sta  save_SCRATCH_ZPWORD1
+            lda  P8ZP_SCRATCH_W1+1
+            sta  save_SCRATCH_ZPWORD1+1
+            lda  P8ZP_SCRATCH_W2
+            sta  save_SCRATCH_ZPWORD2
+            lda  P8ZP_SCRATCH_W2+1
+            sta  save_SCRATCH_ZPWORD2+1
+            rts
+save_SCRATCH_ZPB1	.byte  0
+save_SCRATCH_ZPREG	.byte  0
+save_SCRATCH_ZPWORD1	.word  0
+save_SCRATCH_ZPWORD2	.word  0
+        }}
+    }
+
+    asmsub restore_prog8_internals() {
+        %asm {{
+            lda  save_prog8_internals.save_SCRATCH_ZPB1
+            sta  P8ZP_SCRATCH_B1
+            lda  save_prog8_internals.save_SCRATCH_ZPREG
+            sta  P8ZP_SCRATCH_REG
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1
+            sta  P8ZP_SCRATCH_W1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1+1
+            sta  P8ZP_SCRATCH_W1+1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2
+            sta  P8ZP_SCRATCH_W2
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2+1
+            sta  P8ZP_SCRATCH_W2+1
+            rts
+        }}
+    }
+
     inline asmsub exit(ubyte returnvalue @A) {
         ; -- immediately exit the program with a return code in the A register
         %asm {{

compiler/res/prog8lib/pet32/textio.p8

@@ -1,4 +1,6 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the Commodore PET
+; All routines work with Screencode character encoding, except `print`, `chrout` and `input_chars`,
+; these work with PETSCII encoding instead.
 
 %import syslib
 %import conv
@@ -28,6 +30,45 @@ sub spc() {
 }
 
 
+
+asmsub get_column() -> ubyte @Y {
+    %asm {{
+        sec
+        jmp cbm.PLOT
+    }}
+}
+
+asmsub row(ubyte rownum @A) clobbers(A, X, Y) {
+    ; ---- set the cursor on the given row (starting with 0) on the current line
+    %asm {{
+        sec
+        jsr  cbm.PLOT
+        tax
+        clc
+        jmp  cbm.PLOT
+    }}
+}
+
+asmsub get_row() -> ubyte @X {
+    %asm {{
+        sec
+        jmp cbm.PLOT
+    }}
+}
+
+sub get_cursor(uword colptr, uword rowptr) {
+    %asm {{
+        sec
+        jsr cbm.PLOT
+        tya
+        ldy #$00
+        sta (colptr),y
+        txa
+        sta (rowptr),y
+    }}
+}
+
+
 asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A)  {
 	; ---- fill the character screen with the given fill character. color is ignored on PET
 	%asm {{
@@ -139,10 +180,10 @@ asmsub  scroll_down  () clobbers(A,X)  {
 	}}
 }
 
-romsub $FFD2 = chrout(ubyte character @ A)    ; for consistency. You can also use cbm.CHROUT directly ofcourse.
+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 from 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.
@@ -328,7 +369,8 @@ asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 }
 
 asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
-	; ---- Input a string (max. 80 chars) from the keyboard. Returns length in Y. (string is terminated with a 0 byte as well)
+	; ---- 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 {{
@@ -453,4 +495,11 @@ asmsub height() clobbers(X, Y) -> ubyte @A {
     }}
 }
 
+asmsub waitkey() -> ubyte @A {
+    %asm {{
+-       jsr cbm.GETIN
+        beq -
+        rts
+    }}
+}
 }

compiler/res/prog8lib/prog8_lib.asm

@@ -441,7 +441,7 @@ _return_minusone
 
 
 strlen          .proc
-        ; -- returns the number of bytes in the string in AY, in Y.
+        ; -- returns the number of bytes in the string in AY, in Y. Clobbers A.
 		sta  P8ZP_SCRATCH_W1
 		sty  P8ZP_SCRATCH_W1+1
 		ldy  #0

compiler/res/prog8lib/string.p8

@@ -146,11 +146,11 @@ _startloop	dey
 		iny
 		bne  -
 _notfound	lda  #0
-                clc
+        clc
 		rts
-_found		tya
-                sec
-                rts
+_found	tya
+        sec
+        rts
         }}
     }
 
@@ -168,6 +168,31 @@ _found		tya
         }}
     }
 
+    asmsub append(uword target @R0, uword suffix @R1) clobbers(Y) -> ubyte @A {
+        ; Append the suffix string to the target. (make sure the buffer is large enough!)
+        ; Returns the length of the resulting string.
+        %asm {{
+            lda  cx16.r0
+            ldy  cx16.r0+1
+            jsr  length
+            sty  P8ZP_SCRATCH_B1
+            tya
+            clc
+            adc  cx16.r0
+            sta  P8ZP_SCRATCH_W1
+            lda  cx16.r0+1
+            adc  #0
+            sta  P8ZP_SCRATCH_W1+1
+            lda  cx16.r1
+            ldy  cx16.r1+1
+            jsr  prog8_lib.strcpy
+            tya
+            clc
+            adc  P8ZP_SCRATCH_B1
+            rts
+        }}
+    }
+
     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.
@@ -336,4 +361,83 @@ fail    clc             ; yes, no match found, return with c=0
 	rts
 		}}
 	}
+
+
+    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]
+        ; On the English word list in /usr/share/dict/words it seems to have a pretty even distribution
+        %asm {{
+            lda  #179
+            sta  P8ZP_SCRATCH_REG
+            ldy  #0
+            clc
+-           lda  (cx16.r0),y
+            beq  +
+            rol  P8ZP_SCRATCH_REG
+            eor  P8ZP_SCRATCH_REG
+            sta  P8ZP_SCRATCH_REG
+            iny
+            bne  -
++           lda  P8ZP_SCRATCH_REG
+            rts
+        }}
+    }
+
+    asmsub isdigit(ubyte character @A) -> bool @Pc {
+        %asm {{
+            cmp  #'0'
+            bcs  +
+            rts
++           cmp  #'9'+1
+            bcc  +
+            clc
+            rts
++           sec
+            rts
+        }}
+    }
+
+    asmsub isupper(ubyte character @A) -> bool @Pc {
+        ; shifted petscii has 2 ranges that contain the upper case letters...
+        %asm {{
+            cmp  #97
+            bcs  +
+            rts
++           cmp  #122+1
+            bcc  _yes
+            cmp  #193
+            bcs  +
+            rts
++           cmp  #218+1
+            bcc  _yes
+            clc
+            rts
+_yes        sec
+            rts
+        }}
+    }
+
+    asmsub islower(ubyte character @A) -> bool @Pc {
+        %asm {{
+            cmp  #'a'
+            bcs  +
+            rts
++           cmp  #'z'+1
+            bcc  +
+            clc
+            rts
++           sec
+            rts
+        }}
+    }
+
+    asmsub isletter(ubyte character @A) -> bool @Pc {
+        %asm {{
+            jsr  islower
+            bcs  +
+            jmp  isupper
++           rts
+        }}
+    }
 }

compiler/res/prog8lib/virtual/emudbg.p8

@@ -0,0 +1,34 @@
+; Emulator debug interface. (reflecting the Commander X16 emudbg library module)
+; Docs: https://github.com/X16Community/x16-emulator#emulator-io-registers
+
+%import textio
+
+emudbg {
+
+    sub is_emulator() -> bool {
+        ; Test for emulator presence.
+        return true  ; VM is always 'emulator'
+    }
+
+    sub console_write(str message) {
+        txt.print("[EMUDBG: ")
+        txt.print(message)
+        txt.chrout(']')
+    }
+
+    sub console_chrout(ubyte char) {
+        txt.chrout(char)
+    }
+
+    sub console_value1(ubyte value) {
+        txt.print("[EMUDBG debug 1: ")
+        txt.print_uwhex(value, true)
+        txt.print("]\n")
+    }
+
+    sub console_value2(ubyte value) {
+        txt.print("[EMUDBG debug 2: ")
+        txt.print_uwhex(value, true)
+        txt.print("]\n")
+    }
+}

compiler/res/prog8lib/virtual/floats.p8

@@ -4,11 +4,13 @@
 
 floats {
 
-    const float  PI     = 3.141592653589793
-    const float  TWOPI  = 6.283185307179586
+        const float  π      = 3.141592653589793
+        const float  PI     = π
+        const float  TWOPI  = 2*π
+
 
 sub print_f(float value) {
-    ; ---- prints the floating point value (without a newline).
+    ; ---- prints the floating point value (without a newline and no leading spaces).
     %ir {{
         loadm.f fr65535,floats.print_f.value
         syscall 25 (fr65535.f)
@@ -16,6 +18,18 @@ sub print_f(float value) {
     }}
 }
 
+sub str_f(float value) -> str {
+    ; ---- converts the floating point value to a string (no leading spaces)
+    str @shared buffer=" "*20
+    %ir {{
+        load.w r65535,floats.str_f.buffer
+        loadm.f fr65535,floats.str_f.value
+        syscall 47 (r65535.w, fr65535.f)
+        load.w r0,floats.str_f.buffer
+        returnr.w r0
+    }}
+}
+
 sub parse_f(str value) -> float {
     ; -- parse a string value of a number to float
     %ir {{
@@ -155,4 +169,8 @@ sub clampf(float value, float minimum, float maximum) -> float {
     return maximum
 }
 
+sub normalize(float value) -> float {
+    return value
+}
+
 }

compiler/res/prog8lib/virtual/math.p8

@@ -1,4 +1,6 @@
 ; Internal Math library routines - always included by the compiler
+; note: some functions you might expect here are builtin functions,
+;       such as abs, sqrt, clamp, min, max for example.
 
 math {
 
@@ -209,59 +211,85 @@ math {
         }
     }
 
-sub direction(ubyte x1, ubyte y1, ubyte x2, ubyte y2) -> ubyte {
-    ; From a pair of positive coordinates, calculate discrete direction between 0 and 23 into A.
-    ; This adjusts the atan() result  so that the direction N is centered on the angle=N instead of having it as a boundary
-    ubyte angle = atan2(x1, y1, x2, y2) - 256/48
-    return 23-lsb(mkword(angle,0) / 2730)
-}
-
-sub direction_sc(byte x1, byte y1, byte x2, byte y2) -> ubyte {
-    ; From a pair of signed coordinates around the origin, calculate discrete direction between 0 and 23 into A.
-    ; shift the points into the positive quadrant
-    ubyte px1
-    ubyte py1
-    ubyte px2
-    ubyte py2
-    if x1<0 or x2<0 {
-        px1 = x1 as ubyte + 128
-        px2 = x2 as ubyte + 128
-    } else {
-        px1 = x1 as ubyte
-        px2 = x2 as ubyte
-    }
-    if y1<0 or y2<0 {
-        py1 = y1 as ubyte + 128
-        py2 = y2 as ubyte + 128
-    } else {
-        py1 = y1 as ubyte
-        py2 = y2 as ubyte
+    sub direction(ubyte x1, ubyte y1, ubyte x2, ubyte y2) -> ubyte {
+        ; From a pair of positive coordinates, calculate discrete direction between 0 and 23 into A.
+        ; This adjusts the atan() result  so that the direction N is centered on the angle=N instead of having it as a boundary
+        ubyte angle = atan2(x1, y1, x2, y2) - 256/48
+        return 23-lsb(mkword(angle,0) / 2730)
     }
 
-    return direction(px1, py1, px2, py2)
-}
+    sub direction_sc(byte x1, byte y1, byte x2, byte y2) -> ubyte {
+        ; From a pair of signed coordinates around the origin, calculate discrete direction between 0 and 23 into A.
+        ; shift the points into the positive quadrant
+        ubyte px1
+        ubyte py1
+        ubyte px2
+        ubyte py2
+        if x1<0 or x2<0 {
+            px1 = x1 as ubyte + 128
+            px2 = x2 as ubyte + 128
+        } else {
+            px1 = x1 as ubyte
+            px2 = x2 as ubyte
+        }
+        if y1<0 or y2<0 {
+            py1 = y1 as ubyte + 128
+            py2 = y2 as ubyte + 128
+        } else {
+            py1 = y1 as ubyte
+            py2 = y2 as ubyte
+        }
 
-sub direction_qd(ubyte quadrant, ubyte xdelta, ubyte ydelta) -> ubyte {
-    ; From a pair of X/Y deltas (both >=0), and quadrant 0-3, calculate discrete direction between 0 and 23.
-    when quadrant {
-        3 -> return direction(0, 0, xdelta, ydelta)
-        2 -> return direction(xdelta, 0, 0, ydelta)
-        1 -> return direction(0, ydelta, xdelta, 0)
-        else -> return direction(xdelta, ydelta, 0, 0)
+        return direction(px1, py1, px2, py2)
     }
-}
 
-sub atan2(ubyte x1, ubyte y1, ubyte x2, ubyte y2) -> ubyte {
-    ;; Calculate the angle, in a 256-degree circle, between two points into A.
-    ;; The points (x1, y1) and (x2, y2) have to use *unsigned coordinates only* from the positive quadrant in the carthesian plane!
-    %ir {{
-        loadm.b r65532,math.atan2.x1
-        loadm.b r65533,math.atan2.y1
-        loadm.b r65534,math.atan2.x2
-        loadm.b r65535,math.atan2.y2
-        syscall 44 (r65532.b, r65533.b, r65534.b, r65535.b): r0.b
-        returnr.b r0
-    }}
-}
+    sub direction_qd(ubyte quadrant, ubyte xdelta, ubyte ydelta) -> ubyte {
+        ; From a pair of X/Y deltas (both >=0), and quadrant 0-3, calculate discrete direction between 0 and 23.
+        when quadrant {
+            3 -> return direction(0, 0, xdelta, ydelta)
+            2 -> return direction(xdelta, 0, 0, ydelta)
+            1 -> return direction(0, ydelta, xdelta, 0)
+            else -> return direction(xdelta, ydelta, 0, 0)
+        }
+    }
+
+    sub atan2(ubyte x1, ubyte y1, ubyte x2, ubyte y2) -> ubyte {
+        ;; Calculate the angle, in a 256-degree circle, between two points into A.
+        ;; The points (x1, y1) and (x2, y2) have to use *unsigned coordinates only* from the positive quadrant in the carthesian plane!
+        %ir {{
+            loadm.b r65532,math.atan2.x1
+            loadm.b r65533,math.atan2.y1
+            loadm.b r65534,math.atan2.x2
+            loadm.b r65535,math.atan2.y2
+            syscall 44 (r65532.b, r65533.b, r65534.b, r65535.b): r0.b
+            returnr.b r0
+        }}
+    }
+
+    sub mul16_last_upper() -> uword {
+        ; This routine peeks into the internal 32 bits multiplication result buffer of the
+        ; 16*16 bits multiplication routine, to fetch the upper 16 bits of the last calculation.
+        ; Notes:
+        ;   - to avoid interference it's best to fetch and store this value immediately after the multiplication expression.
+        ;     for instance, simply printing a number may already result in new multiplication calls being performed
+        ;   - not all multiplications in the source code result in an actual multiplication call:
+        ;     some simpler multiplications will be optimized away into faster routines. These will not set the upper 16 bits at all!
+        %ir {{
+            syscall 46 (): r0.w
+            returnr.w r0
+        }}
+    }
+
+    sub diff(ubyte b1, ubyte b2) -> ubyte {
+        if b1>b2
+            return b1-b2
+        return b2-b1
+    }
+
+    sub diffw(uword w1, uword w2) -> uword {
+        if w1>w2
+            return w1-w2
+        return w2-w1
+    }
 
 }

compiler/res/prog8lib/virtual/monogfx.p8

@@ -0,0 +1,471 @@
+; Monochrome Bitmap pixel graphics routines for the Virtual Machine
+; Using the full-screen 640x480 and 320x240 screen modes, but just black/white.
+;
+; 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!
+
+
+monogfx {
+
+    %option no_symbol_prefixing
+
+    ; read-only control variables:
+    uword width = 0
+    uword height = 0
+    bool dont_stipple_flag = true            ; set to false to enable stippling mode
+
+    sub lores() {
+        ; enable 320*240 bitmap mode
+        sys.gfx_enable(0)
+        width = 320
+        height = 240
+        clear_screen(0)
+    }
+
+    sub hires() {
+        ; enable 640*480 bitmap mode
+        sys.gfx_enable(1)
+        width = 640
+        height = 480
+        clear_screen(0)
+    }
+
+    sub textmode() {
+        ; back to normal text mode
+    }
+
+    sub clear_screen(ubyte color) {
+        stipple(false)
+        if color
+            color=255
+        sys.gfx_clear(color)
+    }
+
+    sub stipple(bool enable) {
+        dont_stipple_flag = not enable
+    }
+
+    sub rect(uword xx, uword yy, uword rwidth, uword rheight, bool draw) {
+        if rwidth==0 or rheight==0
+            return
+        horizontal_line(xx, yy, rwidth, draw)
+        if rheight==1
+            return
+        horizontal_line(xx, yy+rheight-1, rwidth, draw)
+        vertical_line(xx, yy+1, rheight-2, draw)
+        if rwidth==1
+            return
+        vertical_line(xx+rwidth-1, yy+1, rheight-2, draw)
+    }
+
+    sub fillrect(uword xx, uword yy, uword rwidth, uword rheight, bool draw) {
+        ; Draw a filled rectangle of the given size and color.
+        ; To fill the whole screen, use clear_screen(color) instead - it is much faster.
+        if rwidth==0
+            return
+        repeat rheight {
+            horizontal_line(xx, yy, rwidth, draw)
+            yy++
+        }
+    }
+
+    sub horizontal_line(uword xx, uword yy, uword length, bool draw) {
+        ubyte color = 0
+        if draw
+            color = 255
+        uword xpos
+        for xpos in xx to xx+length-1
+            plot(xpos, yy, color)
+    }
+
+    sub safe_horizontal_line(uword xx, uword yy, uword length, bool draw) {
+        ; does bounds checking and clipping
+        if msb(yy)&$80!=0 or yy>=height
+            return
+        if msb(xx)&$80!=0 {
+            length += xx
+            xx = 0
+        }
+        if xx>=width
+            return
+        if xx+length>width
+            length = width-xx
+        if length>width
+            return
+
+        horizontal_line(xx, yy, length, draw)
+    }
+
+    sub vertical_line(uword xx, uword yy, uword lheight, bool draw) {
+        ubyte color = 0
+        if draw
+            color = 255
+        uword ypos
+        for ypos in yy to yy+lheight-1
+            plot(xx, ypos, color)
+    }
+
+    sub line(uword @zp x1, uword @zp y1, uword @zp x2, uword @zp y2, bool draw) {
+        ; Bresenham algorithm.
+        ; This code special-cases various quadrant loops to allow simple ++ and -- operations.
+        if y1>y2 {
+            ; make sure dy is always positive to have only 4 instead of 8 special cases
+            cx16.r0 = x1
+            x1 = x2
+            x2 = cx16.r0
+            cx16.r0 = y1
+            y1 = y2
+            y2 = cx16.r0
+        }
+        word @zp dx = (x2 as word)-x1
+        word @zp dy = (y2 as word)-y1
+
+        if dx==0 {
+            vertical_line(x1, y1, abs(dy) as uword +1, draw)
+            return
+        }
+        if dy==0 {
+            if x1>x2
+                x1=x2
+            horizontal_line(x1, y1, abs(dx) as uword +1, draw)
+            return
+        }
+
+        word @zp d = 0
+        cx16.r1L = true      ; 'positive_ix'
+        if dx < 0 {
+            dx = -dx
+            cx16.r1L = false
+        }
+        word @zp dx2 = dx*2
+        word @zp dy2 = dy*2
+        cx16.r14 = x1       ; internal plot X
+
+        if dx >= dy {
+            if cx16.r1L {
+                repeat {
+                    plot(cx16.r14, y1, draw)
+                    if cx16.r14==x2
+                        return
+                    cx16.r14++
+                    d += dy2
+                    if d > dx {
+                        y1++
+                        d -= dx2
+                    }
+                }
+            } else {
+                repeat {
+                    plot(cx16.r14, y1, draw)
+                    if cx16.r14==x2
+                        return
+                    cx16.r14--
+                    d += dy2
+                    if d > dx {
+                        y1++
+                        d -= dx2
+                    }
+                }
+            }
+        }
+        else {
+            if cx16.r1L {
+                repeat {
+                    plot(cx16.r14, y1, draw)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx2
+                    if d > dy {
+                        cx16.r14++
+                        d -= dy2
+                    }
+                }
+            } else {
+                repeat {
+                    plot(cx16.r14, y1, draw)
+                    if y1 == y2
+                        return
+                    y1++
+                    d += dx2
+                    if d > dy {
+                        cx16.r14--
+                        d -= dy2
+                    }
+                }
+            }
+        }
+    }
+
+    sub circle(uword @zp xcenter, uword @zp ycenter, ubyte radius, bool draw) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
+        ; Midpoint algorithm.
+        if radius==0
+            return
+
+        ubyte @zp xx = radius
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-xx
+        ; R14 = internal plot X
+        ; R15 = internal plot Y
+
+        while xx>=yy {
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter + yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter - yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter + xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter - xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+
+            yy++
+            if decisionOver2>=0 {
+                xx--
+                decisionOver2 -= xx*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+
+        sub plotq() {
+            ; cx16.r14 = x, cx16.r15 = y, draw=draw
+            plot(cx16.r14, cx16.r15, draw)
+        }
+    }
+
+    sub safe_circle(uword @zp xcenter, uword @zp ycenter, ubyte radius, bool draw) {
+        ; Does bounds checking and clipping.
+        ; Midpoint algorithm.
+        if radius==0
+            return
+
+        ubyte @zp xx = radius
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-xx
+        ; R14 = internal plot X
+        ; R15 = internal plot Y
+
+        while xx>=yy {
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter + yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + xx
+            cx16.r15 = ycenter - yy
+            plotq()
+            cx16.r14 = xcenter - xx
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter + xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+            cx16.r14 = xcenter + yy
+            cx16.r15 = ycenter - xx
+            plotq()
+            cx16.r14 = xcenter - yy
+            plotq()
+
+            yy++
+            if decisionOver2>=0 {
+                xx--
+                decisionOver2 -= xx*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+
+        sub plotq() {
+            ; cx16.r14 = x, cx16.r15 = y, draw=draw
+            safe_plot(cx16.r14, cx16.r15, draw)
+        }
+    }
+
+    sub disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, bool draw) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
+        ; Midpoint algorithm, filled
+        if radius==0
+            return
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-radius
+
+        while radius>=yy {
+            horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, draw)
+            horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, draw)
+            horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
+            horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
+            yy++
+            if decisionOver2>=0 {
+                radius--
+                decisionOver2 -= radius*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+    }
+
+    sub safe_disc(uword @zp xcenter, uword @zp ycenter, ubyte @zp radius, bool draw) {
+        ; Warning: NO BOUNDS CHECKS. Make sure circle fits in the screen.
+        ; Midpoint algorithm, filled
+        if radius==0
+            return
+        ubyte @zp yy = 0
+        word @zp decisionOver2 = (1 as word)-radius
+
+        while radius>=yy {
+            safe_horizontal_line(xcenter-radius, ycenter+yy, radius*$0002+1, draw)
+            safe_horizontal_line(xcenter-radius, ycenter-yy, radius*$0002+1, draw)
+            safe_horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
+            safe_horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
+            yy++
+            if decisionOver2>=0 {
+                radius--
+                decisionOver2 -= radius*$0002
+            }
+            decisionOver2 += yy*$0002
+            decisionOver2++
+        }
+    }
+
+    sub plot(uword @zp xx, uword @zp yy, bool @zp draw) {
+        if draw {
+            if dont_stipple_flag
+                sys.gfx_plot(xx, yy, 255)
+            else {
+                if (xx ^ yy)&1
+                    sys.gfx_plot(xx, yy, 255)
+                else
+                    sys.gfx_plot(xx, yy, 0)
+            }
+        }
+        else
+            sys.gfx_plot(xx, yy, 0)
+    }
+
+    sub safe_plot(uword xx, uword yy, bool draw) {
+        ; A plot that does bounds checks to see if the pixel is inside the screen.
+        if msb(xx)&$80!=0 or msb(yy)&$80!=0
+            return
+        if xx >= width or yy >= height
+            return
+        plot(xx, yy, draw)
+    }
+
+    sub pget(uword @zp xx, uword yy) -> ubyte {
+        return sys.gfx_getpixel(xx, yy)
+    }
+
+    sub fill(uword x, uword y, bool draw) {
+        ; 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
+        word @zp xx = x as word
+        word @zp yy = y as word
+        word[MAXDEPTH] @split @shared stack_xl
+        word[MAXDEPTH] @split @shared stack_xr
+        word[MAXDEPTH] @split @shared stack_y
+        byte[MAXDEPTH] @shared stack_dy
+        cx16.r12L = 0       ; stack pointer
+        word x1
+        word x2
+        byte dy
+        cx16.r10L = draw as ubyte
+        sub push_stack(word sxl, word sxr, word sy, byte sdy) {
+            if cx16.r12L==MAXDEPTH
+                return
+            cx16.r0s = sy+sdy
+            if cx16.r0s>=0 and cx16.r0s<=height-1 {
+                stack_xl[cx16.r12L] = sxl
+                stack_xr[cx16.r12L] = sxr
+                stack_y[cx16.r12L] = sy
+                stack_dy[cx16.r12L] = sdy
+                cx16.r12L++
+            }
+        }
+        sub pop_stack() {
+            cx16.r12L--
+            x1 = stack_xl[cx16.r12L]
+            x2 = stack_xr[cx16.r12L]
+            yy = stack_y[cx16.r12L]
+            dy = stack_dy[cx16.r12L]
+            yy+=dy
+        }
+        cx16.r11L = pget(xx as uword, yy as uword)        ; old_color
+        if cx16.r11L == cx16.r10L
+            return
+        if xx<0 or xx>width-1 or yy<0 or yy>height-1
+            return
+        push_stack(xx, xx, yy, 1)
+        push_stack(xx, xx, yy + 1, -1)
+        word left = 0
+        while cx16.r12L {
+            pop_stack()
+            xx = x1
+            while xx >= 0 {
+                if pget(xx as uword, yy as uword) != cx16.r11L
+                    break
+                xx--
+            }
+            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.r9 = xx
+                while xx <= width-1 {
+                    if pget(xx as uword, yy as uword) != cx16.r11L
+                        break
+                    xx++
+                }
+                if cx16.r9!=xx
+                    horizontal_line(cx16.r9, yy as uword, (xx as uword)-cx16.r9, cx16.r10L)
+
+                push_stack(left, xx - 1, yy, dy)
+                if xx > x2 + 1
+                    push_stack(x2 + 1, xx - 1, yy, -dy)
+skip:
+                xx++
+                while xx <= x2 {
+                    if pget(xx as uword, yy as uword) == cx16.r11L
+                        break
+                    xx++
+                }
+                left = xx
+            } until xx>x2
+        }
+    }
+
+    sub text_charset(ubyte charset) {
+        ; -- select the text charset to use with the text() routine
+        ;    the charset number is the same as for the cx16.screen_set_charset() ROM function.
+        ;    1 = ISO charset, 2 = PETSCII uppercase+graphs, 3= PETSCII uppercase+lowercase.
+        ; TODO vm has no bitmap charset
+    }
+
+    sub text(uword @zp xx, uword yy, bool draw, uword sctextptr) {
+        ; -- Write some text at the given pixel position. The text string must be in screencode encoding (not petscii!).
+        ;    You must also have called text_charset() first to select and prepare the character set to use.
+        ; TODO vm has no bitmap charset
+    }
+}

compiler/res/prog8lib/virtual/string.p8

@@ -78,6 +78,13 @@ string {
         }
     }
 
+    sub append(str target, str suffix) -> ubyte {
+        ; Append the suffix string to the target. (make sure the buffer is large enough!)
+        ; Returns the length of the resulting string.
+        cx16.r0L = length(target)
+        return copy(suffix, target+cx16.r0L) + cx16.r0L
+    }
+
     sub compare(str st1, str st2) -> byte {
         ; Compares two strings for sorting.
         ; Returns -1 (255), 0 or 1 depending on wether string1 sorts before, equal or after string2.
@@ -150,4 +157,37 @@ string {
             return false
         return compare(st + str_len - suffix_len, suffix) == 0
     }
-}
+
+    sub hash(str st) -> ubyte {
+        ; experimental 8 bit hashing function.
+        ; hash(-1)=179;  hash(i) = ROL hash(i-1)  XOR  string[i]
+        ; (experimental because the quality of the resulting hash value still has to be determined)
+        ubyte hashcode = 179
+        ubyte ix
+        sys.clear_carry()
+        repeat {
+            if st[ix] {
+                rol(hashcode)
+                hashcode ^= st[ix]
+                ix++
+            } else
+                return hashcode
+        }
+    }
+
+    sub isdigit(ubyte character) -> bool {
+        return character>='0' and character<='9'
+    }
+
+    sub isupper(ubyte character) -> bool {
+        return character>='A' and character<='Z'
+    }
+
+    sub islower(ubyte character) -> bool {
+        return character>='a' and character<='z'
+    }
+
+    sub isletter(ubyte character) -> bool {
+        return islower(character) or isupper(character)
+    }
+ }

compiler/res/prog8lib/virtual/syslib.p8

@@ -79,6 +79,21 @@ sys {
         }}
     }
 
+    sub disable_caseswitch() {
+        ; no-op
+    }
+
+    sub enable_caseswitch() {
+        ; no-op
+    }
+
+    sub save_prog8_internals() {
+        ; no-op
+    }
+
+    sub restore_prog8_internals() {
+        ; no-op
+    }
 
     sub gfx_enable(ubyte mode) {
         %ir {{

compiler/src/prog8/CompilerMain.kt

@@ -42,13 +42,14 @@ private fun compileMain(args: Array<String>): Boolean {
     val startEmulator2 by cli.option(ArgType.Boolean, fullName = "emu2", description = "auto-start alternative emulator after successful compilation")
     val experimentalCodegen by cli.option(ArgType.Boolean, fullName = "expericodegen", description = "use experimental/alternative codegen")
     val dontWriteAssembly by cli.option(ArgType.Boolean, fullName = "noasm", description="don't create assembly code")
-    val dontOptimize by cli.option(ArgType.Boolean, fullName = "noopt", description = "don't perform any optimizations")
+    val dontOptimize by cli.option(ArgType.Boolean, fullName = "noopt", description = "don't perform code optimizations")
     val outputDir by cli.option(ArgType.String, fullName = "out", description = "directory for output files instead of current directory").default(".")
     val quietAssembler by cli.option(ArgType.Boolean, fullName = "quietasm", description = "don't print assembler output results")
     val warnSymbolShadowing by cli.option(ArgType.Boolean, fullName = "warnshadow", description="show assembler warnings about symbol shadowing")
     val sourceDirs by cli.option(ArgType.String, fullName="srcdirs", description = "list of extra paths, separated with ${File.pathSeparator}, to search in for imported modules").multiple().delimiter(File.pathSeparator)
     val includeSourcelines by cli.option(ArgType.Boolean, fullName = "sourcelines", description = "include original Prog8 source lines in generated asm code")
     val splitWordArrays by cli.option(ArgType.Boolean, fullName = "splitarrays", description = "treat all word arrays as tagged with @split to make them lsb/msb split in memory")
+    val breakpointCpuInstruction by cli.option(ArgType.Boolean, fullName = "breakinstr", description = "also use a CPU instruction for %breakpoint")
     val compilationTarget by cli.option(ArgType.String, fullName = "target", description = "target output of the compiler (one of '${C64Target.NAME}', '${C128Target.NAME}', '${Cx16Target.NAME}', '${AtariTarget.NAME}', '${PETTarget.NAME}', '${VMTarget.NAME}') (required)")
     val startVm by cli.option(ArgType.Boolean, fullName = "vm", description = "load and run a .p8ir IR source file in the VM")
     val watchMode by cli.option(ArgType.Boolean, fullName = "watch", description = "continuous compilation mode (watch for file changes)")
@@ -122,6 +123,7 @@ private fun compileMain(args: Array<String>): Boolean {
                     varsHighBank,
                     compilationTarget!!,
                     splitWordArrays == true,
+                    breakpointCpuInstruction = false,
                     processedSymbols,
                     srcdirs,
                     outputPath
@@ -190,6 +192,7 @@ private fun compileMain(args: Array<String>): Boolean {
                     varsHighBank,
                     compilationTarget!!,
                     splitWordArrays == true,
+                    breakpointCpuInstruction == true,
                     processedSymbols,
                     srcdirs,
                     outputPath

compiler/src/prog8/buildversion/BuildVersion.kt

@@ -5,11 +5,11 @@ package prog8.buildversion
  */
 const val MAVEN_GROUP = "prog8"
 const val MAVEN_NAME = "compiler"
-const val VERSION = "9.3-SNAPSHOT"
-const val GIT_REVISION = 4012
-const val GIT_SHA = "9167ba499de99696aa7c6887d4867eae70eb5caf"
-const val GIT_DATE = "2023-07-30T15:49:35Z"
+const val VERSION = "9.7"
+const val GIT_REVISION = 4286
+const val GIT_SHA = "cfc9c15f1e9fe96940e170fb14ad3a957109977c"
+const val GIT_DATE = "2023-12-10T15:22:00Z"
 const val GIT_BRANCH = "master"
-const val BUILD_DATE = "2023-07-30T16:41:27Z"
-const val BUILD_UNIX_TIME = 1690735287514L
+const val BUILD_DATE = "2023-12-10T15:44:19Z"
+const val BUILD_UNIX_TIME = 1702223059842L
 const val DIRTY = 1