fix chained assignment and multi-vardecl RHS evaluation

fix void optimization issue
version 9.7
2026-10-22 05:02:58 +00:00 · 2023-12-10 16:44:51 +01:00 · 2023-12-09 21:48:22 +01:00 · 2023-12-09 18:54:54 +01:00 · 2023-12-09 14:07:42 +01:00 · 2023-12-09 13:13:34 +01:00
194 changed files with 6648 additions and 2562 deletions
@@ -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>
@@ -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>
@@ -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>
@@ -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!/" />
@@ -120,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),
@@ -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)
+    }
 }
@@ -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 {
@@ -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
@@ -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
 }
@@ -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 {
@@ -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
        }
    }
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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)
@@ -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 {
@@ -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 {
@@ -48,6 +48,7 @@ class AtariZeropage(options: CompilationOptions) : Zeropage(options) {
        free.addAll(distinctFree)

        removeReservedFromFreePool()
+        retainAllowed()
    }

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

        removeReservedFromFreePool()
+        retainAllowed()
    }

    override fun allocateCx16VirtualRegisters() {
@@ -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() {
@@ -47,8 +47,8 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
            free.addAll(distinctFree)

            removeReservedFromFreePool()
-
            allocateCx16VirtualRegisters()
+            retainAllowed()
        }
    }

@@ -50,6 +50,7 @@ class PETZeropage(options: CompilationOptions) : Zeropage(options) {
        free.addAll(distinctFree)

        removeReservedFromFreePool()
+        retainAllowed()
    }

    override fun allocateCx16VirtualRegisters() {
@@ -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(", ")
    }
@@ -30,7 +30,7 @@ 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 {
@@ -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) {
@@ -3075,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""")
+    }
 }

 /**
@@ -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) }
-}
@@ -47,9 +47,20 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
            "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])
@@ -72,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")
@@ -110,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) {
@@ -131,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() {
@@ -173,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")

@@ -187,6 +207,9 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
 +           .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) {
@@ -273,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")
@@ -686,7 +709,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
            assignAsmGen.assignConstantByte(target, 0)
        } else {
            asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A, false)
-            assignAsmGen.assignRegisterByte(target, CpuRegister.A, false)
+            assignAsmGen.assignRegisterByte(target, CpuRegister.A, false, false)
        }
    }

@@ -701,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?) {
@@ -714,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?) {
@@ -723,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")
@@ -743,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 -> {
@@ -799,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)
@@ -871,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
@@ -887,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")
        }
    }

@@ -1111,7 +1182,25 @@ 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(arg, RegisterOrPair.AY)
                    // NOTE: we rely on the fact that the above assignment to AY, assigns the Lsb to A as the last instruction.
@@ -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")
@@ -156,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
@@ -188,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)
        }
    }

@@ -209,3 +233,5 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
        return false
    }
 }
+
+
@@ -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}")
+            }
        }
    }

@@ -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) {
@@ -205,239 +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 -> {
-                                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}")
                        }
+
+                        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")
-                                }
-                                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")
-                                            inplacemodificationWordWithLiteralval("P8ZP_SCRATCH_W1", target.datatype, operator, number, block)
-                                            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, 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 -> {
+                            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!!, 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")
-                                    }
-                                }
-                                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")
@@ -445,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) {
@@ -495,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) {
@@ -544,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
        }
    }

@@ -918,8 +994,9 @@ internal class AugmentableAssignmentAsmGen(private val program: PtProgram,
            "<<" -> {
                asmgen.out("""
                    tay
-                    beq  +
                    lda  $variable
+                    cpy  #0
+                    beq  +
 -                   asl  a
                    dey
                    bne  -
@@ -929,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  -
@@ -938,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
@@ -1113,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("""
@@ -1235,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) {
            "+" -> {
@@ -1532,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
@@ -1545,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")
                }
            }
@@ -1899,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  -
 +""")
                    }
                    ">>" -> {
@@ -2649,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)
@@ -2674,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)
@@ -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()
    }
@@ -22,6 +22,7 @@ class TestCodegen: FunSpec({
            CbmPrgLauncherType.NONE,
            ZeropageType.DONTUSE,
            zpReserved = emptyList(),
+            zpAllowed = CompilationOptions.AllZeropageAllowed,
            floats = true,
            noSysInit = false,
            compTarget = target,
@@ -30,7 +30,7 @@ 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 {
@@ -29,11 +29,13 @@ 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)
@@ -349,13 +351,18 @@ 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)
    }
@@ -435,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)
@@ -17,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) {
@@ -31,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 {
@@ -188,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)
@@ -711,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 {
@@ -767,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 {
@@ -821,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)
@@ -876,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)
@@ -948,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)
@@ -997,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)
@@ -1322,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)
@@ -1333,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)
@@ -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> {
@@ -470,7 +465,6 @@ 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.CMPI, IRDataType.BYTE, reg1 = tmpReg, immediate = 0)
                            it += IRInstruction(Opcode.BSTEQ, labelSymbol = endLabel)
                            it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = tmpReg, labelSymbol = loopvarSymbol)
                        }
@@ -491,15 +485,18 @@ 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.CMPI, IRDataType.BYTE, reg1=indexReg, immediate = if(iterableLength==256) 0 else iterableLength)
+                            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)
                        }
                    }
@@ -516,7 +513,10 @@ class IRCodeGen(
                        result += translateNode(forLoop.statements)
                        result += addConstReg(IRDataType.BYTE, indexReg, elementSize)
                        result += IRCodeChunk(null, null).also {
-                            it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=indexReg, immediate = if(lengthBytes==256) 0 else lengthBytes)
+                            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)
                        }
                    }
@@ -705,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
@@ -802,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
@@ -976,7 +976,6 @@ class IRCodeGen(
                        fpReg2 = rightTr.resultFpReg
                    )
                    when(condition.operator) {
-                        // TODO: the converted list of operators
                        "==" -> {
                            it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1 = compResultReg, immediate = 0)
                            it += branchInstr(goto, Opcode.BSTEQ)
@@ -986,7 +985,6 @@ class IRCodeGen(
                            it += branchInstr(goto, Opcode.BSTNE)
                        }
                        else -> {
-                            // TODO: the old list of operators, still to be converted
                            val gotoOpcode = when (condition.operator) {
                                "<" -> Opcode.BLTS
                                ">" -> Opcode.BGTS
@@ -1016,7 +1014,6 @@ class IRCodeGen(
        }
    }

-    // TODO use this everywhere
    private fun branchInstr(goto: PtJump, branchOpcode: Opcode) = if (goto.address != null)
        IRInstruction(branchOpcode, address = goto.address?.toInt())
    else if (goto.generatedLabel != null)
@@ -1034,18 +1031,19 @@ class IRCodeGen(
        val condition = ifElse.condition as PtBinaryExpression
        val leftTr = expressionEval.translateExpression(condition.left)
        addToResult(result, leftTr, leftTr.resultReg, -1)
+        val requireCompareZero = leftTr.lastInstruction().opcode !in OpcodesThatSetStatusbits
        when(condition.operator) {
-            // TODO: converted list of operators
            "==" -> {
-                addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = leftTr.resultReg, immediate = 0), null)
+                if(requireCompareZero)
+                    addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = leftTr.resultReg, immediate = 0), null)
                addInstr(result, branchInstr(goto, Opcode.BSTEQ), null)
            }
            "!=" -> {
-                addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = leftTr.resultReg, immediate = 0), null)
+                if(requireCompareZero)
+                    addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = leftTr.resultReg, immediate = 0), null)
                addInstr(result, branchInstr(goto, Opcode.BSTNE), null)
            }
            else -> {
-                // TODO: to-be converted operators
                val opcode = when (condition.operator) {
                    "<" -> if (signed) Opcode.BLTS else Opcode.BLT
                    ">" -> if (signed) Opcode.BGTS else Opcode.BGT
@@ -1072,12 +1070,13 @@ class IRCodeGen(
    ) {
        val condition = ifElse.condition as? PtBinaryExpression
        if(condition==null) {
-            val tr = expressionEval.translateExpression(ifElse.condition)
-            result += tr.chunks
-            result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.CMPI, irDtLeft, reg1 = tr.resultReg, immediate = 0)
-                it += branchInstr(goto, Opcode.BSTNE)
-            }
+            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)
@@ -1085,7 +1084,6 @@ class IRCodeGen(
            if(number!=null) {
                val firstReg = leftTr.resultReg
                when(condition.operator) {
-                    // TODO: the converted operators
                    "==" -> {
                        addInstr(result, IRInstruction(Opcode.CMPI, irDtLeft, reg1 = firstReg, immediate = number), null)
                        addInstr(result, branchInstr(goto, Opcode.BSTEQ), null)
@@ -1095,7 +1093,6 @@ class IRCodeGen(
                        addInstr(result, branchInstr(goto, Opcode.BSTNE), null)
                    }
                    else -> {
-                        // TODO: to-be converted operators
                        val opcode = when (condition.operator) {
                            "<" -> if(signed) Opcode.BLTS else Opcode.BLT
                            ">" -> if(signed) Opcode.BGTS else Opcode.BGT
@@ -1187,7 +1184,7 @@ 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)
            }
            when (condition.operator) {
@@ -1267,33 +1264,6 @@ class IRCodeGen(
        val condition = ifElse.condition as? PtBinaryExpression
        if(condition==null) {
            throw AssemblyError("if-else condition is not a binaryexpression, should have been converted?")
-//            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()
-//                result += IRCodeChunk(null, null).also {
-//                    it += IRInstruction(Opcode.CMPI, irDtLeft, reg1=tr.resultReg, immediate = 0)
-//                    it += IRInstruction(Opcode.BSTEQ, labelSymbol = elseLabel)
-//                    TODO("test this")
-//                }
-//                result += translateNode(ifElse.ifScope)
-//                val afterIfLabel = createLabelName()
-//                addInstr(result, IRInstruction(Opcode.JUMP, labelSymbol = afterIfLabel), null)
-//                result += labelFirstChunk(translateNode(ifElse.elseScope), elseLabel)
-//                result += IRCodeChunk(afterIfLabel, null)
-//            } else {
-//                val afterIfLabel = createLabelName()
-//                result += IRCodeChunk(null, null).also {
-//                    it += IRInstruction(Opcode.CMPI, irDtLeft, reg1=tr.resultReg, immediate = 0)
-//                    it += IRInstruction(Opcode.BSTEQ, labelSymbol = afterIfLabel)
-//                    TODO("test this")
-//                }
-//                result += translateNode(ifElse.ifScope)
-//                result += IRCodeChunk(afterIfLabel, null)
-//            }
-//            return result
        } else {
            if (irDtLeft == IRDataType.FLOAT) {
                val leftTr = expressionEval.translateExpression(condition.left)
@@ -1641,10 +1611,7 @@ class IRCodeGen(
        addToResult(result, countTr, countTr.resultReg, -1)
        if(constIntValue(repeat.count)==null) {
            // check if the counter is already zero
-            result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.CMPI, irDt, reg1=countTr.resultReg, immediate = 0)
-                it += IRInstruction(Opcode.BSTEQ, labelSymbol = skipRepeatLabel)
-            }
+            addInstr(result, IRInstruction(Opcode.BSTEQ, labelSymbol = skipRepeatLabel), null)
        }
        result += labelFirstChunk(translateNode(repeat.statements), repeatLabel)
        result += IRCodeChunk(null, null).also {
@@ -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
+*/
    }
 }
@@ -37,9 +37,9 @@ class IRUnusedCodeRemover(
                }
            }

-            irprog.st.allVariables().forEach { stVar->
-                val initValue = stVar.onetimeInitializationArrayValue
-                if(initValue!=null && !initValue.isEmpty()) {
+            irprog.st.allVariables().forEach { variable ->
+                val initValue = variable.onetimeInitializationArrayValue
+                if(!initValue.isNullOrEmpty()) {
                    if(initValue.any {
                        it.addressOfSymbol?.startsWith(blockLabel)==true
                    })
@@ -61,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++
@@ -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()
    }
@@ -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
@@ -19,6 +19,7 @@ class TestVmCodeGen: FunSpec({
            CbmPrgLauncherType.NONE,
            ZeropageType.DONTUSE,
            zpReserved = emptyList(),
+            zpAllowed = CompilationOptions.AllZeropageAllowed,
            floats = true,
            noSysInit = false,
            compTarget = target,
@@ -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
@@ -87,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) {
@@ -184,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))
+                        }
                    }
                }
            }
@@ -195,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))
@@ -386,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
@@ -526,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
@@ -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) {
@@ -291,8 +301,11 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
    }

    private fun createConstArrayInitializerValue(decl: VarDecl): ArrayLiteral? {
-        // convert the initializer range expression from a range or int, to an actual array.

+        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
@@ -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")
@@ -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
    }

@@ -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)
                                }
@@ -40,7 +40,7 @@ dependencies {
    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 {
@@ -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
@@ -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 {
@@ -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 {{
@@ -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
+    }}
+}
 }
@@ -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"
@@ -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++
        }
    }

@@ -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 {{
@@ -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
+    }}
+}
 }
@@ -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
+    }
+}
@@ -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
@@ -11,11 +21,7 @@ diskio {
    const ubyte READ_IO_CHANNEL=12
    const ubyte WRITE_IO_CHANNEL=13

-    ubyte drivenumber = 8
-
-    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)
@@ -87,7 +93,7 @@ io_error:
    sub diskname() -> uword {
        ; returns disk label name or 0 if error
        cbm.SETNAM(3, "$")
-        cbm.SETLFS(READ_IO_CHANNEL, diskio.drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
        ubyte status = 1
        void cbm.OPEN()          ; open 12,8,0,"$=c"
        if_cs
@@ -100,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--
                }
@@ -120,7 +126,7 @@ io_error:
        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
@@ -135,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" {
@@ -270,9 +277,13 @@ close_end:

    ; ----- 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)
@@ -308,13 +319,12 @@ close_end:
        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
            list_blocks += readsize
@@ -412,15 +422,35 @@ _end        rts

    ; ----- iterative file writing functions (uses write io channel) -----

-    sub f_open_w(uword filenameptr) -> bool {
-        ; -- open a file for iterative writing with f_write
-        f_close_w()
+    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)
+    }

-        cbm.SETNAM(string.length(filenameptr), filenameptr)
-        cbm.SETLFS(WRITE_IO_CHANNEL, drivenumber, 1)
-        void cbm.OPEN()             ; open 13,8,1,"filename"
-        if_cc
+    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()
+        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 {
            return not cbm.READST()
+        }
        f_close_w()
        return false
    }
@@ -429,6 +459,21 @@ _end        rts
        ; -- write the given number of bytes to the currently open file
        if num_bytes!=0 {
            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++
@@ -516,9 +561,6 @@ io_error:
        if_cc
            cx16.r0L = cbm.READST()==0

-        cbm.CLRCHN()
-        cbm.CLOSE(1)
-
        return cx16.r0L
    }

@@ -567,8 +609,6 @@ io_error:
 +
        }}

-        cbm.CLRCHN()
-        cbm.CLOSE(1)
        return cx16.r1
    }

@@ -703,7 +743,7 @@ internal_vload:
        cx16.r12 = reversebuffer + MAX_PATH_LEN-1
        @(cx16.r12)=0
        cbm.SETNAM(3, "$=c")
-        cbm.SETLFS(READ_IO_CHANNEL, diskio.drivenumber, 0)
+        cbm.SETLFS(READ_IO_CHANNEL, drivenumber, 0)
        void cbm.OPEN()          ; open 12,8,0,"$=c"
        if_cs
            goto io_error
@@ -777,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] = READ_IO_CHANNEL       ; f_open uses the read io channel
+        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)
@@ -791,15 +831,18 @@ io_error:
    }


-    ; 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] = WRITE_IO_CHANNEL       ; f_open_w uses the write io channel
-;        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
+    }

 }
@@ -1,5 +1,5 @@
 ; Emulator debug interface.
-; Docs: https://github.com/X16Community/x16-emulator#debug-io-registers
+; Docs: https://github.com/X16Community/x16-emulator#emulator-io-registers

 emudbg {

@@ -23,36 +23,38 @@ emudbg {
    &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'
    }

-    asmsub console_write(str isoString @R0) clobbers(Y) {
-        %asm {{
-            ldy  #0
-           lda  (cx16.r0),y
-            beq  +
-            sta  p8_EMU_CPUCLK_U
-            iny
-            bne  -
-+
-        }}
+    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++
+            }
+        }
    }

-    asmsub console_chrout(ubyte char @A) {
-        %asm {{
-            sta  p8_EMU_CPUCLK_U
-        }}
+    sub console_chrout(ubyte char) {
+        ; note: make sure the character is in Iso encoding.
+        if is_emulator()
+            EMU_CPUCLK_U = char
    }

-    asmsub console_value1(ubyte value @A) {
-        %asm {{
-            sta  p8_EMU_CPUCLK_M
-        }}
+    sub console_value1(ubyte value) {
+        if is_emulator()
+            EMU_CPUCLK_M = value
    }

-    asmsub console_value2(ubyte value @A) {
-        %asm {{
-            sta  p8_EMU_CPUCLK_H
-        }}
+    sub console_value2(ubyte value) {
+        if is_emulator()
+            EMU_CPUCLK_H = value
    }
 }
@@ -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"

@@ -10,14 +10,17 @@
 ;       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 x 256c (8 bpp)
-;   mode 2 = bitmap 640 x 480 x 4c (2 bpp. there's not enough vram for more colors in hires mode.)
-;   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 4c (not yet implemented: just use 256c, there's enough vram for that)
-;   higher color dephts in highres are not supported due to lack of VRAM
+;   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 {

@@ -40,9 +43,6 @@ gfx2 {
                cx16.VERA_L1_CONFIG = %00000111
                cx16.VERA_L1_MAPBASE = 0
                cx16.VERA_L1_TILEBASE = 0
-                width = 320
-                height = 240
-                bpp = 8
            }
            2 -> {
                ; highres 4c
@@ -52,27 +52,44 @@ 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
-                width = 0
-                height = 0
-                bpp = 0
-                mode = 0
            }
        }

-        active_mode = mode
-        if bpp
+        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
+                active_mode = 0
+            }
+        }
+    }
+
    sub clear_screen(ubyte color) {
        position(0, 0)
        when active_mode {
@@ -189,6 +206,24 @@ gfx2 {
        }
    }

+    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 -> {
@@ -336,6 +371,7 @@ gfx2 {
    }

    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
@@ -349,36 +385,91 @@ gfx2 {
        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
@@ -391,12 +482,35 @@ gfx2 {
            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++
        }
    }

@@ -453,6 +567,15 @@ gfx2 {
        }
    }

+    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 -> {
@@ -481,21 +604,32 @@ gfx2 {
                    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
@@ -574,11 +708,15 @@ gfx2 {
        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
@@ -587,17 +725,26 @@ gfx2 {
            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
        }
@@ -789,6 +936,8 @@ skip:
    }

    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
 -           sta  cx16.VERA_DATA0
@@ -7,11 +7,17 @@
 ; 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" 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++
        }
    }

@@ -5,6 +5,9 @@
 ; 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 {

@@ -229,6 +232,24 @@ _done
        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 {
@@ -385,6 +406,7 @@ _done
    }

    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
@@ -398,36 +420,91 @@ _done
        while xx>=yy {
            cx16.r14 = xcenter + xx
            cx16.r15 = ycenter + yy
-            plot(cx16.r14, cx16.r15, draw)
+            plotq()
            cx16.r14 = xcenter - xx
-            plot(cx16.r14, cx16.r15, draw)
+            plotq()
            cx16.r14 = xcenter + xx
            cx16.r15 = ycenter - yy
-            plot(cx16.r14, cx16.r15, draw)
+            plotq()
            cx16.r14 = xcenter - xx
-            plot(cx16.r14, cx16.r15, draw)
+            plotq()
            cx16.r14 = xcenter + yy
            cx16.r15 = ycenter + xx
-            plot(cx16.r14, cx16.r15, draw)
+            plotq()
            cx16.r14 = xcenter - yy
-            plot(cx16.r14, cx16.r15, draw)
+            plotq()
            cx16.r14 = xcenter + yy
            cx16.r15 = ycenter - xx
-            plot(cx16.r14, cx16.r15, draw)
+            plotq()
            cx16.r14 = xcenter - yy
-            plot(cx16.r14, cx16.r15, draw)
+            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, 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
@@ -440,12 +517,35 @@ _done
            horizontal_line(xcenter-yy, ycenter+radius, yy*$0002+1, draw)
            horizontal_line(xcenter-yy, ycenter-radius, yy*$0002+1, draw)
            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, 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++
        }
    }

@@ -497,6 +597,15 @@ _done
        }
    }

+    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
@@ -525,11 +634,13 @@ _done
        }}
    }

-    sub fill(word @zp xx, word @zp yy, bool draw) {
+    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 = 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
@@ -608,11 +719,14 @@ _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)
+            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
@@ -621,17 +735,25 @@ _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
+                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
        }
@@ -768,6 +890,8 @@ skip:
    }

    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  +
@@ -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))
    }
-
 }
@@ -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
@@ -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)
    }
 }
@@ -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
@@ -268,14 +272,29 @@ cx16 {
    &ubyte  VERA_SPI_DATA       = VERA_BASE + $001E
    &ubyte  VERA_SPI_CTRL       = VERA_BASE + $001F

-    ; experimental Vera FX registers: (depends on particular value set in VERA_CTRL!!!)
+    ; Vera FX registers: (accessing depends on particular DCSEL value set in VERA_CTRL!)
    &ubyte VERA_FX_CTRL         = VERA_BASE + $0009
-    &ubyte VERA_FX_MULT         = VERA_BASE + $000C
+    &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_RESET  = VERA_BASE + $0009     ; (DCSEL=6)
+    &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
@@ -364,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)
@@ -397,8 +415,8 @@ romsub $fecc = monitor()  clobbers(A,X,Y)
 romsub $ff44 = MACPTR(ubyte length @A, uword buffer @XY, bool dontAdvance @Pc)  clobbers(A) -> bool @Pc, uword @XY
 romsub $feb1 = MCIOUT(ubyte length @A, uword buffer @XY, bool dontAdvance @Pc)  clobbers(A) -> bool @Pc, uword @XY
 romsub $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!
@@ -407,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)
@@ -450,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
@@ -526,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
            }}
 }
@@ -569,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
@@ -582,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
    }}
 }
@@ -832,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 --------

@@ -873,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
@@ -911,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) {
@@ -994,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
@@ -1004,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
@@ -1025,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
@@ -1041,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
    }}
 }
@@ -1250,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
@@ -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
+    }}
+}
 }
@@ -39,19 +39,19 @@ verafx {

        if (amountof32bits & %1111110000000011) == 0 {
            repeat lsb(amountof32bits >> 2)
-                unroll 4 cx16.VERA_DATA0=0       ; write 4 bytes at a time, unrolled
+                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 4 bytes at a time, unrolled
+                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 bytes at a time, unrolled
+                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 4 bytes at a time, unrolled
+                unroll 2 cx16.VERA_DATA0=0       ; write 2*4 bytes at a time, unrolled
        }
        else {
            repeat amountof32bits
@@ -65,10 +65,16 @@ verafx {
    ; unsigned multiplication just passes the values as signed to muls
    ; if you do this yourself in your call to muls, it will save a few instructions.
    sub mult(uword value1, uword value2) -> uword {
+        ; Returns the lower 16 bits of the 32 bits result,
+        ; the upper 16 bits are stored in cx16.r0 so you can access those separately.
+        ; It's not part of the subroutine's signature to avoid awkward use of multiple returnvalues.
        return muls(value1 as word, value2 as word) as uword
    }

-    asmsub muls(word value1 @R0, word value2 @R1) -> word @AY {
+    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
@@ -104,14 +110,13 @@ verafx {
            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
-; we skip the upper 16 bits of the result:
-;            lda  cx16.VERA_DATA0
-;            sta  $0402
-;            lda  cx16.VERA_DATA0
-;            sta  $0403
        }}
    }

@@ -10,11 +10,7 @@ diskio {
    const ubyte READ_IO_CHANNEL=12
    const ubyte WRITE_IO_CHANNEL=13

-    ubyte drivenumber = 8
-
-    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)
@@ -107,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--
                }
@@ -137,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.
@@ -275,6 +271,10 @@ close_end:
    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)
@@ -390,6 +390,11 @@ _end        rts

    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)
@@ -476,9 +481,6 @@ io_error:
        if_cc
            cx16.r0L = cbm.READST()==0

-        cbm.CLRCHN()
-        cbm.CLOSE(1)
-
        return cx16.r0L
    }

@@ -506,8 +508,6 @@ io_error:
 +
        }}

-        cbm.CLRCHN()
-        cbm.CLOSE(1)
        return cx16.r1
    }

@@ -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
@@ -74,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
@@ -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
@@ -445,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
+        }}
+    }
+
 }
@@ -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 {{
@@ -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
+    }}
+}
 }
@@ -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
@@ -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
+        }}
+    }
 }
@@ -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")
+    }
+}
@@ -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
+}
+
 }
@@ -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 {

@@ -277,4 +279,17 @@ math {
            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
+    }
+
 }
@@ -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
+    }
+}
@@ -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)
+    }
+ }
@@ -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 {{
@@ -49,6 +49,7 @@ private fun compileMain(args: Array<String>): Boolean {
    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
@@ -5,11 +5,11 @@ package prog8.buildversion
 */
 const val MAVEN_GROUP = "prog8"
 const val MAVEN_NAME = "compiler"
-const val VERSION = "9.5-SNAPSHOT"
-const val GIT_REVISION = 4108
-const val GIT_SHA = "c319233ddc7f43a05e2090e293abbed8d80ce8cf"
-const val GIT_DATE = "2023-09-18T21:22:03Z"
+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-09-18T21:27:55Z"
-const val BUILD_UNIX_TIME = 1695072475414L
+const val BUILD_DATE = "2023-12-10T15:44:19Z"
+const val BUILD_UNIX_TIME = 1702223059842L
 const val DIRTY = 1
@@ -105,20 +105,23 @@ private fun builtinAbs(args: List<Expression>, position: Position, program: Prog
 }

 private fun builtinSizeof(args: List<Expression>, position: Position, program: Program): NumericLiteral {
-    // 1 arg, type = anything, result type = ubyte
+    // 1 arg, type = anything, result type = ubyte or uword
    if(args.size!=1)
        throw SyntaxError("sizeof requires one argument", position)
-    if(args[0] !is IdentifierReference)
-        throw SyntaxError("sizeof argument should be an identifier", position)
+    if(args[0] !is IdentifierReference && args[0] !is NumericLiteral)
+        throw SyntaxError("sizeof argument should be an identifier or number", position)

    val dt = args[0].inferType(program)
    if(dt.isKnown) {
+        if(args[0] is NumericLiteral)
+            return NumericLiteral.optimalInteger(program.memsizer.memorySize(dt.getOr(DataType.UNDEFINED)), position)
+
        val target = (args[0] as IdentifierReference).targetStatement(program)
            ?: throw CannotEvaluateException("sizeof", "no target")

        return when {
            dt.isArray -> {
-                val length = (target as VarDecl).arraysize!!.constIndex() ?: throw CannotEvaluateException("sizeof", "unknown array size")
+                val length = (target as VarDecl).arraysize?.constIndex() ?: throw CannotEvaluateException("sizeof", "unknown array size")
                val elementDt = ArrayToElementTypes.getValue(dt.getOr(DataType.UNDEFINED))
                NumericLiteral.optimalInteger(program.memsizer.memorySize(elementDt) * length, position)
            }
@@ -38,6 +38,7 @@ class CompilerArguments(val filepath: Path,
                        val varsHighBank: Int?,
                        val compilationTarget: String,
                        val splitWordArrays: Boolean,
+                        val breakpointCpuInstruction: Boolean,
                        val symbolDefs: Map<String, String>,
                        val sourceDirs: List<String> = emptyList(),
                        val outputDir: Path = Path(""),
@@ -74,6 +75,7 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
                asmListfile = args.asmListfile
                includeSourcelines = args.includeSourcelines
                experimentalCodegen = args.experimentalCodegen
+                breakpointCpuInstruction = args.breakpointCpuInstruction
                varsHighBank = args.varsHighBank
                splitWordArrays = args.splitWordArrays
                outputDir = args.outputDir.normalize()
@@ -105,6 +107,7 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {

            if (args.writeAssembly) {

+                // re-initialize memory areas with final compilationOptions
                compilationOptions.compTarget.machine.initializeMemoryAreas(compilationOptions)
                program.processAstBeforeAsmGeneration(compilationOptions, args.errors)
                args.errors.report()
@@ -299,6 +302,14 @@ fun determineCompilationOptions(program: Program, compTarget: ICompilationTarget
        .map { it[0].int!!..it[1].int!! }
        .toList()

+    val zpAllowed = toplevelModule.statements
+        .asSequence()
+        .filter { it is Directive && it.directive == "%zpallowed" }
+        .map { (it as Directive).args }
+        .filter { it.size==2 && it[0].int!=null && it[1].int!=null }
+        .map { it[0].int!!..it[1].int!! }
+        .toList()
+
    val outputType = if (outputTypeStr == null) {
        if(compTarget is AtariTarget)
            OutputType.XEX
@@ -328,7 +339,7 @@ fun determineCompilationOptions(program: Program, compTarget: ICompilationTarget

    return CompilationOptions(
        outputType, launcherType,
-        zpType, zpReserved, floatsEnabled, noSysInit,
+        zpType, zpReserved, zpAllowed, floatsEnabled, noSysInit,
        compTarget, 0u
    )
 }
@@ -110,14 +110,18 @@ class ModuleImporter(private val program: Program,
        // their content has to be merged into already existing other block with the same name.
        val blocks = importedModule.statements.filterIsInstance<Block>()
        for(block in blocks) {
-            if("merge" in block.options()) {
-                val existingBlock = program.allBlocks.firstOrNull { it.name==block.name && it !== block}
-                if(existingBlock!=null) {
+            val blockHasMergeOption = "merge" in block.options()
+            val existingBlock = program.allBlocks.firstOrNull { it.name==block.name && it !== block}
+            if(existingBlock!=null) {
+                val existingBlockHasMergeOption = "merge" in existingBlock.options()
+                if (blockHasMergeOption || existingBlockHasMergeOption) {
+                    // transplant the contents
                    existingBlock.statements.addAll(block.statements.filter { it !is Directive })
                    importedModule.statements.remove(block)
-                } else {
-                    val merges = block.statements.filter { it is Directive && it.directive=="%option" && it.args.any { a->a.name=="merge" } }
-                    block.statements.removeAll(merges.toSet())
+
+                    if(blockHasMergeOption && !existingBlockHasMergeOption) {
+                        existingBlock.statements.add(0, Directive("%option", listOf(DirectiveArg(null, "merge", null, block.position)), block.position))
+                    }
                }
            }
        }
@@ -127,7 +131,7 @@ class ModuleImporter(private val program: Program,

    private fun removeDirectivesFromImportedModule(importedModule: Module) {
        // Most global directives don't apply for imported modules, so remove them
-        val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address")
+        val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%zpallowed", "%address")
        var directives = importedModule.statements.filterIsInstance<Directive>()
        importedModule.statements.removeAll(directives.toSet())
        directives = directives.filter{ it.directive !in moduleLevelDirectives }
@@ -7,7 +7,6 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.IAstVisitor
 import prog8.code.core.*
-import prog8.code.target.C64Target
 import prog8.code.target.Cx16Target
 import prog8.code.target.VMTarget
 import prog8.compiler.builtinFunctionReturnType
@@ -56,13 +55,14 @@ internal class AstChecker(private val program: Program,
        val directives = module.statements.filterIsInstance<Directive>().groupBy { it.directive }
        directives.filter { it.value.size > 1 }.forEach{ entry ->
            when(entry.key) {
-                "%output", "%launcher", "%zeropage", "%address" ->
+                "%output", "%launcher", "%zeropage", "%address", "%encoding" ->
                    entry.value.forEach { errors.err("directive can just occur once", it.position) }
            }
        }
    }

    override fun visit(identifier: IdentifierReference) {
+        checkLongType(identifier)
        val stmt = identifier.targetStatement(program)
        if(stmt==null)
            errors.undefined(identifier.nameInSource, identifier.position)
@@ -280,6 +280,10 @@ internal class AstChecker(private val program: Program,
        super.visit(label)
    }

+    override fun visit(numLiteral: NumericLiteral) {
+        checkLongType(numLiteral)
+    }
+
    private fun hasReturnOrJumpOrRts(scope: IStatementContainer): Boolean {
        class Searcher: IAstVisitor
        {
@@ -314,7 +318,7 @@ internal class AstChecker(private val program: Program,
            err("cannot redefine a built-in function")

        if(subroutine.parameters.size>6 && !subroutine.isAsmSubroutine && !subroutine.definingBlock.isInLibrary)
-            errors.warn("subroutine has a large number of parameters, this slows down code execution a lot", subroutine.position)
+            errors.warn("subroutine has a large number of parameters, this is slow if called often", subroutine.position)

        val uniqueNames = subroutine.parameters.asSequence().map { it.name }.toSet()
        if(uniqueNames.size!=subroutine.parameters.size)
@@ -529,6 +533,9 @@ internal class AstChecker(private val program: Program,
    }

    override fun visit(assignTarget: AssignTarget) {
+        if(assignTarget.inferType(program).istype(DataType.LONG))
+            errors.err("integer overflow", assignTarget.position)
+
        super.visit(assignTarget)

        val memAddr = assignTarget.memoryAddress?.addressExpression?.constValue(program)?.number?.toInt()
@@ -578,6 +585,7 @@ internal class AstChecker(private val program: Program,
    }

    override fun visit(addressOf: AddressOf) {
+        checkLongType(addressOf)
        val variable=addressOf.identifier.targetVarDecl(program)
        if(variable!=null && variable.type==VarDeclType.CONST)
            errors.err("invalid pointer-of operand type", addressOf.position)
@@ -585,6 +593,12 @@ internal class AstChecker(private val program: Program,
    }

    override fun visit(decl: VarDecl) {
+        if(decl.names.size>1)
+            throw InternalCompilerException("vardecls with multiple names should have been converted into individual vardecls")
+
+        if(decl.datatype==DataType.LONG)
+            errors.err("integer overflow", decl.position)
+
        fun err(msg: String) = errors.err(msg, decl.position)

        // the initializer value can't refer to the variable itself (recursive definition)
@@ -594,7 +608,7 @@ internal class AstChecker(private val program: Program,
        // CONST can only occur on simple types (byte, word, float)
        if(decl.type== VarDeclType.CONST) {
            if (decl.datatype !in NumericDatatypes)
-                err("const modifier can only be used on numeric types (byte, word, float)")
+                err("const can only be used on numeric types (byte, word, float)")
        }

        // FLOATS enabled?
@@ -773,7 +787,7 @@ internal class AstChecker(private val program: Program,
                        directive.args[0].name != "full")
                    err("invalid zp type, expected basicsafe, floatsafe, kernalsafe, dontuse, or full")
            }
-            "%zpreserved" -> {
+            "%zpreserved", "%zpallowed" -> {
                if(directive.parent !is Module)
                    err("this directive may only occur at module level")
                if(directive.args.size!=2 || directive.args[0].int==null || directive.args[1].int==null)
@@ -832,9 +846,20 @@ internal class AstChecker(private val program: Program,
                    if(directive.args.any {it.name !in arrayOf("align_word", "align_page", "no_symbol_prefixing", "force_output", "merge", "splitarrays", "verafxmuls")})
                        err("using an option that is not valid for blocks")
                }
+                if(directive.parent is Module) {
+                    if(directive.args.any {it.name !in arrayOf("enable_floats", "no_sysinit", "splitarrays")})
+                        err("using an option that is not valid for modules")
+                }
                if(directive.args.any { it.name=="verafxmuls" } && compilerOptions.compTarget.name != Cx16Target.NAME)
                    err("verafx option is only valid on cx16 target")
            }
+            "%encoding" -> {
+                if(directive.parent !is Module)
+                    err("this directive may only occur at module level")
+                val allowedEncodings = Encoding.entries.map {it.prefix}
+                if(directive.args.size!=1 || directive.args[0].name !in allowedEncodings)
+                    err("invalid encoding directive, expected one of ${allowedEncodings}")
+            }
            else -> throw SyntaxError("invalid directive ${directive.directive}", directive.position)
        }
        super.visit(directive)
@@ -912,6 +937,7 @@ internal class AstChecker(private val program: Program,
    }

    override fun visit(expr: PrefixExpression) {
+        checkLongType(expr)
        val dt = expr.expression.inferType(program).getOr(DataType.UNDEFINED)
        if(dt==DataType.UNDEFINED)
            return  // any error should be reported elsewhere
@@ -932,6 +958,7 @@ internal class AstChecker(private val program: Program,

    override fun visit(expr: BinaryExpression) {
        super.visit(expr)
+        checkLongType(expr)

        val leftIDt = expr.left.inferType(program)
        val rightIDt = expr.right.inferType(program)
@@ -950,7 +977,7 @@ internal class AstChecker(private val program: Program,

        if(expr.operator=="+" || expr.operator=="-") {
            if(leftDt == DataType.STR || rightDt == DataType.STR || leftDt in ArrayDatatypes || rightDt in ArrayDatatypes) {
-                errors.err("missing & (address-of) on the string operand", expr.position)
+                errors.err("missing & (address-of) on the operand", expr.position)
                return
            }
        }
@@ -1033,6 +1060,7 @@ internal class AstChecker(private val program: Program,
    }

    override fun visit(typecast: TypecastExpression) {
+        checkLongType(typecast)
        if(typecast.type in IterableDatatypes)
            errors.err("cannot type cast to string or array type", typecast.position)

@@ -1079,6 +1107,7 @@ internal class AstChecker(private val program: Program,
    }

    override fun visit(functionCallExpr: FunctionCallExpression) {
+        checkLongType(functionCallExpr)
        // this function call is (part of) an expression, which should be in a statement somewhere.
        val stmtOfExpression = findParentNode<Statement>(functionCallExpr)
                ?: throw FatalAstException("cannot determine statement scope of function call expression at ${functionCallExpr.position}")
@@ -1134,6 +1163,11 @@ internal class AstChecker(private val program: Program,
        super.visit(functionCallExpr)
    }

+    override fun visit(bfc: BuiltinFunctionCall) {
+        checkLongType(bfc)
+        super.visit(bfc)
+    }
+
    override fun visit(functionCallStatement: FunctionCallStatement) {
        val targetStatement = functionCallStatement.target.checkFunctionOrLabelExists(program, functionCallStatement, errors)
        if(targetStatement!=null) {
@@ -1213,6 +1247,13 @@ internal class AstChecker(private val program: Program,
    }

    private fun checkFunctionCall(target: Statement, args: List<Expression>, position: Position) {
+        if(target is BuiltinFunctionPlaceholder) {
+            if(!compilerOptions.floats) {
+                if (target.name == "peekf" || target.name == "pokef")
+                    errors.err("floating point used, but that is not enabled via options", position)
+            }
+        }
+
        if(target is Label && args.isNotEmpty())
            errors.err("cannot use arguments when calling a label", position)

@@ -1263,6 +1304,10 @@ internal class AstChecker(private val program: Program,
                }
            }
        }
+
+        args.forEach{
+            checkLongType(it)
+        }
    }

    override fun visit(postIncrDecr: PostIncrDecr) {
@@ -1300,6 +1345,7 @@ internal class AstChecker(private val program: Program,
    }

    override fun visit(arrayIndexedExpression: ArrayIndexedExpression) {
+        checkLongType(arrayIndexedExpression)
        val target = arrayIndexedExpression.arrayvar.targetStatement(program)
        if(target is VarDecl) {
            if(target.datatype !in IterableDatatypes && target.datatype!=DataType.UWORD)
@@ -1338,7 +1384,7 @@ internal class AstChecker(private val program: Program,
            if(choices!=null) {
                for (c in choices) {
                    if(c in tally)
-                        errors.err("choice value already occurs earlier", choiceNode.position)
+                        errors.err("choice value already occurs elsewhere", choiceNode.position)
                    else
                        tally.add(c)
                }
@@ -1348,6 +1394,9 @@ internal class AstChecker(private val program: Program,
        if(whenStmt.choices.isEmpty())
            errors.err("empty when statement", whenStmt.position)

+        if(whenStmt.condition.constValue(program)!=null)
+            errors.warn("when-value is a constant and will always result in the same choice", whenStmt.condition.position)
+
        super.visit(whenStmt)
    }

@@ -1355,18 +1404,18 @@ internal class AstChecker(private val program: Program,
        val whenStmt = whenChoice.parent as When
        if(whenChoice.values!=null) {
            val conditionType = whenStmt.condition.inferType(program)
-            val constvalues = whenChoice.values!!.map { it.constValue(program) }
-            for(constvalue in constvalues) {
+            val constvalues = whenChoice.values!!.map { it.constValue(program) to it.position }
+            for((constvalue, pos) in constvalues) {
                when {
-                    constvalue == null -> errors.err("choice value must be a constant", whenChoice.position)
-                    constvalue.type !in IntegerDatatypes -> errors.err("choice value must be a byte or word", whenChoice.position)
+                    constvalue == null -> errors.err("choice value must be a constant", pos)
+                    constvalue.type !in IntegerDatatypes -> errors.err("choice value must be a byte or word", pos)
                    conditionType isnot constvalue.type -> {
                        if(conditionType.isKnown) {
                            if(conditionType.istype(DataType.BOOL)) {
                                if(constvalue.number!=0.0 && constvalue.number!=1.0)
-                                    errors.err("choice value datatype differs from condition value", whenChoice.position)
+                                    errors.err("choice value datatype differs from condition value", pos)
                            } else {
-                                errors.err("choice value datatype differs from condition value", whenChoice.position)
+                                errors.err("choice value datatype differs from condition value", pos)
                            }
                        }
                    }
@@ -1441,6 +1490,12 @@ internal class AstChecker(private val program: Program,
            errors.err("%asm containing IR code cannot be translated to 6502 assembly", inlineAssembly.position)
    }

+    private fun checkLongType(expression: Expression) {
+        if(expression.inferType(program).istype(DataType.LONG)) {
+            errors.err("integer overflow", expression.position)
+        }
+    }
+
    private fun checkValueTypeAndRangeString(targetDt: DataType, value: StringLiteral) : Boolean {
        return if (targetDt == DataType.STR) {
            when {
@@ -61,10 +61,6 @@ internal fun Program.charLiteralsToUByteLiterals(target: ICompilationTarget, err
    val walker = object : AstWalker() {
        override fun after(char: CharLiteral, parent: Node): Iterable<IAstModification> {
            require(char.encoding != Encoding.DEFAULT)
-            if(char.encoding != Encoding.DEFAULT && char.encoding !in target.supportedEncodings) {
-                errors.err("compilation target doesn't support this text encoding", char.position)
-                return noModifications
-            }
            return try {
                val encoded = target.encodeString(char.value.toString(), char.encoding)
                listOf(IAstModification.ReplaceNode(
@@ -81,10 +77,6 @@ internal fun Program.charLiteralsToUByteLiterals(target: ICompilationTarget, err
        override fun after(string: StringLiteral, parent: Node): Iterable<IAstModification> {
            // this only *checks* for errors for string encoding. The actual encoding is done much later
            require(string.encoding != Encoding.DEFAULT)
-            if(string.encoding != Encoding.DEFAULT && string.encoding !in target.supportedEncodings) {
-                errors.err("compilation target doesn't support this text encoding", string.position)
-                return noModifications
-            }
            try {
                target.encodeString(string.value, string.encoding)
            } catch (x: CharConversionException) {
@@ -33,10 +33,13 @@ internal class AstIdentifiersChecker(private val errors: IErrorReporter,
    override fun visit(block: Block) {
        val existing = blocks[block.name]
        if(existing!=null) {
-            if(block.isInLibrary)
-                nameError(existing.name, existing.position, block)
-            else
-                nameError(block.name, block.position, existing)
+            // we allow duplicates if at least one of them has %option merge
+            if("merge" !in existing.options() + block.options()) {
+                if (block.isInLibrary)
+                    nameError(existing.name, existing.position, block)
+                else
+                    nameError(block.name, block.position, existing)
+            }
        }
        else
            blocks[block.name] = block
@@ -50,16 +53,18 @@ internal class AstIdentifiersChecker(private val errors: IErrorReporter,
        if(decl.name in BuiltinFunctions)
            errors.err("builtin function cannot be redefined", decl.position)

-        val existingInSameScope = decl.definingScope.lookup(listOf(decl.name))
-        if(existingInSameScope!=null && existingInSameScope!==decl)
-            nameError(decl.name, decl.position, existingInSameScope)
+        if(decl.names.size<2) {
+            val existingInSameScope = decl.definingScope.lookup(listOf(decl.name))
+            if (existingInSameScope != null && existingInSameScope !== decl)
+                nameError(decl.name, decl.position, existingInSameScope)

-        val existingOuter = decl.parent.definingScope.lookup(listOf(decl.name))
-        if (existingOuter != null && existingOuter !== decl && existingOuter is VarDecl) {
-            if(existingOuter.parent!==decl.parent)
-                nameShadowWarning(decl.name, decl.position, existingOuter)
-            else
-                nameError(decl.name, decl.position, existingOuter)
+            val existingOuter = decl.parent.definingScope.lookup(listOf(decl.name))
+            if (existingOuter != null && existingOuter !== decl && existingOuter is VarDecl) {
+                if (existingOuter.parent !== decl.parent)
+                    nameShadowWarning(decl.name, decl.position, existingOuter)
+                else
+                    nameError(decl.name, decl.position, existingOuter)
+            }
        }

        if(decl.definingBlock.name==decl.name)
@@ -174,7 +179,8 @@ internal class AstIdentifiersChecker(private val errors: IErrorReporter,
                            else
                                '_'
                        }.joinToString("")
-                        call.args[0] = StringLiteral(processed, compTarget.defaultEncoding, name.position)
+                        val textEncoding = (call as Node).definingModule.textEncoding
+                        call.args[0] = StringLiteral(processed, textEncoding, name.position)
                        call.args[0].linkParents(call as Node)
                    }
                }
@@ -58,13 +58,13 @@ class AstPreprocessor(val program: Program,

    override fun before(char: CharLiteral, parent: Node): Iterable<IAstModification> {
        if(char.encoding== Encoding.DEFAULT)
-            char.encoding = options.compTarget.defaultEncoding
+            char.encoding = char.definingModule.textEncoding
        return noModifications
    }

    override fun before(string: StringLiteral, parent: Node): Iterable<IAstModification> {
        if(string.encoding==Encoding.DEFAULT)
-            string.encoding = options.compTarget.defaultEncoding
+            string.encoding = string.definingModule.textEncoding
        return super.before(string, parent)
    }

@@ -117,16 +117,36 @@ class AstPreprocessor(val program: Program,
                    replacements.add(IAstModification.Remove(decl, scope))
                } else {
                    val declToInsert: VarDecl
-                    if(decl.value!=null && decl.datatype in NumericDatatypes) {
-                        val target = AssignTarget(IdentifierReference(listOf(decl.name), decl.position), null, null, decl.position)
-                        val assign = Assignment(target, decl.value!!, AssignmentOrigin.VARINIT, decl.position)
-                        replacements.add(IAstModification.ReplaceNode(decl, assign, scope))
-                        decl.value = null
-                        decl.allowInitializeWithZero = false
-                        declToInsert = decl.copy()
+                    if(decl.names.size>1) {
+                        // we need to handle multi-decl here too, the desugarer maybe has not processed it here yet...
+                        if(decl.value!=null) {
+                            decl.names.forEach { name ->
+                                val target = AssignTarget(IdentifierReference(listOf(name), decl.position), null, null, decl.position)
+                                val assign = Assignment(target.copy(), decl.value!!.copy(), AssignmentOrigin.VARINIT, decl.position)
+                                replacements.add(IAstModification.InsertAfter(decl, assign, scope))
+                            }
+                            replacements.add(IAstModification.Remove(decl, scope))
+                            decl.value = null
+                            decl.allowInitializeWithZero = false
+                            declToInsert = decl
+                        } else {
+                            // just move it to the defining scope
+                            replacements.add(IAstModification.Remove(decl, scope))
+                            declToInsert = decl
+                        }
                    } else {
-                        replacements.add(IAstModification.Remove(decl, scope))
-                        declToInsert = decl
+                        // handle declaration of a single variable
+                        if(decl.value!=null && decl.datatype in NumericDatatypes) {
+                            val target = AssignTarget(IdentifierReference(listOf(decl.name), decl.position), null, null, decl.position)
+                            val assign = Assignment(target, decl.value!!, AssignmentOrigin.VARINIT, decl.position)
+                            replacements.add(IAstModification.ReplaceNode(decl, assign, scope))
+                            decl.value = null
+                            decl.allowInitializeWithZero = false
+                            declToInsert = decl.copy()
+                        } else {
+                            replacements.add(IAstModification.Remove(decl, scope))
+                            declToInsert = decl
+                        }
                    }
                    movements.add(IAstModification.InsertFirst(declToInsert, parentscope))
                }
@@ -177,7 +197,7 @@ class AstPreprocessor(val program: Program,
    private fun makeSplitArray(decl: VarDecl): Iterable<IAstModification> {
        val splitDt = ArrayToElementTypes.getValue(decl.datatype)
        val newDecl = VarDecl(
-            decl.type, decl.origin, splitDt, decl.zeropage, decl.arraysize, decl.name,
+            decl.type, decl.origin, splitDt, decl.zeropage, decl.arraysize, decl.name, emptyList(),
            decl.value, true, decl.sharedWithAsm, true, decl.position
        )
        return listOf(IAstModification.ReplaceNode(decl, newDecl, decl.parent))
@@ -4,8 +4,10 @@ import prog8.ast.IStatementContainer
 import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.FatalAstException
-import prog8.ast.expressions.*
-import prog8.ast.getTempVar
+import prog8.ast.expressions.BinaryExpression
+import prog8.ast.expressions.ContainmentCheck
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
@@ -39,72 +41,6 @@ internal class BeforeAsmAstChanger(val program: Program, private val options: Co
        return noModifications
    }

-    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
-        // Try to replace A = B <operator> Something  by A= B, A = A <operator> Something
-        // this triggers the more efficent augmented assignment code generation more often.
-        // But it can only be done if the target variable IS NOT OCCURRING AS AN OPERAND ITSELF.
-
-        if(options.compTarget.name==VMTarget.NAME)   // don't apply this optimization for Vm target
-            return noModifications
-
-        if(!assignment.isAugmentable
-            && assignment.target.identifier != null
-            && !assignment.target.isIOAddress(options.compTarget.machine)) {
-            val binExpr = assignment.value as? BinaryExpression
-
-            if (binExpr != null && binExpr.operator !in ComparisonOperators) {
-                if (binExpr.left !is BinaryExpression) {
-                    if (binExpr.right.referencesIdentifier(assignment.target.identifier!!.nameInSource)) {
-                        // the right part of the expression contains the target variable itself.
-                        // we can't 'split' it trivially because the variable will be changed halfway through.
-                        if(binExpr.operator in AssociativeOperators) {
-                            // A = <something-without-A>  <associativeoperator>  <otherthing-with-A>
-                            // use the other part of the expression to split.
-                            val sourceDt = binExpr.right.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
-                            val (_, right) = binExpr.right.typecastTo(assignment.target.inferType(program).getOrElse { throw AssemblyError(
-                                "unknown dt"
-                            )
-                            }, sourceDt, implicit=true)
-                            val assignRight = Assignment(assignment.target, right, AssignmentOrigin.ASMGEN, assignment.position)
-                            return listOf(
-                                IAstModification.InsertBefore(assignment, assignRight, parent as IStatementContainer),
-                                IAstModification.ReplaceNode(binExpr.right, binExpr.left, binExpr),
-                                IAstModification.ReplaceNode(binExpr.left, assignment.target.toExpression(), binExpr)
-                            )
-                        }
-                    } else {
-                        if(binExpr.left isSameAs assignment.target)
-                            return noModifications
-                        val typeCast = binExpr.left as? TypecastExpression
-                        if(typeCast!=null && typeCast.expression isSameAs assignment.target)
-                            return noModifications
-
-                        if(binExpr.operator in "+-") {
-                            val leftDt = binExpr.left.inferType(program)
-                            val rightDt = binExpr.right.inferType(program)
-                            if(leftDt==rightDt && leftDt.isInteger && rightDt.isInteger && binExpr.right is ArrayIndexedExpression) {
-                                // don't split array[i] +/- array[i]    (the codegen has an optimized path for this)
-                                return noModifications
-                            }
-                        }
-
-                        val sourceDt = binExpr.left.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
-                        val (_, left) = binExpr.left.typecastTo(assignment.target.inferType(program).getOrElse { throw AssemblyError(
-                            "unknown dt"
-                        )
-                        }, sourceDt, implicit=true)
-                        val assignLeft = Assignment(assignment.target, left, AssignmentOrigin.ASMGEN, assignment.position)
-                        return listOf(
-                            IAstModification.InsertBefore(assignment, assignLeft, parent as IStatementContainer),
-                            IAstModification.ReplaceNode(binExpr.left, assignment.target.toExpression(), binExpr)
-                        )
-                    }
-                }
-            }
-        }
-        return noModifications
-    }
-
    override fun after(scope: AnonymousScope, parent: Node): Iterable<IAstModification> {
        if(scope.statements.any { it is VarDecl || it is IStatementContainer })
            throw FatalAstException("anonymousscope may no longer contain any vardecls or subscopes")
@@ -221,35 +157,4 @@ internal class BeforeAsmAstChanger(val program: Program, private val options: Co

        return noModifications
    }
-
-    override fun after(arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable<IAstModification> {
-
-        if(options.compTarget.name!=VMTarget.NAME) {    // don't apply this optimization/check for Vm target
-            val index = arrayIndexedExpression.indexer.indexExpr
-            if (index !is NumericLiteral && index !is IdentifierReference) {
-                // replace complex indexing expression with a temp variable to hold the computed index first
-                return getAutoIndexerVarFor(arrayIndexedExpression)
-            }
-        }
-
-        return noModifications
-    }
-
-    private fun getAutoIndexerVarFor(expr: ArrayIndexedExpression): MutableList<IAstModification> {
-        val modifications = mutableListOf<IAstModification>()
-        val statement = expr.containingStatement
-        val dt = expr.indexer.indexExpr.inferType(program)
-        val (tempVarName, _) = program.getTempVar(dt.getOrElse { throw FatalAstException("invalid dt") })
-        val target = AssignTarget(IdentifierReference(tempVarName, expr.indexer.position), null, null, expr.indexer.position)
-        val assign = Assignment(target, expr.indexer.indexExpr, AssignmentOrigin.ASMGEN, expr.indexer.position)
-        modifications.add(IAstModification.InsertBefore(statement, assign, statement.parent as IStatementContainer))
-        modifications.add(
-            IAstModification.ReplaceNode(
-                expr.indexer.indexExpr,
-                target.identifier!!.copy(),
-                expr.indexer
-            )
-        )
-        return modifications
-    }
 }
@@ -29,7 +29,7 @@ internal class BoolRemover(val program: Program) : AstWalker() {
                if(newvalue.number!=0.0)
                    newvalue = NumericLiteral(DataType.UBYTE, 1.0, newvalue.position)
            }
-            val ubyteDecl = VarDecl(decl.type, decl.origin, DataType.UBYTE, decl.zeropage, decl.arraysize, decl.name,
+            val ubyteDecl = VarDecl(decl.type, decl.origin, DataType.UBYTE, decl.zeropage, decl.arraysize, decl.name, emptyList(),
                newvalue, decl.isArray, decl.sharedWithAsm, decl.splitArray, decl.position)
            return listOf(IAstModification.ReplaceNode(decl, ubyteDecl, parent))
        }
@@ -46,7 +46,7 @@ internal class BoolRemover(val program: Program) : AstWalker() {
                }.toTypedArray()
                newarray = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_UB), convertedArray, decl.position)
            }
-            val ubyteArrayDecl = VarDecl(decl.type, decl.origin, DataType.ARRAY_UB, decl.zeropage, decl.arraysize, decl.name,
+            val ubyteArrayDecl = VarDecl(decl.type, decl.origin, DataType.ARRAY_UB, decl.zeropage, decl.arraysize, decl.name, emptyList(),
                newarray, true, decl.sharedWithAsm, decl.splitArray, decl.position)
            return listOf(IAstModification.ReplaceNode(decl, ubyteArrayDecl, parent))
        }
@@ -19,13 +19,13 @@ internal class CodeDesugarer(val program: Program, private val errors: IErrorRep
    // have been performed (because those could re-introduce nodes that have to be desugared)
    //
    // List of modifications:
-    // - replace 'break' statements by a goto + generated after label.
+    // - replace 'break' and 'continue' statements by a goto + generated after label.
    // - replace while and do-until loops by just jumps.
    // - replace peek() and poke() by direct memory accesses.
    // - repeat-forever loops replaced by label+jump.
    // - pointer[word] replaced by @(pointer+word)
    // - @(&var) and @(&var+1) replaced by lsb(var) and msb(var) if var is a word
-
+    // - flatten chained assignments

    override fun before(breakStmt: Break, parent: Node): Iterable<IAstModification> {
        fun jumpAfter(stmt: Statement): Iterable<IAstModification> {
@@ -52,6 +52,39 @@ internal class CodeDesugarer(val program: Program, private val errors: IErrorRep
        }
    }

+    override fun before(continueStmt: Continue, parent: Node): Iterable<IAstModification> {
+        fun jumpToBottom(scope: IStatementContainer): Iterable<IAstModification> {
+            val label = program.makeLabel("cont", continueStmt.position)
+            return listOf(
+                IAstModification.ReplaceNode(continueStmt, program.jumpLabel(label), parent),
+                IAstModification.InsertLast(label, scope)
+            )
+        }
+
+        fun jumpToBefore(loop: WhileLoop): Iterable<IAstModification> {
+            val label = program.makeLabel("cont", continueStmt.position)
+            return listOf(
+                IAstModification.ReplaceNode(continueStmt, program.jumpLabel(label), parent),
+                IAstModification.InsertBefore(loop, label, loop.parent as IStatementContainer)
+            )
+        }
+
+        var partof = parent
+        while(true) {
+            when (partof) {
+                is Subroutine, is Block, is ParentSentinel -> {
+                    errors.err("continue in wrong scope", continueStmt.position)
+                    return noModifications
+                }
+                is ForLoop -> return jumpToBottom(partof.body)
+                is RepeatLoop -> return jumpToBottom(partof.body)
+                is UntilLoop -> return jumpToBottom(partof.body)
+                is WhileLoop -> return jumpToBefore(partof)
+                else -> partof = partof.parent
+            }
+        }
+    }
+
    override fun after(untilLoop: UntilLoop, parent: Node): Iterable<IAstModification> {
        /*
 do { STUFF } until CONDITION
@@ -77,6 +110,22 @@ if CONDITION==0
    }

    override fun after(whileLoop: WhileLoop, parent: Node): Iterable<IAstModification> {
+        /*
+        while true -> repeat
+        while false -> discard
+         */
+
+        val constCondition = whileLoop.condition.constValue(program)?.asBooleanValue
+        if(constCondition==true) {
+            errors.warn("condition is always true", whileLoop.condition.position)
+            val repeat = RepeatLoop(null, whileLoop.body, whileLoop.position)
+            return listOf(IAstModification.ReplaceNode(whileLoop, repeat, parent))
+        } else if(constCondition==false) {
+            errors.warn("condition is always false", whileLoop.condition.position)
+            return listOf(IAstModification.Remove(whileLoop, parent as IStatementContainer))
+        }
+
+
        /*
 while CONDITION { STUFF }
    ==>
@@ -238,4 +287,33 @@ _after:
        return noModifications
    }

+    override fun after(chainedAssignment: ChainedAssignment, parent: Node): Iterable<IAstModification> {
+        val assign = chainedAssignment.nested as? Assignment
+        if(assign!=null) {
+            // unpack starting from last in the chain
+            val assigns = mutableListOf<Statement>(assign)
+            var lastChained: ChainedAssignment = chainedAssignment
+            var pc: ChainedAssignment? = chainedAssignment
+
+            if(assign.value.isSimple) {
+                // simply copy the RHS value to each component's assignment
+                while (pc != null) {
+                    lastChained = pc
+                    assigns.add(Assignment(pc.target.copy(), assign.value.copy(), assign.origin, pc.position))
+                    pc = pc.parent as? ChainedAssignment
+                }
+            } else if(pc!=null) {
+                // need to evaluate RHS once and reuse that in each component's assignment
+                val firstComponentAsValue = assign.target.toExpression()
+                while (pc != null) {
+                    lastChained = pc
+                    assigns.add(Assignment(pc.target.copy(), firstComponentAsValue.copy(), assign.origin, pc.position))
+                    pc = pc.parent as? ChainedAssignment
+                }
+            }
+            return listOf(IAstModification.ReplaceNode(lastChained,
+                AnonymousScope(assigns, chainedAssignment.position), lastChained.parent))
+        }
+        return noModifications
+    }
 }
@@ -37,9 +37,11 @@ class IntermediateAstMaker(private val program: Program, private val errors: IEr
    private fun transformStatement(statement: Statement): PtNode {
        return when (statement) {
            is AnonymousScope -> throw FatalAstException("AnonymousScopes should have been flattened")
+            is ChainedAssignment -> throw FatalAstException("ChainedAssignment should have been flattened")
            is Assignment -> transform(statement)
            is Block -> transform(statement)
            is Break -> throw FatalAstException("break should have been replaced by Goto")
+            is Continue -> throw FatalAstException("continue should have been replaced by Goto")
            is BuiltinFunctionCallStatement -> transform(statement)
            is BuiltinFunctionPlaceholder -> throw FatalAstException("BuiltinFunctionPlaceholder should not occur in Ast here")
            is ConditionalBranch -> transform(statement)
@@ -1,6 +1,7 @@
 package prog8.compiler.astprocessing

 import prog8.ast.IFunctionCall
+import prog8.ast.IStatementContainer
 import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.expressions.ArrayLiteral
@@ -21,10 +22,6 @@ internal class LiteralsToAutoVars(private val program: Program,
 ) : AstWalker() {

    override fun after(string: StringLiteral, parent: Node): Iterable<IAstModification> {
-        if(string.encoding != Encoding.DEFAULT && string.encoding !in target.supportedEncodings) {
-            errors.err("compilation target doesn't support this text encoding", string.position)
-            return noModifications
-        }
        if(string.parent !is VarDecl && string.parent !is WhenChoice) {
            val binExpr = string.parent as? BinaryExpression
            if(binExpr!=null &&(binExpr.operator=="+" || binExpr.operator=="*"))
@@ -74,4 +71,20 @@ internal class LiteralsToAutoVars(private val program: Program,
        }
        return noModifications
    }
+
+    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+        if(decl.names.size>1) {
+            // note: the desugaring of a multi-variable vardecl has to be done here
+            // and not in CodeDesugarer, that one is too late (identifiers can't be found otherwise)
+            if(decl.datatype !in NumericDatatypes)
+                errors.err("can only multi declare numeric variables", decl.position)
+            if(errors.noErrors()) {
+                // desugar into individual vardecl per name.
+                return decl.desugarMultiDecl().map {
+                    IAstModification.InsertBefore(decl, it, parent as IStatementContainer)
+                } + IAstModification.Remove(decl, parent as IStatementContainer)
+            }
+        }
+        return noModifications
+    }
 }
@@ -22,7 +22,7 @@ internal class StatementReorderer(
    // - sorts the choices in when statement.
    // - insert AddressOf (&) expression where required (string params to a UWORD function param etc.).

-    private val directivesToMove = setOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address", "%option")
+    private val directivesToMove = setOf("%output", "%launcher", "%zeropage", "%zpreserved", "%zpallowed", "%address", "%option", "%encoding")

    override fun after(module: Module, parent: Node): Iterable<IAstModification> {
        val (blocks, other) = module.statements.partition { it is Block }
@@ -52,10 +52,6 @@ internal class StatementReorderer(
                            // This allows you to restart the program and have the same starting values of the variables
                            // So basically consider 'ubyte xx' as a short form for 'ubyte xx; xx=0'
                            decl.value = null
-                            if(decl.name.startsWith("tempvar_") && decl.definingScope.name=="prog8_lib") {
-                                // no need to zero out the special internal temporary variables.
-                                return noModifications
-                            }
                            if(decl.findInitializer(program)!=null)
                                return noModifications   // an initializer assignment for a vardecl is already here
                            val nextFor = decl.nextSibling() as? ForLoop
@@ -159,6 +155,7 @@ internal class StatementReorderer(
                                it.zeropage,
                                null,
                                it.name,
+                                emptyList(),
                                null,
                                false,
                                it.sharedWithAsm,
@@ -195,11 +192,6 @@ internal class StatementReorderer(
                errors.err("else choice must be the last one", whenStmt.choices[elseChoice].position)
        }

-        val choices = whenStmt.choiceValues(program).sortedBy {
-            it.first?.first() ?: Int.MAX_VALUE
-        }
-        whenStmt.choices.clear()
-        choices.mapTo(whenStmt.choices) { it.second }
        return noModifications
    }
Author	SHA1	Message	Date
Irmen de Jong	e98e951834	fix chained assignment and multi-vardecl RHS evaluation	2023-12-10 16:44:51 +01:00
Irmen de Jong	2668bf8519	fix void optimization issue	2023-12-09 21:48:22 +01:00
Irmen de Jong	dd4c073e18	version 9.7	2023-12-09 18:54:54 +01:00
Irmen de Jong	c7c72f00c7	document underscores in numeric literals for grouping	2023-12-09 14:07:42 +01:00
Irmen de Jong	ef1c665b9a	allow underscores for numerical grouping	2023-12-09 13:13:34 +01:00
Irmen de Jong	d56565be25	fix multi-var decl	2023-12-09 12:32:41 +01:00
Irmen de Jong	e076b3aedc	fix multi-var decl in nested scopes	2023-12-09 12:07:09 +01:00
Irmen de Jong	ae3b2ddf5f	allow multi var declarations for floats too	2023-12-08 23:29:13 +01:00
Irmen de Jong	1bdc427d73	multi var declarations ubyte x,y,z	2023-12-08 22:18:21 +01:00
Irmen de Jong	6a639ce533	chained assignments x=y=z=42	2023-12-08 01:07:16 +01:00
Irmen de Jong	d91ca8b197	vm: added floats.str_f()	2023-12-07 23:10:27 +01:00
Irmen de Jong	a01c0a283d	add check for memory() args to be const, added floats.str_f() add check for memory() args to be const	2023-12-07 22:39:53 +01:00
Irmen de Jong	5c393091a0	unit test for %encoding	2023-12-07 21:54:01 +01:00
Frosty-J	01b680504b	Add `%encoding` to syntax files (#113 ) * IDEA `%encoding` syntax * N++ `%encoding` syntax * Vim `%encoding` syntax	2023-12-07 21:53:33 +01:00
Irmen de Jong	8e4319cd5a	module directive %encoding to set the text encoding for that whole file (iso, petscii, etc.)	2023-12-06 23:54:08 +01:00
Irmen de Jong	5a776dd690	improve KotlinJavaRuntime library ref	2023-12-06 22:52:39 +01:00
Irmen de Jong	cce08d95db	unused subroutine warning only for main compilation module	2023-12-06 21:48:56 +01:00
Irmen de Jong	28c1b208c1	optimized calls for float *10 and +0.5	2023-12-06 01:18:07 +01:00
Irmen de Jong	3844bf1f72	fix string.isupper()	2023-12-05 23:52:43 +01:00
Irmen de Jong	745d192563	added floats.normalize()	2023-12-05 22:54:35 +01:00
Irmen de Jong	ee782e92ac	fix cast error and vm float parsing	2023-12-05 22:51:15 +01:00
Irmen de Jong	afbc91d1fc	added string.isdigit, islower, isupper, isletter	2023-12-05 22:50:20 +01:00
Irmen de Jong	f998888d6d	fix some unicode identifier issues	2023-12-05 17:38:23 +01:00
Irmen de Jong	7d8b42d63e	allow Unicode letters in identifiers: things like 'knäckebröd' and 'π' are now valid identifiers. Added floats.π constant.	2023-12-05 01:36:54 +01:00
Irmen de Jong	6ebd4e821f	improved docs about subroutine scoping, fix possible optimizer crash for inlined sub	2023-12-04 23:23:52 +01:00
Irmen de Jong	d1806bfdc3	added remaining verafx registers	2023-12-03 22:15:29 +01:00
Irmen de Jong	1d2d7155da	palette: changed some of the available presets. Also fix sizeof(array) crash.	2023-12-03 17:14:40 +01:00
Irmen de Jong	b09e0a05bf	some tweaks to errors about long integer literals	2023-12-03 02:45:26 +01:00
Irmen de Jong	c609e982fe	allow const expression intermediate values to be 32 bits integers to avoid needless overflow errors.	2023-12-03 01:48:12 +01:00
Irmen de Jong	2b227b43fe	bmx: error for unsupported file version	2023-12-02 23:56:59 +01:00
Irmen de Jong	48f09f71ab	fix TODO crash on uword[0] = uword[0] or 128 (byte register assign to word array)	2023-12-02 21:29:14 +01:00
Irmen de Jong	ead8c59bda	allow all character encodings on all compilation targets.	2023-12-02 20:59:50 +01:00
Irmen de Jong	db52a9466c	fix weird compiler warning for while 1 {..}	2023-12-02 20:24:45 +01:00
Irmen de Jong	1509de390e	various fixes print_f() no longer prints a leading space. Better error message if using float in for loop. Fix crash when using non-const as when choice value. VM print_f() more closely resembles the CBM version.	2023-12-02 18:23:54 +01:00
Irmen de Jong	88a1aa4f3d	fix invalid optimization for integers (X/C1)*C2 , only ok for floats because of int rounding	2023-12-01 23:17:49 +01:00
Irmen de Jong	172e78e8f2	ir: ignore empty chunks instead of crashing	2023-12-01 22:49:20 +01:00
Irmen de Jong	36bfef567d	comments	2023-12-01 20:20:18 +01:00
Irmen de Jong	e40ebd75a2	floats.parse_f uses kernal VAL if it's present	2023-11-30 23:50:50 +01:00
Irmen de Jong	992732f2cb	bmx support to save partial screens ('stamps')	2023-11-30 22:17:57 +01:00
Irmen de Jong	b58a3ba1bb	added cx16 sprites.move , movex and movey routines to move sprite by deltas	2023-11-30 20:49:47 +01:00
Irmen de Jong	afe521b0c9	simplify bmx loading	2023-11-29 21:57:17 +01:00
Irmen de Jong	5d9caef45f	bmx can load "stamps"	2023-11-29 21:07:22 +01:00
Irmen de Jong	278e2f5605	preparing for working kernal FP VAL_1() call	2023-11-29 00:27:02 +01:00
Irmen de Jong	1e299bf360	better pokef() code	2023-11-28 23:04:27 +01:00
Irmen de Jong	8dfa0bc38c	fix a compiler crash in certain vardecl initialization expressions	2023-11-28 21:01:58 +01:00
Irmen de Jong	fde136fb7b	bmx module only supports 320 or 640 image widths for now	2023-11-28 20:38:52 +01:00
Irmen de Jong	ee4da1a757	fix floats.parse_f() to use new kernal routine address for VAL gives error message if it detects issues f.ex. with new kernal version that moves the routine	2023-11-27 23:58:28 +01:00
Irmen de Jong	ae2d96c455	added `peekf` and `pokef` builtin functions. Fixed sizeof() to allow number argument as well.	2023-11-27 23:36:02 +01:00
Irmen de Jong	6d8fbe0877	fixed float array indexing with an expression	2023-11-27 20:54:49 +01:00
Irmen de Jong	2fa1d8f2e8	fix vm string hash	2023-11-27 01:27:50 +01:00
Irmen de Jong	533090a68e	fix expression result register of square, callfar, string compare functions in certain situations	2023-11-26 23:02:10 +01:00
Irmen de Jong	1dff59e1d6	added string.hash()	2023-11-26 22:14:08 +01:00
Irmen de Jong	44d232f52a	optimize for x in something downto 0	2023-11-26 02:24:18 +01:00
Irmen de Jong	5f6cff739a	fix bmx palette writing from buffer	2023-11-26 01:50:25 +01:00
Irmen de Jong	2764d235a9	optimizing for x in 0 to something	2023-11-25 21:37:27 +01:00
Irmen de Jong	45debff89f	bmx: allow palette to be loaded into memory buffer instead of vram	2023-11-25 17:58:43 +01:00
Irmen de Jong	c45fbe6310	continue stmt added	2023-11-25 01:14:35 +01:00
Irmen de Jong	9ef9c24388	IR: optimize redundant labels	2023-11-25 01:10:17 +01:00
Irmen de Jong	6a40f23578	cx16: added bmx library module and showbmx example	2023-11-24 23:39:05 +01:00
Irmen de Jong	6a0a6b4751	todo	2023-11-24 01:20:10 +01:00
Irmen de Jong	0bee6f6b41	cx16: reorder processing of IRQ handlers	2023-11-24 01:12:27 +01:00
Irmen de Jong	82a15b5a16	65C02 cpu: use TRB and TSB instructions for in-place AND/OR.	2023-11-24 00:50:52 +01:00
Irmen de Jong	11b7c4459e	omission	2023-11-23 00:29:31 +01:00
Irmen de Jong	98570ac456	cx16: optimized sys.set_rasterline()	2023-11-23 00:02:04 +01:00
Irmen de Jong	1b2296ad5b	move cx16 irq examples to new API, fix some bugs in the handler	2023-11-22 23:25:39 +01:00
Irmen de Jong	16851746d6	new X16 irq handler routines and examples	2023-11-22 20:03:21 +01:00
Irmen de Jong	935450a45f	update kotest library	2023-11-22 18:40:07 +01:00
Irmen de Jong	ba67fd318b	renamed cx16.VERA_IRQ_LINE_L to VERA_IRQLINE_L and added VERA_SCANLINE_L, to align with official register naming. Also added a multi-irq example for the X16 to show the updated irq handler semantics.	2023-11-22 18:36:24 +01:00
Irmen de Jong	08ac459a41	breaking change: sys.set_irq() and sys.set_rasterirq() no longer have useKernal parameter! The irq handler routine must return a boolean instead in the A register. When it returns true it means run the system IRQ handler afterwards. When it returns false, the system handler is NOT ran afterwards.	2023-11-21 23:22:53 +01:00
Irmen de Jong	a83e9d9a0a	added sys.save_prog8_internals() and restore_prog8_internals()	2023-11-21 22:00:43 +01:00
Irmen de Jong	62d3f01948	fix name check in inline asm this no longer removes a subroutine that is otherwise only called from inlined asm.	2023-11-21 01:26:50 +01:00
Irmen de Jong	af5ca2d0b8	vm: treat floats as 64 bits doubles. 0.0 printed as "0".	2023-11-21 00:57:56 +01:00
Irmen de Jong	ab4bcdf12d	emudbg no longer clobbers r1	2023-11-20 00:20:48 +01:00
Irmen de Jong	a6756d2cea	removed diskio.set_drive(), just set the diskio.drivenumber variable directly there already wasn't a getter	2023-11-19 22:15:56 +01:00
Irmen de Jong	f81061dd42	error msg and comments	2023-11-18 01:03:34 +01:00
Irmen de Jong	8e2c304b3c	txt.waitkey() now returns the key that was pressed	2023-11-17 20:31:19 +01:00
Irmen de Jong	f21adaa3ef	fix compiler error caused by removal of string symbol in txt.print() optimization	2023-11-17 19:51:48 +01:00
Irmen de Jong	2637939e62	cx16.vaddr_clone now leaves vera CTRL selected port intact	2023-11-17 19:22:23 +01:00
Irmen de Jong	faf05582f8	improved cx16 emudbg library	2023-11-17 15:07:21 +01:00
Irmen de Jong	161c02ced3	message	2023-11-17 00:37:12 +01:00
Irmen de Jong	ff8de8e42d	removing redundant compares	2023-11-16 22:56:19 +01:00
Irmen de Jong	09d506194f	note	2023-11-15 22:27:16 +01:00
Irmen de Jong	42db3085df	improve the way %option merge works, you can now merge your own code with library code for instance.	2023-11-14 23:04:13 +01:00
Irmen de Jong	ad14c88fde	give error when using %option merge in module scope	2023-11-14 21:53:50 +01:00
Irmen de Jong	0c9daf6eaf	fix compiler crash on ptrvar[n+1] = ptrvar[2]	2023-11-14 21:46:11 +01:00
Irmen de Jong	86c6530e46	palette: more accurate color conversion from 8 to 4 bits channels set_rgb8(), color8to4(), channel8to4()	2023-11-14 20:40:48 +01:00
Irmen de Jong	159f80d629	next version	2023-11-14 19:06:47 +01:00
Irmen de Jong	aa949165c7	diskio.f_open_w() error handling back to what it was before Otherwise it eats the status message. Added comment that you have to check this manually to be sure if the call succeeded or not!	2023-11-12 21:14:06 +01:00
Irmen de Jong	d22359b6e7	removed cx16.FB_cursor_position2() because it was only for use in the graphics module	2023-11-12 16:40:13 +01:00
Irmen de Jong	d73709653d	remove unused interned strings in the resulting code (for example from removed if/else blocks)	2023-11-12 05:28:24 +01:00
Irmen de Jong	405926e811	oops	2023-11-11 14:31:48 +01:00
Irmen de Jong	36758f41a4	fixed diskio.f_open_w() error handling, finally added f_seek_w() to be able to seek in files for writing.	2023-11-11 14:26:40 +01:00
Irmen de Jong	7ebc9c79cf	added string.append() cleanup redundant diskio prefixes	2023-11-10 23:53:59 +01:00
Irmen de Jong	e0668b55b9	fix gfx2 safe_disc coloring	2023-11-10 01:08:13 +01:00
Irmen de Jong	76c09da961	make pokemon() be like poke, but also return the old value in the memory location.	2023-11-09 22:48:44 +01:00
Irmen de Jong	7e3b8c2c59	fix compiler crash on certain subroutine inlining attempts.	2023-11-09 21:16:12 +01:00
Irmen de Jong	ecca854c7c	Added cx16.edkeyvec and cx16.set_chrin_keyhandler(). mention the Github actions builds.	2023-11-09 01:03:31 +01:00
Irmen de Jong	3b0d7ea960	better const-evaluation of addressOf a memory mapped variable	2023-11-08 22:04:41 +01:00
Irmen de Jong	f70fa42eac	more accurate palette conversion	2023-11-08 01:33:55 +01:00
markjreed	5698de6cf4	feat: requirements.txt for convertsprite.py (#112 )	2023-11-08 01:32:41 +01:00
Irmen de Jong	c5a333a904	CX16: diskio.f_write() now uses fast MCIOUT block writes, including hiram bank boundary wrap-over	2023-11-08 01:12:49 +01:00
markjreed	ff324955dd	Feature/read cursor position (#111 ) * feat: add ability to read cursor position on CBM machines * feat: implement plot()/column() for atari target; add get_cursor(), get_column(), row(), and get_row() * feat: implement wait_key() for Commodore targets; add get_cursor(), get_column(), row(), get_row() * feat: really implement waitkey() on CBM targets * fix: make waitkey void for compatibility with atari	2023-11-07 22:19:16 +01:00
Irmen de Jong	70436f5dca	cx16.vpeek() use VERA_DATA0 instead of 1, to not cause ADDRSEL to be != 0 (interferes with kernal)	2023-11-07 22:09:53 +01:00
Irmen de Jong	31177a2b1b	added sys.disable_caseswitch() and sys.enable_caseswitch()	2023-11-07 00:27:34 +01:00
Irmen de Jong	4de012fc49	added notes to textio about PETSCII vs Screencode encoding.	2023-11-06 23:18:24 +01:00
Irmen de Jong	ee2888e744	verafx.mult/muls now return upper 16 bits of the result in r0	2023-11-06 21:55:58 +01:00
Irmen de Jong	efe4df92dc	optimize when with const value (remove other choices from code)	2023-11-06 00:08:07 +01:00
Irmen de Jong	723ab54f97	optimized all circle routines a little more. Added gfx2/monogfx safe_circle and safe_disc. Warning for when on const value.	2023-11-05 21:29:59 +01:00
Irmen de Jong	d9389afc66	fix compiler crash on certain constant expressions	2023-11-05 13:59:08 +01:00
Irmen de Jong	e7178ee496	optimized comparison with word variables	2023-11-05 00:20:12 +01:00
Irmen de Jong	d5f35bb3fb	added gfx2.init_mode()	2023-11-04 14:53:08 +01:00
Irmen de Jong	72f1a779f2	optimize monogfx.fill() and gfx2.fill(), also don't read outside screen area	2023-11-04 14:30:51 +01:00
Irmen de Jong	3277544295	optimize assigning word array value to byte variable	2023-11-04 00:33:50 +01:00
Irmen de Jong	98d2c64d5d	fix assembly error for uword[3] @zp @split word_addrs	2023-11-03 00:39:43 +01:00
Irmen de Jong	f68b46fc60	add a %zpallowed option to specify the range of zeropage register that can be used	2023-11-03 00:19:25 +01:00
Irmen de Jong	d54ab856e7	fix parameter passing bug introduced recently (byte not converted to word)	2023-11-02 00:31:35 +01:00
Irmen de Jong	16b24fadea	gfx2 future mode, upgrate to Kotlin 1.9.20	2023-11-01 23:18:44 +01:00
Irmen de Jong	b3803cbdf1	more opportunities to use LDA(zp) instead of LDA(zp),Y on 65c02	2023-10-31 21:26:55 +01:00
Irmen de Jong	2ceaa25181	optimized code for (infrequently used) logical operations on word array	2023-10-29 23:41:34 +01:00
Irmen de Jong	513611c5a6	IR: using EXT more	2023-10-29 02:57:21 +01:00
Irmen de Jong	7ec4ba40ad	optimize asmsub arg evaluation order and stack usage	2023-10-28 17:29:00 +02:00
Irmen de Jong	92374e122b	IR: optimize concat with msb 0 into ext	2023-10-28 12:53:41 +02:00
Irmen de Jong	94f12732ab	add math.diff() and math.diffw()	2023-10-27 22:36:43 +02:00
Irmen de Jong	0904712a00	remove last trace of getTempVar (arry index expression) tiny optimization	2023-10-27 21:41:52 +02:00
Irmen de Jong	32becdbced	add monogfx lib to virtual target	2023-10-24 00:16:25 +02:00
Irmen de Jong	34aa21f7d9	improve function call arg type casting	2023-10-22 22:33:35 +02:00
Irmen de Jong	cc81dd7d3e	remove useless close calls from diskio load	2023-10-22 17:24:05 +02:00
Irmen de Jong	335213b55f	tweaks	2023-10-21 02:16:58 +02:00
Irmen de Jong	13ab4166c0	new kotest library version	2023-10-19 21:57:06 +02:00
Irmen de Jong	3dc5a0e7f8	some arrays can be in BSS	2023-10-18 23:59:37 +02:00
Irmen de Jong	e15c5cde53	tiny fill() optimization	2023-10-18 23:11:16 +02:00
Irmen de Jong	d88c09b098	fix signed byte to word casting issue uw = 8888 + (bb as ubyte)	2023-10-17 22:54:33 +02:00
Irmen de Jong	893b383bdf	fix signed byte to word sign extension in assignment	2023-10-17 03:08:37 +02:00
Irmen de Jong	dd7c9d62e6	remove assigment splitter, it now caused code bloat instead of more efficient code	2023-10-16 02:07:22 +02:00
Irmen de Jong	97c5c90eff	fix codegen for var1>>=var2 and var1<<=var2 when var2 is zero	2023-10-16 00:04:21 +02:00
Irmen de Jong	1fb94e7a7b	monogfx and gfx2: flood fill uses optimized horizontal line drawing	2023-10-15 23:19:11 +02:00
Irmen de Jong	daca87c6d0	added -breakinstr compiler option	2023-10-15 21:55:09 +02:00
Irmen de Jong	203ec5fa46	implement taking address of array var with variable index	2023-10-15 20:24:48 +02:00
Irmen de Jong	9ea69c07b8	optimize word array reads with indexvar	2023-10-14 07:30:54 +02:00
Irmen de Jong	68539d6cc9	micro tweaks adpcm.p8	2023-10-13 00:55:56 +02:00