'amiga' example using iso font

to fix the bugs resulting from nesting subroutine calls (as param to another call etc)

.idea/kotlinc.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Kotlin2JvmCompilerArguments">
+    <option name="jvmTarget" value="11" />
+  </component>
+  <component name="KotlinJpsPluginSettings">
+    <option name="version" value="1.8.20-release-327" />
+  </component>
+</project>

.idea/libraries/antlr_antlr4.xml

@@ -1,17 +1,16 @@
 <component name="libraryTable">
   <library name="antlr.antlr4" type="repository">
-    <properties maven-id="org.antlr:antlr4:4.11.1">
+    <properties maven-id="org.antlr:antlr4:4.12.0">
       <exclude>
         <dependency maven-id="com.ibm.icu:icu4j" />
       </exclude>
     </properties>
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.11.1/antlr4-4.11.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.11.1/antlr4-runtime-4.11.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.12.0/antlr4-4.12.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.12.0/antlr4-runtime-4.12.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr-runtime/3.5.3/antlr-runtime-3.5.3.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/antlr/ST4/4.3.4/ST4-4.3.4.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/abego/treelayout/org.abego.treelayout.core/1.0.3/org.abego.treelayout.core-1.0.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/glassfish/javax.json/1.1.4/javax.json-1.1.4.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/github_hypfvieh_dbus_java.xml

@@ -1,23 +1,23 @@
 <component name="libraryTable">
   <library name="github.hypfvieh.dbus.java" type="repository">
-    <properties maven-id="com.github.hypfvieh:dbus-java:3.3.1" />
+    <properties maven-id="com.github.hypfvieh:dbus-java:3.3.2" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/hypfvieh/dbus-java/3.3.1/dbus-java-3.3.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-unixsocket/0.38.6/jnr-unixsocket-0.38.6.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-ffi/2.2.2/jnr-ffi-2.2.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jffi/1.3.1/jffi-1.3.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jffi/1.3.1/jffi-1.3.1-native.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm/9.1/asm-9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm-commons/9.1/asm-commons-9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm-analysis/9.1/asm-analysis-9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm-tree/9.1/asm-tree-9.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm-util/9.1/asm-util-9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/hypfvieh/dbus-java/3.3.2/dbus-java-3.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-unixsocket/0.38.17/jnr-unixsocket-0.38.17.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-ffi/2.2.11/jnr-ffi-2.2.11.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jffi/1.3.9/jffi-1.3.9.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jffi/1.3.9/jffi-1.3.9-native.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm/9.2/asm-9.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm-commons/9.2/asm-commons-9.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm-analysis/9.2/asm-analysis-9.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm-tree/9.2/asm-tree-9.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/ow2/asm/asm-util/9.2/asm-util-9.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-a64asm/1.0.0/jnr-a64asm-1.0.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-x86asm/1.0.2/jnr-x86asm-1.0.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-constants/0.10.1/jnr-constants-0.10.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-enxio/0.32.4/jnr-enxio-0.32.4.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-posix/3.1.5/jnr-posix-3.1.5.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-api/1.7.30/slf4j-api-1.7.30.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-constants/0.10.3/jnr-constants-0.10.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-enxio/0.32.13/jnr-enxio-0.32.13.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/jnr/jnr-posix/3.1.15/jnr-posix-3.1.15.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-api/1.7.36/slf4j-api-1.7.36.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/io_kotest_assertions_core_jvm.xml

@@ -1,21 +1,21 @@
 <component name="libraryTable">
   <library name="io.kotest.assertions.core.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.3.2" />
+    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.5.5" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.3.2/kotest-assertions-core-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.5.5/kotest-assertions-core-jvm-5.5.5.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.21/kotlin-stdlib-jdk8-1.6.21.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.21/kotlin-stdlib-1.6.21.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.6.21/kotlin-stdlib-jdk7-1.6.21.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.3.2/kotest-assertions-shared-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.5.5/kotest-assertions-shared-jvm-5.5.5.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/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.1/kotlinx-coroutines-jdk8-1.6.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.21/kotlin-stdlib-common-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.4/kotlinx-coroutines-jdk8-1.6.4.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.21/kotlin-reflect-1.6.21.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.1/kotlinx-coroutines-core-jvm-1.6.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.3.2/kotest-common-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.3.2/kotest-assertions-api-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.5.5/kotest-common-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.5.5/kotest-assertions-api-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.4/kotlinx-coroutines-core-jvm-1.6.4.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/io_kotest_property_jvm.xml

@@ -1,22 +1,22 @@
 <component name="libraryTable">
   <library name="io.kotest.property.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-property-jvm:5.3.2" />
+    <properties maven-id="io.kotest:kotest-property-jvm:5.5.5" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-property-jvm/5.3.2/kotest-property-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/curious-odd-man/rgxgen/1.3/rgxgen-1.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-property-jvm/5.5.5/kotest-property-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.5.5/kotest-common-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.5.5/kotest-assertions-shared-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.5.5/kotest-assertions-api-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.4/kotlinx-coroutines-jdk8-1.6.4.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.21/kotlin-stdlib-common-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/curious-odd-man/rgxgen/1.4/rgxgen-1.4.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.21/kotlin-stdlib-jdk8-1.6.21.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.21/kotlin-stdlib-1.6.21.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.6.21/kotlin-stdlib-jdk7-1.6.21.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.3.2/kotest-common-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.3.2/kotest-assertions-shared-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.3.2/kotest-assertions-api-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.1/kotlinx-coroutines-jdk8-1.6.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.21/kotlin-reflect-1.6.21.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.1/kotlinx-coroutines-core-jvm-1.6.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.4/kotlinx-coroutines-core-jvm-1.6.4.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/io_kotest_runner_junit5_jvm.xml

@@ -1,46 +1,50 @@
 <component name="libraryTable">
   <library name="io.kotest.runner.junit5.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.3.2" />
+    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.5.5" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.3.2/kotest-runner-junit5-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.3.2/kotest-framework-api-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.3.2/kotest-assertions-shared-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.6.1/kotlinx-coroutines-test-jvm-1.6.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.3.2/kotest-common-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.3.2/kotest-framework-engine-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.146/classgraph-4.8.146.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.5.5/kotest-runner-junit5-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.5.5/kotest-framework-api-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.6.4/kotlinx-coroutines-test-jvm-1.6.4.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.5.5/kotest-assertions-shared-jvm-5.5.5.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/kotlin/kotlin-stdlib-common/1.6.21/kotlin-stdlib-common-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.5.5/kotest-common-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.5.5/kotest-framework-engine-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.154/classgraph-4.8.154.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/jetbrains/kotlinx/kotlinx-coroutines-debug/1.6.1/kotlinx-coroutines-debug-1.6.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.6.4/kotlinx-coroutines-debug-1.6.4.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$/io/kotest/kotest-framework-discovery-jvm/5.3.2/kotest-framework-discovery-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.3.2/kotest-assertions-core-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.1/kotlinx-coroutines-jdk8-1.6.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.3.2/kotest-assertions-api-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.3.2/kotest-extensions-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/commons-io/commons-io/2.11.0/commons-io-2.11.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk/1.12.3/mockk-1.12.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-common/1.12.3/mockk-common-1.12.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl/1.12.3/mockk-dsl-1.12.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl-jvm/1.12.3/mockk-dsl-jvm-1.12.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-jvm/1.12.3/mockk-agent-jvm-1.12.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-api/1.12.3/mockk-agent-api-1.12.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-common/1.12.3/mockk-agent-common-1.12.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/objenesis/objenesis/3.1/objenesis-3.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.12.6/byte-buddy-1.12.6.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.12.6/byte-buddy-agent-1.12.6.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.3.2/kotest-framework-concurrency-jvm-5.3.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.1/kotlinx-coroutines-core-jvm-1.6.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.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.5.5/kotest-framework-discovery-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.5.5/kotest-assertions-core-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.4/kotlinx-coroutines-jdk8-1.6.4.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.5.5/kotest-assertions-api-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.5.5/kotest-extensions-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-jvm/1.13.1/mockk-jvm-1.13.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl-jvm/1.13.1/mockk-dsl-jvm-1.13.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-jvm/1.13.1/mockk-agent-jvm-1.13.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/objenesis/objenesis/3.2/objenesis-3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-api-jvm/1.13.1/mockk-agent-api-jvm-1.13.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-core-jvm/1.13.1/mockk-core-jvm-1.13.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-api/1.7.36/slf4j-api-1.7.36.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.13.2/junit-4.13.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter/5.8.2/junit-jupiter-5.8.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-params/5.8.2/junit-jupiter-params-5.8.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-engine/5.8.2/junit-jupiter-engine-5.8.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core/1.6.4/kotlinx-coroutines-core-1.6.4.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.5.5/kotest-framework-concurrency-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.4/kotlinx-coroutines-core-jvm-1.6.4.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.7.2/junit-platform-engine-1.7.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.0/apiguardian-api-1.1.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.7.2/junit-platform-commons-1.7.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-suite-api/1.7.2/junit-platform-suite-api-1.7.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-launcher/1.7.2/junit-platform-launcher-1.7.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.7.2/junit-jupiter-api-5.7.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.2/junit-jupiter-api-5.8.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.21/kotlin-stdlib-jdk8-1.6.21.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.21/kotlin-stdlib-1.6.21.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />

.idea/libraries/jetbrains_kotlinx_cli_jvm.xml

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

.idea/libraries/slf4j_simple.xml

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

.idea/libraries/takes.xml

@@ -1,15 +1,16 @@
 <component name="libraryTable">
   <library name="takes" type="repository">
-    <properties maven-id="org.takes:takes:1.20" />
+    <properties maven-id="org.takes:takes:1.24.4" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/takes/takes/1.20/takes-1.20.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/cactoos/cactoos/0.50/cactoos-0.50.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/javax/xml/bind/jaxb-api/2.3.0/jaxb-api-2.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-api/1.7.25/slf4j-api-1.7.25.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/apache/commons/commons-text/1.4/commons-text-1.4.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/apache/commons/commons-lang3/3.7/commons-lang3-3.7.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/sun/xml/bind/jaxb-core/2.3.0/jaxb-core-2.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/sun/xml/bind/jaxb-impl/2.3.0/jaxb-impl-2.3.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/takes/takes/1.24.4/takes-1.24.4.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/cactoos/cactoos/0.54.0/cactoos-0.54.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/javax/xml/bind/jaxb-api/2.4.0-b180830.0359/jaxb-api-2.4.0-b180830.0359.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/javax/activation/javax.activation-api/1.2.0/javax.activation-api-1.2.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/sun/xml/bind/jaxb-core/4.0.0/jaxb-core-4.0.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/jakarta/xml/bind/jakarta.xml.bind-api/4.0.0/jakarta.xml.bind-api-4.0.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/jakarta/activation/jakarta.activation-api/2.1.0/jakarta.activation-api-2.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/eclipse/angus/angus-activation/1.0.0/angus-activation-1.0.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/sun/xml/bind/jaxb-impl/4.0.0/jaxb-impl-4.0.0.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.readthedocs.yaml

@@ -7,13 +7,9 @@ version: 2
 
 # Set the version of Python and other tools you might need
 build:
-  os: ubuntu-20.04
+  os: ubuntu-22.04
   tools:
-    python: "3.9"
-    # You can also specify other tool versions:
-    # nodejs: "16"
-    # rust: "1.55"
-    # golang: "1.17"
+    python: "3.11"
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:

README.md

@@ -76,7 +76,9 @@ IntelliJ IDEA with the Kotlin plugin).
 
 It's handy to have an emulator (or a real machine perhaps!) to run the programs on. The compiler assumes the presence
 of the [Vice emulator](http://vice-emu.sourceforge.net/)  for the C64 target,
-and the [x16emu emulator](https://github.com/commanderx16/x16-emulator) for the CommanderX16 target.
+and a recent emulator version (R42 or newer) for the CommanderX16, such as [x16emu](https://cx16forum.com/forum/viewforum.php?f=30) 
+(preferred, this is the official emulator. If required, source code is [here](https://github.com/X16Community/x16-emulator/)).
+There is also [Box16](https://github.com/indigodarkwolf/box16) which has powerful debugging features.
 
 **Syntax highlighting:** for a few different editors, syntax highlighting definition files are provided.
 Look in the [syntax-files](https://github.com/irmen/prog8/tree/master/syntax-files) directory in the github repository to find them.

codeCore/src/prog8/code/SymbolTable.kt

@@ -15,14 +15,26 @@ class SymbolTable(astProgram: PtProgram) : StNode(astProgram.name, StNodeType.GL
      * This gives the fastest lookup possible (no need to traverse tree nodes)
      */
 
-    val flat: Map<String, StNode> by lazy {
+    private var cachedFlat: Map<String, StNode>? = null
+
+    val flat: Map<String, StNode> get()  {
+        if(cachedFlat!=null)
+            return cachedFlat!!
+
         val result = mutableMapOf<String, StNode>()
-        fun flatten(node: StNode) {
-            result[node.scopedName] = node
-            node.children.values.forEach { flatten(it) }
+        fun collect(node: StNode) {
+            for(child in node.children) {
+                result[child.value.scopedName] = child.value
+                collect(child.value)
+            }
         }
-        children.values.forEach { flatten(it) }
-        result
+        collect(this)
+        cachedFlat = result
+        return result
+    }
+
+    fun resetCachedFlat() {
+        cachedFlat = null
     }
 
     val allVariables: Collection<StStaticVariable> by lazy {
@@ -133,7 +145,7 @@ open class StNode(val name: String,
     }
 
     private val scopedNameList: List<String> by lazy {
-        if(type== StNodeType.GLOBAL)
+        if(type==StNodeType.GLOBAL)
             emptyList()
         else
             parent.scopedNameList + name
@@ -142,7 +154,7 @@ open class StNode(val name: String,
     private fun lookup(scopedName: List<String>): StNode? {
         // a scoped name refers to a name in another namespace, and always stars from the root.
         var node = this
-        while(node.type!= StNodeType.GLOBAL)
+        while(node.type!=StNodeType.GLOBAL)
             node = node.parent
 
         for(name in scopedName) {
@@ -201,6 +213,11 @@ class StMemVar(name: String,
                val length: Int?,             // for arrays: the number of elements, for strings: number of characters *including* the terminating 0-byte
                astNode: PtNode) :
     StNode(name, StNodeType.MEMVAR, astNode) {
+
+    init{
+        if(dt in ArrayDatatypes || dt == DataType.STR)
+            require(length!=null) { "memory mapped array or string must have known length" }
+    }
 }
 
 class StMemorySlab(
@@ -218,7 +235,7 @@ class StSub(name: String, val parameters: List<StSubroutineParameter>, val retur
 
 
 class StRomSub(name: String,
-               val address: UInt,
+               val address: UInt?,      // null in case of asmsub, specified in case of romsub
                val parameters: List<StRomSubParameter>,
                val returns: List<StRomSubParameter>,
                astNode: PtNode) :

codeCore/src/prog8/code/SymbolTableMaker.kt

@@ -26,11 +26,11 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
                 PtMemMapped("P8ZP_SCRATCH_REG", DataType.UBYTE, options.compTarget.machine.zeropage.SCRATCH_REG, null, Position.DUMMY),
                 PtMemMapped("P8ZP_SCRATCH_W1", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W1, null, Position.DUMMY),
                 PtMemMapped("P8ZP_SCRATCH_W2", DataType.UWORD, options.compTarget.machine.zeropage.SCRATCH_W2, null, Position.DUMMY),
-                PtMemMapped("P8ESTACK_LO", DataType.ARRAY_UB, options.compTarget.machine.ESTACK_LO, 256u, Position.DUMMY),
-                PtMemMapped("P8ESTACK_HI", DataType.ARRAY_UB, options.compTarget.machine.ESTACK_HI, 256u, Position.DUMMY)
+                PtMemMapped("P8ESTACK_LO", DataType.ARRAY_UB, options.compTarget.machine.ESTACK_LO, 128u, Position.DUMMY),
+                PtMemMapped("P8ESTACK_HI", DataType.ARRAY_UB, options.compTarget.machine.ESTACK_HI, 128u, Position.DUMMY)
             ).forEach {
                 it.parent = program
-                st.add(StMemVar(it.name, it.type, it.address, null, it))
+                st.add(StMemVar(it.name, it.type, it.address, it.arraySize?.toInt(), it))
             }
         }
 
@@ -40,14 +40,9 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
     private fun addToSt(node: PtNode, scope: Stack<StNode>) {
         val stNode = when(node) {
             is PtAsmSub -> {
-                if(node.address==null) {
-                    val params = node.parameters.map { StSubroutineParameter(it.second.name, it.second.type) }
-                    StSub(node.name, params, node.returns.singleOrNull()?.second, node)
-                } else {
-                    val parameters = node.parameters.map { StRomSubParameter(it.first, it.second.type) }
-                    val returns = node.returns.map { StRomSubParameter(it.first, it.second) }
-                    StRomSub(node.name, node.address, parameters, returns, node)
-                }
+                val parameters = node.parameters.map { StRomSubParameter(it.first, it.second.type) }
+                val returns = node.returns.map { StRomSubParameter(it.first, it.second) }
+                StRomSub(node.name, node.address, parameters, returns, node)
             }
             is PtBlock -> {
                 StNode(node.name, StNodeType.BLOCK, node)

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

@@ -63,7 +63,7 @@ class PtProgram(
         children.asSequence().filterIsInstance<PtBlock>()
 
     fun entrypoint(): PtSub? =
-        allBlocks().firstOrNull { it.name == "main" }?.children?.firstOrNull { it is PtSub && it.name == "start" } as PtSub?
+        allBlocks().firstOrNull { it.name == "main" }?.children?.firstOrNull { it is PtSub && (it.name == "start" || it.name=="main.start") } as PtSub?
 }
 
 

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

@@ -1,6 +1,9 @@
 package prog8.code.ast
 
-import prog8.code.core.*
+import prog8.code.core.DataType
+import prog8.code.core.Encoding
+import prog8.code.core.NumericDatatypes
+import prog8.code.core.Position
 import java.util.*
 import kotlin.math.abs
 import kotlin.math.round
@@ -180,7 +183,13 @@ class PtFunctionCall(val name: String,
 }
 
 
-class PtIdentifier(val name: String, type: DataType, position: Position) : PtExpression(type, position)
+class PtIdentifier(val name: String, type: DataType, position: Position) : PtExpression(type, position) {
+    override fun toString(): String {
+        return "[PtIdentifier:$name $type $position]"
+    }
+
+    fun copy() = PtIdentifier(name, type, position)
+}
 
 
 class PtMemoryByte(position: Position) : PtExpression(DataType.UBYTE, position) {
@@ -215,6 +224,8 @@ class PtNumber(type: DataType, val number: Double, position: Position) : PtExpre
     }
 
     operator fun compareTo(other: PtNumber): Int = number.compareTo(other.number)
+
+    override fun toString() = "PtNumber:$type:$number"
 }
 
 

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

@@ -6,7 +6,7 @@ import prog8.code.core.*
  * Produces readable text from a [PtNode] (AST node, usually starting with PtProgram as root),
  * passing it as a String to the specified receiver function.
  */
-fun printAst(root: PtNode, output: (text: String) -> Unit) {
+fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Unit) {
     fun type(dt: DataType) = "!${dt.name.lowercase()}!"
     fun txt(node: PtNode): String {
         return when(node) {
@@ -134,16 +134,22 @@ fun printAst(root: PtNode, output: (text: String) -> Unit) {
         root.children.forEach {
             walkAst(it) { node, depth ->
                 val txt = txt(node)
-                if(txt.isNotEmpty())
-                    output("    ".repeat(depth) + txt(node))
+                val library = if(node is PtBlock) node.library else node.definingBlock()?.library==true
+                if(!library || !skipLibraries) {
+                    if (txt.isNotEmpty())
+                        output("    ".repeat(depth) + txt(node))
+                }
             }
         }
         println()
     } else {
         walkAst(root) { node, depth ->
             val txt = txt(node)
-            if(txt.isNotEmpty())
-                output("    ".repeat(depth) + txt(node))
+            val library = if(node is PtBlock) node.library else node.definingBlock()?.library==true
+            if(!library || !skipLibraries) {
+                if (txt.isNotEmpty())
+                    output("    ".repeat(depth) + txt(node))
+            }
         }
     }
 }

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

@@ -38,25 +38,17 @@ class PtSub(
 class PtSubroutineParameter(name: String, val type: DataType, position: Position): PtNamedNode(name, position)
 
 
-class PtAssignment(position: Position) : PtNode(position) {
+sealed interface IPtAssignment {
+    val children: MutableList<PtNode>
     val target: PtAssignTarget
         get() = children[0] as PtAssignTarget
     val value: PtExpression
         get() = children[1] as PtExpression
 }
 
+class PtAssignment(position: Position) : PtNode(position), IPtAssignment
 
-class PtAugmentedAssign(val operator: String, position: Position) : PtNode(position) {
-    val target: PtAssignTarget
-        get() = children[0] as PtAssignTarget
-    val value: PtExpression
-        get() = children[1] as PtExpression
-    init {
-        require(operator.endsWith('=') || operator in PrefixOperators) {
-            "invalid augmented assign operator $operator"
-        }
-    }
-}
+class PtAugmentedAssign(val operator: String, position: Position) : PtNode(position), IPtAssignment
 
 
 class PtAssignTarget(position: Position) : PtNode(position) {
@@ -100,8 +92,8 @@ class PtForLoop(position: Position) : PtNode(position) {
 
 
 class PtIfElse(position: Position) : PtNode(position) {
-    val condition: PtBinaryExpression
-        get() = children[0] as PtBinaryExpression
+    val condition: PtExpression
+        get() = children[0] as PtExpression
     val ifScope: PtNodeGroup
         get() = children[1] as PtNodeGroup
     val elseScope: PtNodeGroup

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

@@ -79,12 +79,15 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     "reverse"   to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
     // cmp returns a status in the carry flag, but not a proper return value
     "cmp"       to FSignature(false, listOf(FParam("value1", IntegerDatatypesNoBool), FParam("value2", NumericDatatypesNoBool)), null),
+    "prog8_lib_stringcompare"       to FSignature(true, listOf(FParam("str1", arrayOf(DataType.STR)), FParam("str2", arrayOf(DataType.STR))), DataType.BYTE),
     "abs"       to FSignature(true, listOf(FParam("value", IntegerDatatypesNoBool)), DataType.UWORD),
     "len"       to FSignature(true, listOf(FParam("values", IterableDatatypes)), DataType.UWORD),
     // normal functions follow:
     "sizeof"    to FSignature(true, listOf(FParam("object", DataType.values())), DataType.UBYTE),
     "sgn"       to FSignature(true, listOf(FParam("value", NumericDatatypesNoBool)), DataType.BYTE),
     "sqrt16"    to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD))), DataType.UBYTE),
+    "divmod"    to FSignature(false, listOf(FParam("number", arrayOf(DataType.UBYTE)), FParam("divident", arrayOf(DataType.UBYTE)), FParam("division", arrayOf(DataType.UBYTE)), FParam("remainder", arrayOf(DataType.UBYTE))), null),
+    "divmodw"   to FSignature(false, listOf(FParam("number", arrayOf(DataType.UWORD)), FParam("divident", arrayOf(DataType.UWORD)), FParam("division", arrayOf(DataType.UWORD)), FParam("remainder", arrayOf(DataType.UWORD))), null),
     "any"       to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE),
     "all"       to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE),
     "lsb"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE),

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

@@ -20,6 +20,7 @@ class CompilationOptions(val output: OutputType,
                          var asmListfile: Boolean = false,
                          var experimentalCodegen: Boolean = false,
                          var varsHigh: Boolean = false,
+                         var useNewExprCode: Boolean = false,
                          var evalStackBaseAddress: UInt? = null,
                          var outputDir: Path = Path(""),
                          var symbolDefs: Map<String, String> = emptyMap()

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

@@ -13,7 +13,5 @@ interface ICodeGeneratorBackend {
 
 interface IAssemblyProgram {
     val name: String
-    fun assemble(options: CompilationOptions): Boolean
+    fun assemble(options: CompilationOptions, errors: IErrorReporter): Boolean
 }
-
-fun viceMonListName(baseFilename: String) = "$baseFilename.vice-mon-list"

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

@@ -131,6 +131,7 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
 }
 
 
+// TODO: this class is not yet used
 class GoldenRam(options: CompilationOptions, val region: UIntRange): MemoryAllocator(options) {
     private var nextLocation: UInt = region.first
 

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

@@ -1,5 +1,6 @@
 package prog8.code.core
 
+import prog8.code.core.SourceCode.Companion.libraryFilePrefix
 import java.nio.file.InvalidPathException
 import kotlin.io.path.Path
 import kotlin.io.path.absolute
@@ -7,6 +8,10 @@ import kotlin.io.path.absolute
 data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
     override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
     fun toClickableStr(): String {
+        if(this===DUMMY)
+            return ""
+        if(file.startsWith(libraryFilePrefix))
+            return "$file:$line:$startCol:"
         return try {
             val path = Path(file).absolute().normalize().toString()
             "file://$path:$line:$startCol:"

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

@@ -16,5 +16,7 @@ class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by Cb
 
     companion object {
         const val NAME = "c64"
+
+        fun viceMonListName(baseFilename: String) = "$baseFilename.vice-mon-list"
     }
 }

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

@@ -23,7 +23,7 @@ class AtariMachineDefinition: IMachineDefinition {
     override lateinit var zeropage: Zeropage
     override lateinit var golden: GoldenRam
 
-    override fun getFloatAsmBytes(num: Number) = TODO("float asm bytes from number")
+    override fun getFloatAsmBytes(num: Number) = TODO("atari float asm bytes from number")
 
     override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
         return if (compilerOptions.output == OutputType.XEX)

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

@@ -13,6 +13,10 @@ class AtariZeropage(options: CompilationOptions) : Zeropage(options) {
     override val SCRATCH_W2 = 0xcfu      // temp storage 2 for a word  $cf+$d0        TODO is $d0 okay to use?
 
     init {
+        if (options.floats) {
+            throw InternalCompilerException("Atari target doesn't yet support floating point routines")
+        }
+
         if (options.floats && options.zeropage !in arrayOf(
                 ZeropageType.FLOATSAFE,
                 ZeropageType.BASICSAFE,
@@ -39,9 +43,9 @@ class AtariZeropage(options: CompilationOptions) : Zeropage(options) {
             }
         }
 
-        val distictFree = free.distinct()
+        val distinctFree = free.distinct()
         free.clear()
-        free.addAll(distictFree)
+        free.addAll(distinctFree)
 
         removeReservedFromFreePool()
     }

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

@@ -1,6 +1,7 @@
 package prog8.code.target.c128
 
 import prog8.code.core.*
+import prog8.code.target.C64Target
 import prog8.code.target.cbm.Mflpt5
 import java.nio.file.Path
 
@@ -40,7 +41,7 @@ class C128MachineDefinition: IMachineDefinition {
         }
 
         println("\nStarting C-128 emulator x128...")
-        val viceMonlist = viceMonListName(programNameWithPath.toString())
+        val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
         val cmdline = listOf("x128", "-silent", "-moncommands", viceMonlist,
                 "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
         val processb = ProcessBuilder(cmdline).inheritIO()

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

@@ -6,15 +6,22 @@ import prog8.code.core.Zeropage
 import prog8.code.core.ZeropageType
 
 
+// reference: "Mapping the C128" zero page chapter.
+
 class C128Zeropage(options: CompilationOptions) : Zeropage(options) {
 
-    override val SCRATCH_B1 = 0x9bu      // temp storage for a single byte
-    override val SCRATCH_REG = 0x9cu     // temp storage for a register, must be B1+1
+    override val SCRATCH_B1 = 0x74u      // temp storage for a single byte
+    override val SCRATCH_REG = 0x75u     // temp storage for a register, must be B1+1
     override val SCRATCH_W1 = 0xfbu      // temp storage 1 for a word  $fb+$fc
     override val SCRATCH_W2 = 0xfdu      // temp storage 2 for a word  $fd+$fe
 
-
     init {
+        if (options.floats) {
+            throw InternalCompilerException("C128 target doesn't yet support floating point routines")
+            // note: in git commit labeled 'c128: remove floats module' the floats.p8 and floats.asm files are removed,
+            //       they could be retrieved again at a later time if the compiler somehow *does* store the fp variables in bank1.
+        }
+
         if (options.floats && options.zeropage !in arrayOf(
                 ZeropageType.FLOATSAFE,
                 ZeropageType.BASICSAFE,
@@ -24,23 +31,42 @@ class C128Zeropage(options: CompilationOptions) : Zeropage(options) {
 
         when (options.zeropage) {
             ZeropageType.FULL -> {
-                // TODO all c128 usable zero page locations, except the ones used by the system's IRQ routine
-                free.addAll(0x0au..0xffu)       // TODO c128 what about $02-$09?
-                // TODO c128  free.removeAll(setOf(0xa0u, 0xa1u, 0xa2u, 0x91u, 0xc0u, 0xc5u, 0xcbu, 0xf5u, 0xf6u))        // these are updated by IRQ
+                // $00/$01 are data port IO registers, // $02-$09 are storage locations for JSRFAR and such
+                free.addAll(0x0au..0xffu)
+                free.removeAll(listOf(0x90u, 0x91u, 0xa0u, 0xa1u, 0xa2u, 0xc0u, 0xccu, 0xcdu, 0xd0u, 0xd1u, 0xd2u, 0xd3u, 0xd4u, 0xd5u, 0xf7u))        // these are updated/used by IRQ
+            }
+            ZeropageType.KERNALSAFE -> {
+                free.addAll(0x0au..0x8fu)       // BASIC variables
+                free.addAll(listOf(0x92u, 0x96u, 0x9bu, 0x9cu, 0x9eu, 0x9fu, 0xa4u, 0xa7u, 0xa8u, 0xa9u, 0xaau, 0xabu,
+                    0xb0u, 0xb1u, 0xb4u, 0xb5u, 0xb6u))
             }
-            ZeropageType.KERNALSAFE,
             ZeropageType.FLOATSAFE,
             ZeropageType.BASICSAFE -> {
-                free.clear()   // TODO c128 usable zero page addresses
+                free.addAll(listOf(0x0bu, 0x0cu, 0x0du, 0x0eu, 0x0fu, 0x10u, 0x11u, 0x12u, 0x16u, 0x17u, 0x18u, 0x19u, 0x1au))
+                free.addAll(0x1bu..0x23u)
+                free.addAll(listOf(0x3fu, 0x40u, 0x41u, 0x42u, 0x43u, 0x44u, 0x47u, 0x48u, 0x49u, 0x4au, 0x4bu, 0x4cu, 0x4fu,
+                    0x55u, 0x56u, 0x57u, 0x58u,
+                    0x74u, 0x75u, 0x78u, 0x80u, 0x83u, 0x87u, 0x88u, 0x89u, 0x8au, 0x8bu, 0x8cu, 0x8du, 0x8eu, 0x8fu,
+                    0x92u, 0x96u, 0x9bu, 0x9cu, 0x9eu, 0x9fu, 0xa4u, 0xa7u, 0xa8u, 0xa9u, 0xaau, 0xabu,
+                    0xb0u, 0xb1u, 0xb4u, 0xb5u, 0xb6u
+                ))
+
+                // if(options.zeropage==ZeropageType.BASICSAFE) {
+                    // can also clobber the FP locations (unconditionally, because the C128 target doesn't support floating point calculations in prog8 at this time0
+                    free.addAll(listOf(0x14u, 0x28u, 0x29u, 0x2au, 0x2bu, 0x2cu,
+                        0x50u, 0x51u, 0x52u, 0x53u, 0x54u, 0x59u, 0x5au, 0x5bu, 0x5cu, 0x5du, 0x5eu, 0x5fu, 0x60u, 0x61u, 0x62u,
+                        0x63u, 0x64u, 0x65u, 0x66u, 0x67u, 0x68u,
+                        0x6au, 0x6bu, 0x6cu, 0x6du, 0x6eu, 0x6fu, 0x71u))
+                // }
             }
             ZeropageType.DONTUSE -> {
                 free.clear()  // don't use zeropage at all
             }
         }
 
-        val distictFree = free.distinct()
+        val distinctFree = free.distinct()
         free.clear()
-        free.addAll(distictFree)
+        free.addAll(distinctFree)
 
         removeReservedFromFreePool()
     }

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

@@ -1,6 +1,7 @@
 package prog8.code.target.c64
 
 import prog8.code.core.*
+import prog8.code.target.C64Target
 import prog8.code.target.cbm.Mflpt5
 import java.io.IOException
 import java.nio.file.Path
@@ -42,7 +43,7 @@ class C64MachineDefinition: IMachineDefinition {
 
         for(emulator in listOf("x64sc", "x64")) {
             println("\nStarting C-64 emulator $emulator...")
-            val viceMonlist = viceMonListName(programNameWithPath.toString())
+            val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
             val cmdline = listOf(emulator, "-silent", "-moncommands", viceMonlist,
                     "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
             val processb = ProcessBuilder(cmdline).inheritIO()

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

@@ -44,7 +44,7 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
             if (options.zeropage == ZeropageType.FLOATSAFE) {
                 // remove the zeropage locations used for floating point operations from the free list
                 free.removeAll(listOf(
-                        0x03, 0x04, 0x10, 0x11, 0x12,
+                        0x03, 0x04, 0x05, 0x06, 0x10, 0x11, 0x12,
                         0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
                         0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
                         0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
@@ -65,9 +65,9 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
             }
         }
 
-        val distictFree = free.distinct()
+        val distinctFree = free.distinct()
         free.clear()
-        free.addAll(distictFree)
+        free.addAll(distinctFree)
 
         removeReservedFromFreePool()
 

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

@@ -1,6 +1,7 @@
 package prog8.code.target.cx16
 
 import prog8.code.core.*
+import prog8.code.target.C64Target
 import prog8.code.target.cbm.Mflpt5
 import java.nio.file.Path
 
@@ -43,7 +44,7 @@ class CX16MachineDefinition: IMachineDefinition {
             }
             2 -> {
                 emulator = "box16"
-                extraArgs = listOf("-sym", viceMonListName(programNameWithPath.toString()))
+                extraArgs = listOf("-sym", C64Target.viceMonListName(programNameWithPath.toString()))
             }
             else -> {
                 System.err.println("Cx16 target only supports x16emu and box16 emulators.")
@@ -63,7 +64,7 @@ class CX16MachineDefinition: IMachineDefinition {
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = CX16Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, 0x0600u until 0x0800u)
+        golden = GoldenRam(compilerOptions, 0x0400u until ESTACK_LO)
     }
 
 }

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

@@ -43,9 +43,9 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
                 else -> throw InternalCompilerException("for this machine target, zero page type 'floatsafe' is not available. ${options.zeropage}")
             }
 
-            val distictFree = free.distinct()
+            val distinctFree = free.distinct()
             free.clear()
-            free.addAll(distictFree)
+            free.addAll(distinctFree)
 
             removeReservedFromFreePool()
 

codeGenCpu6502/build.gradle

@@ -30,7 +30,7 @@ dependencies {
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
     implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.3.2'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.5.5'
 }
 
 sourceSets {

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

@@ -311,20 +311,9 @@ private fun optimizeSameAssignments(
         /*
         sta  A   ; or stz     double store, remove this first one
         sta  A   ; or stz
-         */
-        if(!overlappingMods && first.isStoreRegOrZero() && second.isStoreRegOrZero()) {
-            if(first[2]==second[2]) {
-                val firstvalue = first.substring(4)
-                val secondvalue = second.substring(4)
-                if(firstvalue==secondvalue) {
-                    val address = getAddressArg(first, symbolTable)
-                    if(address==null || !machine.isIOAddress(address)) {
-                        overlappingMods = true
-                        mods.add(Modification(lines[0].index, true, null))
-                    }
-                }
-            }
-        }
+        However, this cannot be done relyably because 'A' could be a constant symbol referring to an I/O address.
+        We can't see that here and would otherwise delete valid double stores.
+        */
     }
 
     return mods

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

@@ -4,6 +4,7 @@ import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
 import com.github.michaelbull.result.mapError
 import prog8.code.core.*
+import prog8.code.target.C64Target
 import java.io.File
 import java.nio.file.Path
 import kotlin.io.path.Path
@@ -19,10 +20,10 @@ internal class AssemblyProgram(
     private val prgFile = outputDir.resolve("$name.prg")        // CBM prg executable program
     private val xexFile = outputDir.resolve("$name.xex")        // Atari xex executable program
     private val binFile = outputDir.resolve("$name.bin")
-    private val viceMonListFile = outputDir.resolve(viceMonListName(name))
+    private val viceMonListFile = outputDir.resolve(C64Target.viceMonListName(name))
     private val listFile = outputDir.resolve("$name.list")
 
-    override fun assemble(options: CompilationOptions): Boolean {
+    override fun assemble(options: CompilationOptions, errors: IErrorReporter): Boolean {
 
         val assemblerCommand: List<String>
 

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

@@ -1,5 +1,6 @@
 package prog8.codegen.cpu6502
 
+import prog8.code.StStaticVariable
 import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
@@ -34,6 +35,8 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "any", "all" -> funcAnyAll(fcall, resultToStack, resultRegister, sscope)
             "sgn" -> funcSgn(fcall, resultToStack, resultRegister, sscope)
             "sqrt16" -> funcSqrt16(fcall, resultToStack, resultRegister, sscope)
+            "divmod" -> funcDivmod(fcall)
+            "divmodw" -> funcDivmodW(fcall)
             "rol" -> funcRol(fcall)
             "rol2" -> funcRol2(fcall)
             "ror" -> funcRor(fcall)
@@ -70,12 +73,54 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             "rrestorex" -> funcRrestoreX()
             "cmp" -> funcCmp(fcall)
             "callfar" -> funcCallFar(fcall)
+            "prog8_lib_stringcompare" -> funcStringCompare(fcall, resultToStack)
             else -> throw AssemblyError("missing asmgen for builtin func ${fcall.name}")
         }
 
         return BuiltinFunctions.getValue(fcall.name).returnType
     }
 
+    private fun funcDivmod(fcall: PtBuiltinFunctionCall) {
+        assignAsmGen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A, false)
+        asmgen.saveRegisterStack(CpuRegister.A, false)
+        assignAsmGen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.Y, false)
+        asmgen.restoreRegisterStack(CpuRegister.A ,false)
+        // math.divmod_ub_asm: -- divide A by Y, result quotient in Y, remainder in A   (unsigned)
+        asmgen.out("  jsr  math.divmod_ub_asm")
+        val var2name = asmgen.asmVariableName(fcall.args[2] as PtIdentifier)
+        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)
+    }
+
+    private fun funcDivmodW(fcall: PtBuiltinFunctionCall) {
+        assignAsmGen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", DataType.UWORD)
+        assignAsmGen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AY, false)
+        // math.divmod_uw_asm: -- divide two unsigned words (16 bit each) into 16 bit results
+        //    input:  P8ZP_SCRATCH_W1 in ZP: 16 bit number, A/Y: 16 bit divisor
+        //    output: P8ZP_SCRATCH_W2 in ZP: 16 bit remainder, A/Y: 16 bit division result
+        asmgen.out("  jsr  math.divmod_uw_asm")
+        val var2name = asmgen.asmVariableName(fcall.args[2] as PtIdentifier)
+        val divisionTarget = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, DataType.UBYTE, fcall.definingISub(), fcall.args[2].position, var2name)
+        val remainderVar = asmgen.asmVariableName(fcall.args[3] as PtIdentifier)
+        assignAsmGen.assignRegisterpairWord(divisionTarget, RegisterOrPair.AY)
+        asmgen.out("""
+            lda  P8ZP_SCRATCH_W2
+            ldy  P8ZP_SCRATCH_W2+1
+            sta  $remainderVar
+            sty  $remainderVar+1""")
+    }
+
+    private fun funcStringCompare(fcall: PtBuiltinFunctionCall, resultToStack: Boolean) {
+        assignAsmGen.assignExpressionToVariable(fcall.args[1], "P8ZP_SCRATCH_W2", DataType.UWORD)
+        assignAsmGen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY, false)
+        asmgen.out("  jsr  prog8_lib.strcmp_mem")
+        if(resultToStack)
+            asmgen.out("  sta  P8ESTACK_LO,x |  dex")
+    }
+
     private fun funcRsave() {
         if (asmgen.isTargetCpu(CpuType.CPU65c02))
             asmgen.out("""
@@ -163,24 +208,24 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                             asmgen.out("  cmp  ${arg2.address.asConstInteger()!!.toHex()}")
                         } else {
                             if(arg1.isSimple()) {
-                                asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, fcall.definingISub())
+                                asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE)
                                 asmgen.assignExpressionToRegister(arg1, RegisterOrPair.A)
                                 asmgen.out("  cmp  P8ZP_SCRATCH_B1")
                             } else {
                                 asmgen.pushCpuStack(DataType.UBYTE, arg1)
-                                asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, fcall.definingISub())
+                                asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE)
                                 asmgen.out("  pla |  cmp  P8ZP_SCRATCH_B1")
                             }
                         }
                     }
                     else -> {
                         if(arg1.isSimple()) {
-                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, fcall.definingISub())
+                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE)
                             asmgen.assignExpressionToRegister(arg1, RegisterOrPair.A)
                             asmgen.out("  cmp  P8ZP_SCRATCH_B1")
                         } else {
                             asmgen.pushCpuStack(DataType.UBYTE, arg1)
-                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE, fcall.definingISub())
+                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_B1", DataType.UBYTE)
                             asmgen.out("  pla |  cmp  P8ZP_SCRATCH_B1")
                         }
                     }
@@ -209,7 +254,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     }
                     else -> {
                         if(arg1.isSimple()) {
-                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_W1", DataType.UWORD, fcall.definingISub())
+                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_W1", DataType.UWORD)
                             asmgen.assignExpressionToRegister(arg1, RegisterOrPair.AY)
                             asmgen.out("""
                                 cpy  P8ZP_SCRATCH_W1+1
@@ -218,7 +263,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
     +""")
                         } else {
                             asmgen.pushCpuStack(DataType.UWORD, arg1)
-                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_W1", DataType.UWORD, fcall.definingISub())
+                            asmgen.assignExpressionToVariable(arg2, "P8ZP_SCRATCH_W1", DataType.UWORD)
                             asmgen.restoreRegisterStack(CpuRegister.Y, false)
                             asmgen.restoreRegisterStack(CpuRegister.A, false)
                             asmgen.out("""
@@ -246,11 +291,11 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         val src = AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, DataType.UWORD, expression = addressOf)
         val target =
             if(resultToStack)
-                AsmAssignTarget(TargetStorageKind.STACK,  asmgen, DataType.UWORD, null)
+                AsmAssignTarget(TargetStorageKind.STACK,  asmgen, DataType.UWORD, null, fcall.position)
             else
-                AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, null, asmgen)
+                AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, fcall.position, null, asmgen)
         val assign = AsmAssignment(src, target, program.memsizer, fcall.position)
-        asmgen.translateNormalAssignment(assign)
+        asmgen.translateNormalAssignment(assign, fcall.definingISub())
     }
 
     private fun funcSqrt16(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
@@ -259,7 +304,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
             asmgen.out("  jsr  prog8_lib.func_sqrt16_stack")
         else {
             asmgen.out("  jsr  prog8_lib.func_sqrt16_into_A")
-            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, asmgen), CpuRegister.A)
+            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, false)
         }
     }
 
@@ -293,6 +338,16 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         lda  #$numElements
                         jsr  prog8_lib.func_reverse_w""")
                 }
+                DataType.STR -> {
+                    val stringLength = (symbol as StStaticVariable).length!!-1
+                    asmgen.out("""
+                        lda  #<$varName
+                        ldy  #>$varName
+                        sta  P8ZP_SCRATCH_W1
+                        sty  P8ZP_SCRATCH_W1+1
+                        lda  #$stringLength
+                        jsr  prog8_lib.func_reverse_b""")
+                }
                 DataType.ARRAY_F -> {
                     asmgen.out("""
                         lda  #<$varName
@@ -337,6 +392,16 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                         lda  #$numElements""")
                     asmgen.out(if (decl.type == DataType.ARRAY_UW) "  jsr  prog8_lib.func_sort_uw" else "  jsr  prog8_lib.func_sort_w")
                 }
+                DataType.STR -> {
+                    val stringLength = (symbol as StStaticVariable).length!!-1
+                    asmgen.out("""
+                        lda  #<$varName
+                        ldy  #>$varName
+                        sta  P8ZP_SCRATCH_W1
+                        sty  P8ZP_SCRATCH_W1+1
+                        lda  #$stringLength
+                        jsr  prog8_lib.func_sort_ub""")
+                }
                 DataType.ARRAY_F -> throw AssemblyError("sorting of floating point array is not supported")
                 else -> throw AssemblyError("weird type")
             }
@@ -550,14 +615,15 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
         if(arrayvar.type==DataType.UWORD) {
             if(dt!='b')
                 throw AssemblyError("non-array var indexing requires bytes dt")
-            asmgen.assignExpressionToVariable(arrayvar, "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
+            asmgen.assignExpressionToVariable(arrayvar, "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD)
         } else {
+            val p = arrayvar.parent
             val addressOf = PtAddressOf(arrayvar.position)
             addressOf.add(arrayvar)
-            addressOf.parent = arrayvar.parent.parent
-            asmgen.assignExpressionToVariable(addressOf, "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
+            addressOf.parent = p
+            asmgen.assignExpressionToVariable(addressOf, "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD)
         }
-        asmgen.assignExpressionToVariable(indexer.index, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE, null)
+        asmgen.assignExpressionToVariable(indexer.index, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE)
     }
 
     private fun funcSgn(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: IPtSubroutine?) {
@@ -581,7 +647,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, scope, asmgen), CpuRegister.A)
+            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, true)
         }
     }
 
@@ -602,7 +668,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${fcall.name}_f_into_A |  ldy  #0")
                 else -> throw AssemblyError("weird type $dt")
             }
-            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, asmgen), CpuRegister.A)
+            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, fcall.position, scope, asmgen), CpuRegister.A, dt in SignedDatatypes)
         }
     }
 
@@ -625,7 +691,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 DataType.WORD -> asmgen.out("  jsr  prog8_lib.abs_w_into_AY")
                 else -> throw AssemblyError("weird type")
             }
-            assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, asmgen), RegisterOrPair.AY)
+            assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, fcall.position, scope, asmgen), RegisterOrPair.AY)
         }
     }
 
@@ -662,33 +728,41 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                 }
             }
             is PtBinaryExpression -> {
-                if(addrExpr.operator=="+" && addrExpr.left is PtIdentifier && addrExpr.right is PtNumber) {
-                    val varname = asmgen.asmVariableName(addrExpr.left as PtIdentifier)
-                    if(asmgen.isZpVar(addrExpr.left as PtIdentifier)) {
-                        // pointervar is already in the zero page, no need to copy
-                        asmgen.saveRegisterLocal(CpuRegister.X, fcall.definingISub()!!)
-                        asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AX)
-                        val index = (addrExpr.right as PtNumber).number.toHex()
-                        asmgen.out("""
-                            ldy  #$index
+                require(!asmgen.options.useNewExprCode)
+                val result = asmgen.pointerViaIndexRegisterPossible(addrExpr)
+                val pointer = result?.first as? PtIdentifier
+                if(result!=null && pointer!=null && asmgen.isZpVar(pointer)) {
+                    // can do ZP,Y indexing
+                    val varname = asmgen.asmVariableName(pointer)
+                    val scope = fcall.definingISub()!!
+                    asmgen.saveRegisterLocal(CpuRegister.X, scope)
+                    asmgen.assignExpressionToRegister(result.second, RegisterOrPair.Y)
+                    asmgen.saveRegisterLocal(CpuRegister.Y, scope)
+                    asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AX)
+                    asmgen.restoreRegisterLocal(CpuRegister.Y)
+                    asmgen.out("""
                             sta  ($varname),y
                             txa
                             iny
                             sta  ($varname),y""")
-                        asmgen.restoreRegisterLocal(CpuRegister.X)
-                        return
-                    }
+                    asmgen.restoreRegisterLocal(CpuRegister.X)
+                    return
                 }
             }
-            else -> throw AssemblyError("wrong pokew arg type")
+            else -> { /* fall through */ }
         }
 
-        asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", DataType.UWORD, null)
+        // fall through method:
+        asmgen.assignExpressionToVariable(fcall.args[0], "P8ZP_SCRATCH_W1", DataType.UWORD)
         asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AY)
         asmgen.out("  jsr  prog8_lib.func_pokew")
     }
 
     private fun funcPeekW(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
+        fun fallback() {
+            asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
+            asmgen.out("  jsr  prog8_lib.func_peekw")
+        }
         when(val addrExpr = fcall.args[0]) {
             is PtNumber -> {
                 val addr = addrExpr.number.toHex()
@@ -714,38 +788,26 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                             tay
                             pla""")
                     }
-                } else {
-                    asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
-                    asmgen.out("  jsr  prog8_lib.func_peekw")
-                }
+                } else fallback()
             }
             is PtBinaryExpression -> {
-                if(addrExpr.operator=="+" && addrExpr.left is PtIdentifier && addrExpr.right is PtNumber) {
-                    val varname = asmgen.asmVariableName(addrExpr.left as PtIdentifier)
-                    if(asmgen.isZpVar(addrExpr.left as PtIdentifier)) {
-                        // pointervar is already in the zero page, no need to copy
-                        val index = (addrExpr.right as PtNumber).number.toHex()
-                        asmgen.out("""
-                            ldy  #$index
-                            lda  ($varname),y
-                            pha
-                            iny
-                            lda  ($varname),y
-                            tay
-                            pla""")
-                    }  else {
-                        asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
-                        asmgen.out("  jsr  prog8_lib.func_peekw")
-                    }
-                } else {
-                    asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
-                    asmgen.out("  jsr  prog8_lib.func_peekw")
-                }
-            }
-            else -> {
-                asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.AY)
-                asmgen.out("  jsr  prog8_lib.func_peekw")
+                require(!asmgen.options.useNewExprCode)
+                val result = asmgen.pointerViaIndexRegisterPossible(addrExpr)
+                val pointer = result?.first as? PtIdentifier
+                if(result!=null && pointer!=null && asmgen.isZpVar(pointer)) {
+                    // can do ZP,Y indexing
+                    val varname = asmgen.asmVariableName(pointer)
+                    asmgen.assignExpressionToRegister(result.second, RegisterOrPair.Y)
+                    asmgen.out("""
+                        lda  ($varname),y
+                        pha
+                        iny
+                        lda  ($varname),y
+                        tay
+                        pla""")
+                } else fallback()
             }
+            else -> fallback()
         }
 
         if(resultToStack){
@@ -766,9 +828,10 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
 
     private fun funcMkword(fcall: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
         if(resultToStack) {
-            asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.Y)      // msb
+            asmgen.assignExpressionToRegister(fcall.args[0], RegisterOrPair.A)      // msb
+            asmgen.out("  pha")
             asmgen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.A)      // lsb
-            asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
+            asmgen.out("  sta  P8ESTACK_LO,x |  pla |  sta  P8ESTACK_HI,x |  dex")
         } else {
             val reg = resultRegister ?: RegisterOrPair.AY
             var needAsave = asmgen.needAsaveForExpr(fcall.args[0])
@@ -976,7 +1039,7 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                     val addr = PtAddressOf(value.position)
                     addr.add(variable)
                     addr.parent = call
-                    asmgen.assignExpressionToVariable(value, asmgen.asmVariableName(variable), DataType.FLOAT, scope)
+                    asmgen.assignExpressionToVariable(value, asmgen.asmVariableName(variable), DataType.FLOAT)
                     AsmAssignSource.fromAstSource(addr, program, asmgen)
                 }
             }
@@ -1002,9 +1065,9 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                             AsmAssignSource.fromAstSource(value, program, asmgen)
                         }
                     }
-                    val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, conv.dt, null, variableAsmName = varname)
+                    val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, conv.dt, null, value.position, variableAsmName = varname)
                     val assign = AsmAssignment(src, tgt, program.memsizer, value.position)
-                    asmgen.translateNormalAssignment(assign)
+                    asmgen.translateNormalAssignment(assign, scope)
                 }
                 conv.reg != null -> {
                     val src = when (conv.dt) {
@@ -1020,9 +1083,9 @@ internal class BuiltinFunctionsAsmGen(private val program: PtProgram,
                             AsmAssignSource.fromAstSource(value, program, asmgen)
                         }
                     }
-                    val tgt = AsmAssignTarget.fromRegisters(conv.reg!!, false, null, asmgen)
+                    val tgt = AsmAssignTarget.fromRegisters(conv.reg!!, false, value.position, null, asmgen)
                     val assign = AsmAssignment(src, tgt, program.memsizer, value.position)
-                    asmgen.translateNormalAssignment(assign)
+                    asmgen.translateNormalAssignment(assign, scope)
                 }
                 else -> throw AssemblyError("callconv")
             }

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

@@ -33,14 +33,19 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
             is PtIdentifier -> translateExpression(expression)
             is PtFunctionCall -> translateFunctionCallResultOntoStack(expression)
             is PtBuiltinFunctionCall -> asmgen.translateBuiltinFunctionCallExpression(expression, true, null)
-            is PtContainmentCheck -> throw AssemblyError("containment check as complex expression value is not supported")
-            is PtArray, is PtString -> throw AssemblyError("no asm gen for string/array literal value assignment - should have been replaced by a variable")
+            is PtContainmentCheck -> translateContainmentCheck(expression)
+            is PtArray, is PtString -> throw AssemblyError("string/array literal value assignment should have been replaced by a variable")
             is PtRange -> throw AssemblyError("range expression should have been changed into array values")
             is PtMachineRegister -> throw AssemblyError("machine register ast node should not occur in 6502 codegen it is for IR code")
             else -> TODO("missing expression asmgen for $expression")
         }
     }
 
+    private fun translateContainmentCheck(check: PtContainmentCheck) {
+        asmgen.assignExpressionToRegister(check, RegisterOrPair.A)
+        asmgen.out("  sta  P8ESTACK_LO,x |  dex")
+    }
+
     private fun translateFunctionCallResultOntoStack(call: PtFunctionCall) {
         // only for use in nested expression evaluation
 
@@ -240,17 +245,53 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
     }
 
     private fun translateExpression(expr: PtBinaryExpression) {
+        require(!asmgen.options.useNewExprCode)
+
         // Uses evalstack to evaluate the given expression.  THIS IS SLOW AND SHOULD BE AVOIDED!
+        if(translateSomewhatOptimized(expr.left, expr.operator, expr.right))
+            return
+
         val leftDt = expr.left.type
         val rightDt = expr.right.type
-        // see if we can apply some optimized routines still
-        when(expr.operator) {
+
+        // compare with zero
+        if(expr.operator in ComparisonOperators) {
+            if(leftDt in NumericDatatypes && rightDt in NumericDatatypes) {
+                val rightVal = expr.right.asConstInteger()
+                if(rightVal==0)
+                    return translateComparisonWithZero(expr.left, leftDt, expr.operator)
+            }
+        }
+
+        if(leftDt==DataType.STR && rightDt==DataType.STR && expr.operator in ComparisonOperators)
+            return translateCompareStrings(expr.left, expr.operator, expr.right)
+
+        if((leftDt in ByteDatatypes && rightDt !in ByteDatatypes)
+                || (leftDt in WordDatatypes && rightDt !in WordDatatypes))
+            throw AssemblyError("binary operator ${expr.operator} left/right dt not identical")
+
+        // the general, non-optimized cases
+        // TODO optimize more cases.... (or one day just don't use the evalstack at all anymore)
+        translateExpressionInternal(expr.left)
+        translateExpressionInternal(expr.right)
+        when (leftDt) {
+            in ByteDatatypes -> translateBinaryOperatorBytes(expr.operator, leftDt)
+            in WordDatatypes -> translateBinaryOperatorWords(expr.operator, leftDt)
+            DataType.FLOAT -> translateBinaryOperatorFloats(expr.operator)
+            else -> throw AssemblyError("non-numerical datatype")
+        }
+    }
+
+    private fun translateSomewhatOptimized(left: PtExpression, operator: String, right: PtExpression): Boolean {
+        val leftDt = left.type
+        val rightDt = right.type
+        when(operator) {
             "+" -> {
                 if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val leftVal = expr.left.asConstInteger()
-                    val rightVal = expr.right.asConstInteger()
+                    val leftVal = left.asConstInteger()
+                    val rightVal = right.asConstInteger()
                     if (leftVal!=null && leftVal in -4..4) {
-                        translateExpressionInternal(expr.right)
+                        translateExpressionInternal(right)
                         if(rightDt in ByteDatatypes) {
                             val incdec = if(leftVal<0) "dec" else "inc"
                             repeat(leftVal.absoluteValue) {
@@ -276,11 +317,11 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
                                 }
                             }
                         }
-                        return
+                        return true
                     }
                     else if (rightVal!=null && rightVal in -4..4)
                     {
-                        translateExpressionInternal(expr.left)
+                        translateExpressionInternal(left)
                         if(leftDt in ByteDatatypes) {
                             val incdec = if(rightVal<0) "dec" else "inc"
                             repeat(rightVal.absoluteValue) {
@@ -306,16 +347,16 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
                                 }
                             }
                         }
-                        return
+                        return true
                     }
                 }
             }
             "-" -> {
                 if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val rightVal = expr.right.asConstInteger()
+                    val rightVal = right.asConstInteger()
                     if (rightVal!=null && rightVal in -4..4)
                     {
-                        translateExpressionInternal(expr.left)
+                        translateExpressionInternal(left)
                         if(leftDt in ByteDatatypes) {
                             val incdec = if(rightVal<0) "inc" else "dec"
                             repeat(rightVal.absoluteValue) {
@@ -341,14 +382,14 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
                                 }
                             }
                         }
-                        return
+                        return true
                     }
                 }
             }
             ">>" -> {
-                val amount = expr.right.asConstInteger()
+                val amount = right.asConstInteger()
                 if(amount!=null) {
-                    translateExpressionInternal(expr.left)
+                    translateExpressionInternal(left)
                     when (leftDt) {
                         DataType.UBYTE -> {
                             if (amount <= 2)
@@ -374,17 +415,17 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
                                     asmgen.out("  stz  P8ESTACK_LO+1,x |  stz  P8ESTACK_HI+1,x")
                                 else
                                     asmgen.out("  lda  #0 |  sta  P8ESTACK_LO+1,x |  sta  P8ESTACK_HI+1,x")
-                                return
+                                return true
                             }
-                            var left = amount
-                            while (left >= 7) {
+                            var amountLeft = amount
+                            while (amountLeft >= 7) {
                                 asmgen.out(" jsr  math.shift_right_uw_7")
-                                left -= 7
+                                amountLeft -= 7
                             }
-                            if (left in 0..2)
-                                repeat(left) { asmgen.out(" lsr  P8ESTACK_HI+1,x |  ror  P8ESTACK_LO+1,x") }
+                            if (amountLeft in 0..2)
+                                repeat(amountLeft) { asmgen.out(" lsr  P8ESTACK_HI+1,x |  ror  P8ESTACK_LO+1,x") }
                             else
-                                asmgen.out(" jsr  math.shift_right_uw_$left")
+                                asmgen.out(" jsr  math.shift_right_uw_$amountLeft")
                         }
                         DataType.WORD -> {
                             if(amount>=16) {
@@ -399,27 +440,27 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
                                     sta  P8ESTACK_LO+1,x
                                     sta  P8ESTACK_HI+1,x
 +""")
-                                return
+                                return true
                             }
-                            var left = amount
-                            while (left >= 7) {
+                            var amountLeft = amount
+                            while (amountLeft >= 7) {
                                 asmgen.out(" jsr  math.shift_right_w_7")
-                                left -= 7
+                                amountLeft -= 7
                             }
-                            if (left in 0..2)
-                                repeat(left) { asmgen.out(" lda  P8ESTACK_HI+1,x |  asl  a  |  ror  P8ESTACK_HI+1,x |  ror  P8ESTACK_LO+1,x") }
+                            if (amountLeft in 0..2)
+                                repeat(amountLeft) { asmgen.out(" lda  P8ESTACK_HI+1,x |  asl  a  |  ror  P8ESTACK_HI+1,x |  ror  P8ESTACK_LO+1,x") }
                             else
-                                asmgen.out(" jsr  math.shift_right_w_$left")
+                                asmgen.out(" jsr  math.shift_right_w_$amountLeft")
                         }
                         else -> throw AssemblyError("weird type")
                     }
-                    return
+                    return true
                 }
             }
             "<<" -> {
-                val amount = expr.right.asConstInteger()
+                val amount = right.asConstInteger()
                 if(amount!=null) {
-                    translateExpressionInternal(expr.left)
+                    translateExpressionInternal(left)
                     if (leftDt in ByteDatatypes) {
                         if (amount <= 2)
                             repeat(amount) { asmgen.out("  asl  P8ESTACK_LO+1,x") }
@@ -429,78 +470,80 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
                             asmgen.out("  sta  P8ESTACK_LO+1,x")
                         }
                     } else {
-                        var left = amount
-                        while (left >= 7) {
+                        var amountLeft = amount
+                        while (amountLeft >= 7) {
                             asmgen.out(" jsr  math.shift_left_w_7")
-                            left -= 7
+                            amountLeft -= 7
                         }
-                        if (left in 0..2)
-                            repeat(left) { asmgen.out("  asl  P8ESTACK_LO+1,x |  rol  P8ESTACK_HI+1,x") }
+                        if (amountLeft in 0..2)
+                            repeat(amountLeft) { asmgen.out("  asl  P8ESTACK_LO+1,x |  rol  P8ESTACK_HI+1,x") }
                         else
-                            asmgen.out(" jsr  math.shift_left_w_$left")
+                            asmgen.out(" jsr  math.shift_left_w_$amountLeft")
                     }
-                    return
+                    return true
                 }
             }
             "*" -> {
                 if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val leftVar = expr.left as? PtIdentifier
-                    val rightVar = expr.right as? PtIdentifier
-                    if(leftVar!=null && rightVar!=null && leftVar==rightVar)
-                        return translateSquared(leftVar, leftDt)
+                    val leftVar = left as? PtIdentifier
+                    val rightVar = right as? PtIdentifier
+                    if(leftVar!=null && rightVar!=null && leftVar==rightVar) {
+                        translateSquared(leftVar, leftDt)
+                        return true
+                    }
                 }
 
-                val value = expr.right as? PtNumber
+                val value = right as? PtNumber
                 if(value!=null) {
                     if(rightDt in IntegerDatatypes) {
                         val amount = value.number.toInt()
                         if(amount==2) {
                             // optimize x*2 common case
-                            translateExpressionInternal(expr.left)
+                            translateExpressionInternal(left)
                             if(leftDt in ByteDatatypes) {
                                 asmgen.out("  asl  P8ESTACK_LO+1,x")
                             } else {
                                 asmgen.out("  asl  P8ESTACK_LO+1,x |  rol  P8ESTACK_HI+1,x")
                             }
-                            return
+                            return true
                         }
                         when(rightDt) {
                             DataType.UBYTE -> {
                                 if(amount in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(expr.left)
+                                    translateExpressionInternal(left)
                                     asmgen.out(" jsr  math.stack_mul_byte_$amount")
-                                    return
+                                    return true
                                 }
                             }
                             DataType.BYTE -> {
                                 if(amount in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(expr.left)
+                                    translateExpressionInternal(left)
                                     asmgen.out(" jsr  math.stack_mul_byte_$amount")
-                                    return
+                                    return true
                                 }
                                 if(amount.absoluteValue in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(expr.left)
+                                    translateExpressionInternal(left)
                                     asmgen.out(" jsr  prog8_lib.neg_b |  jsr  math.stack_mul_byte_${amount.absoluteValue}")
-                                    return
+                                    return true
                                 }
                             }
                             DataType.UWORD -> {
                                 if(amount in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(expr.left)
+                                    translateExpressionInternal(left)
                                     asmgen.out(" jsr  math.stack_mul_word_$amount")
-                                    return
+                                    return true
                                 }
                             }
                             DataType.WORD -> {
                                 if(amount in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(expr.left)
+                                    translateExpressionInternal(left)
                                     asmgen.out(" jsr  math.stack_mul_word_$amount")
-                                    return
+                                    return true
                                 }
                                 if(amount.absoluteValue in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(expr.left)
+                                    translateExpressionInternal(left)
                                     asmgen.out(" jsr  prog8_lib.neg_w |  jsr  math.stack_mul_word_${amount.absoluteValue}")
-                                    return
+                                    return true
                                 }
                             }
                             else -> {}
@@ -510,9 +553,9 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
             }
             "/" -> {
                 if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val rightVal = expr.right.asConstInteger()
+                    val rightVal = right.asConstInteger()
                     if(rightVal!=null && rightVal==2) {
-                        translateExpressionInternal(expr.left)
+                        translateExpressionInternal(left)
                         when (leftDt) {
                             DataType.UBYTE -> {
                                 asmgen.out("  lsr  P8ESTACK_LO+1,x")
@@ -545,38 +588,13 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
                             }
                             else -> throw AssemblyError("weird dt")
                         }
-                        return
+                        return true
                     }
                 }
             }
-            in ComparisonOperators -> {
-                if(leftDt in NumericDatatypes && rightDt in NumericDatatypes) {
-                    val rightVal = expr.right.asConstInteger()
-                    if(rightVal==0)
-                        return translateComparisonWithZero(expr.left, leftDt, expr.operator)
-                }
-            }
         }
 
-        if((leftDt in ByteDatatypes && rightDt !in ByteDatatypes)
-                || (leftDt in WordDatatypes && rightDt !in WordDatatypes))
-            throw AssemblyError("binary operator ${expr.operator} left/right dt not identical")
-
-        if(leftDt==DataType.STR && rightDt==DataType.STR && expr.operator in ComparisonOperators) {
-            translateCompareStrings(expr.left, expr.operator, expr.right)
-        }
-        else {
-            // the general, non-optimized cases
-            // TODO optimize more cases.... (or one day just don't use the evalstack at all anymore)
-            translateExpressionInternal(expr.left)
-            translateExpressionInternal(expr.right)
-            when (leftDt) {
-                in ByteDatatypes -> translateBinaryOperatorBytes(expr.operator, leftDt)
-                in WordDatatypes -> translateBinaryOperatorWords(expr.operator, leftDt)
-                DataType.FLOAT -> translateBinaryOperatorFloats(expr.operator)
-                else -> throw AssemblyError("non-numerical datatype")
-            }
-        }
+        return false
     }
 
     private fun translateComparisonWithZero(expr: PtExpression, dt: DataType, operator: String) {
@@ -657,7 +675,7 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
             "<=" -> {
                 when(dt) {
                     DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.equalzero_b")
-                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.lessequalzeros_b")
+                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.lessequalzero_sb")
                     DataType.UWORD -> asmgen.out("  jsr  prog8_lib.equalzero_w")
                     DataType.WORD -> asmgen.out("  jsr  prog8_lib.lessequalzero_sw")
                     DataType.FLOAT -> asmgen.out("  jsr  floats.lessequal_zero")
@@ -871,9 +889,13 @@ internal class ExpressionsAsmGen(private val program: PtProgram,
     }
 
     private fun translateCompareStrings(s1: PtExpression, operator: String, s2: PtExpression) {
-        asmgen.assignExpressionToVariable(s1, "prog8_lib.strcmp_expression._arg_s1", DataType.UWORD, null)
-        asmgen.assignExpressionToVariable(s2, "prog8_lib.strcmp_expression._arg_s2", DataType.UWORD, null)
+        asmgen.assignExpressionToVariable(s1, "prog8_lib.strcmp_expression._arg_s1", DataType.UWORD)
+        asmgen.assignExpressionToVariable(s2, "prog8_lib.strcmp_expression._arg_s2", DataType.UWORD)
         asmgen.out(" jsr  prog8_lib.strcmp_expression")    // result  of compare is in A
+        compareStringsProcessResultInA(operator)
+    }
+
+    private fun compareStringsProcessResultInA(operator: String) {
         when(operator) {
             "==" -> asmgen.out(" and  #1 |  eor  #1 |  sta  P8ESTACK_LO,x")
             "!=" -> asmgen.out(" and  #1 |  sta  P8ESTACK_LO,x")

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

@@ -50,8 +50,8 @@ internal class ForLoopsAsmGen(private val program: PtProgram,
                     val incdec = if(stepsize==1) "inc" else "dec"
                     // loop over byte range via loopvar
                     val varname = asmgen.asmVariableName(stmt.variable)
-                    asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt), null)
-                    asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayToElementTypes.getValue(iterableDt), null)
+                    asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt))
+                    asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayToElementTypes.getValue(iterableDt))
                     asmgen.out(loopLabel)
                     asmgen.translate(stmt.statements)
                     asmgen.out("""
@@ -68,8 +68,8 @@ $modifiedLabel          cmp  #0         ; modified
 
                     // loop over byte range via loopvar
                     val varname = asmgen.asmVariableName(stmt.variable)
-                    asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt), null)
-                    asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayToElementTypes.getValue(iterableDt), null)
+                    asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt))
+                    asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayToElementTypes.getValue(iterableDt))
                     asmgen.out(loopLabel)
                     asmgen.translate(stmt.statements)
                     if(stepsize>0) {
@@ -594,6 +594,5 @@ $loopLabel""")
         asmgen.assignExpressionToVariable(
             range.from,
             asmgen.asmVariableName(stmt.variable),
-            stmt.variable.type,
-            stmt.definingISub())
+            stmt.variable.type)
 }

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

@@ -141,7 +141,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
             throw AssemblyError("argument type incompatible")
 
         val varName = asmgen.asmVariableName(sub.scopedName + "." + parameter.name)
-        asmgen.assignExpressionToVariable(value, varName, parameter.type, sub)
+        asmgen.assignExpressionToVariable(value, varName, parameter.type)
     }
 
     private fun argumentViaRegister(sub: IPtSubroutine, parameter: IndexedValue<PtSubroutineParameter>, value: PtExpression, registerOverride: RegisterOrPair? = null) {
@@ -198,16 +198,17 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
             register!!
             if(requiredDt largerThan value.type) {
                 // we need to sign extend the source, do this via temporary word variable
-                asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_W1", DataType.UBYTE, sub)
+                asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_W1", DataType.UBYTE)
                 asmgen.signExtendVariableLsb("P8ZP_SCRATCH_W1", value.type)
-                asmgen.assignVariableToRegister("P8ZP_SCRATCH_W1", register)
+                asmgen.assignVariableToRegister("P8ZP_SCRATCH_W1", register, null, Position.DUMMY)
             } else {
+                val scope = value.definingISub()
                 val target: AsmAssignTarget =
                     if(parameter.value.type in ByteDatatypes && (register==RegisterOrPair.AX || register == RegisterOrPair.AY || register==RegisterOrPair.XY || register in Cx16VirtualRegisters))
-                        AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, parameter.value.type, sub, register = register)
+                        AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, parameter.value.type, scope, value.position, register = register)
                     else {
                         val signed = parameter.value.type == DataType.BYTE || parameter.value.type == DataType.WORD
-                        AsmAssignTarget.fromRegisters(register, signed, sub, asmgen)
+                        AsmAssignTarget.fromRegisters(register, signed, value.position, scope, asmgen)
                     }
                 val src = if(value.type in PassByReferenceDatatypes) {
                     if(value is PtIdentifier) {
@@ -221,7 +222,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                 } else {
                     AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(target)
                 }
-                asmgen.translateNormalAssignment(AsmAssignment(src, target, program.memsizer, Position.DUMMY))
+                asmgen.translateNormalAssignment(AsmAssignment(src, target, program.memsizer, Position.DUMMY), scope)
             }
         }
     }

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

@@ -150,8 +150,7 @@ internal class ProgramAndVarsGen(
                     asmgen.out("  rts")
             }
             "c128" -> {
-                asmgen.out("  jsr  main.start")
-                // TODO c128: how to bank basic+kernal back in?
+                asmgen.out("  jsr  main.start |  lda  #0 |  sta ${"$"}ff00")
                 if(!options.noSysInit)
                     asmgen.out("  jmp  ${compTarget.name}.cleanup_at_exit")
                 else
@@ -339,7 +338,7 @@ internal class ProgramAndVarsGen(
             asmgen.out("; simple int arg(s) passed via register(s)")
             if(sub.parameters.size==1) {
                 val dt = sub.parameters[0].type
-                val target = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, dt, sub, variableAsmName = sub.parameters[0].name)
+                val target = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, dt, sub, sub.parameters[0].position, variableAsmName = sub.parameters[0].name)
                 if(dt in ByteDatatypes)
                     asmgen.assignRegister(RegisterOrPair.A, target)
                 else
@@ -347,8 +346,8 @@ internal class ProgramAndVarsGen(
             } else {
                 require(sub.parameters.size==2)
                 // 2 simple byte args, first in A, second in Y
-                val target1 = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, sub.parameters[0].type, sub, variableAsmName = sub.parameters[0].name)
-                val target2 = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, sub.parameters[1].type, sub, variableAsmName = sub.parameters[1].name)
+                val target1 = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, sub.parameters[0].type, sub, sub.parameters[0].position, variableAsmName = sub.parameters[0].name)
+                val target2 = AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, sub.parameters[1].type, sub, sub.parameters[1].position, variableAsmName = sub.parameters[1].name)
                 asmgen.assignRegister(RegisterOrPair.A, target1)
                 asmgen.assignRegister(RegisterOrPair.Y, target2)
             }
@@ -358,26 +357,29 @@ internal class ProgramAndVarsGen(
         sub.children.forEach { asmgen.translate(it) }
 
         asmgen.out("; variables")
+        asmgen.out("    .section BSS")
         val asmGenInfo = asmgen.subroutineExtra(sub)
         for((dt, name, addr) in asmGenInfo.extraVars) {
             if(addr!=null)
                 asmgen.out("$name = $addr")
             else when(dt) {
-                DataType.UBYTE -> asmgen.out("$name    .byte  0")
-                DataType.UWORD -> asmgen.out("$name    .word  0")
-                else -> throw AssemblyError("weird dt")
+                DataType.UBYTE -> asmgen.out("$name    .byte  ?")
+                DataType.UWORD -> asmgen.out("$name    .word  ?")
+                DataType.FLOAT -> asmgen.out("$name    .fill  ${options.compTarget.machine.FLOAT_MEM_SIZE}")
+                else -> throw AssemblyError("weird dt for extravar $dt")
             }
         }
         if(asmGenInfo.usedRegsaveA)      // will probably never occur
-            asmgen.out("prog8_regsaveA     .byte  0")
+            asmgen.out("prog8_regsaveA     .byte  ?")
         if(asmGenInfo.usedRegsaveX)
-            asmgen.out("prog8_regsaveX     .byte  0")
+            asmgen.out("prog8_regsaveX     .byte  ?")
         if(asmGenInfo.usedRegsaveY)
-            asmgen.out("prog8_regsaveY     .byte  0")
+            asmgen.out("prog8_regsaveY     .byte  ?")
         if(asmGenInfo.usedFloatEvalResultVar1)
-            asmgen.out("$subroutineFloatEvalResultVar1    .byte  0,0,0,0,0")
+            asmgen.out("$subroutineFloatEvalResultVar1    .fill  ${options.compTarget.machine.FLOAT_MEM_SIZE}")
         if(asmGenInfo.usedFloatEvalResultVar2)
-            asmgen.out("$subroutineFloatEvalResultVar2    .byte  0,0,0,0,0")
+            asmgen.out("$subroutineFloatEvalResultVar2    .fill  ${options.compTarget.machine.FLOAT_MEM_SIZE}")
+        asmgen.out("  .send BSS")
 
         // normal statically allocated variables
         val variables = varsInSubroutine

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

@@ -28,6 +28,7 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                                private val asmgen: AsmGen6502Internal,
                                val datatype: DataType,
                                val scope: IPtSubroutine?,
+                               val position: Position,
                                private val variableAsmName: String? = null,
                                val array: PtArrayIndexer? = null,
                                val memory: PtMemoryByte? = null,
@@ -43,8 +44,6 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
             asmgen.asmVariableName(array.variable)
     }
 
-    lateinit var origAssign: AsmAssignmentBase
-
     init {
         if(register!=null && datatype !in NumericDatatypes)
             throw AssemblyError("register must be integer or float type")
@@ -63,28 +62,28 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                                 if(reg.statusflag!=null)
                                     throw AssemblyError("can't assign value to processor statusflag directly")
                                 else
-                                    return AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, type, definingSub, register=reg.registerOrPair, origAstTarget = this)
+                                    return AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, type, definingSub, target.position, register=reg.registerOrPair, origAstTarget = this)
                             }
                         }
-                        return AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, type, definingSub, variableAsmName = asmgen.asmVariableName(identifier!!), origAstTarget =  this)
+                        return AsmAssignTarget(TargetStorageKind.VARIABLE, asmgen, type, definingSub, target.position, variableAsmName = asmgen.asmVariableName(identifier!!), origAstTarget =  this)
                     }
-                    array != null -> return AsmAssignTarget(TargetStorageKind.ARRAY, asmgen, type, definingSub, array = array, origAstTarget =  this)
-                    memory != null -> return AsmAssignTarget(TargetStorageKind.MEMORY, asmgen, type, definingSub, memory =  memory, origAstTarget =  this)
+                    array != null -> return AsmAssignTarget(TargetStorageKind.ARRAY, asmgen, type, definingSub, target.position, array = array, origAstTarget =  this)
+                    memory != null -> return AsmAssignTarget(TargetStorageKind.MEMORY, asmgen, type, definingSub, target.position, memory =  memory, origAstTarget =  this)
                     else -> throw AssemblyError("weird target")
                 }
             }
         }
 
-        fun fromRegisters(registers: RegisterOrPair, signed: Boolean, scope: IPtSubroutine?, asmgen: AsmGen6502Internal): AsmAssignTarget =
+        fun fromRegisters(registers: RegisterOrPair, signed: Boolean, pos: Position, scope: IPtSubroutine?, asmgen: AsmGen6502Internal): AsmAssignTarget =
                 when(registers) {
                     RegisterOrPair.A,
                     RegisterOrPair.X,
-                    RegisterOrPair.Y -> AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, if(signed) DataType.BYTE else DataType.UBYTE, scope, register = registers)
+                    RegisterOrPair.Y -> AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, if(signed) DataType.BYTE else DataType.UBYTE, scope, pos, register = registers)
                     RegisterOrPair.AX,
                     RegisterOrPair.AY,
-                    RegisterOrPair.XY -> AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, if(signed) DataType.WORD else DataType.UWORD, scope, register = registers)
+                    RegisterOrPair.XY -> AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, if(signed) DataType.WORD else DataType.UWORD, scope, pos, register = registers)
                     RegisterOrPair.FAC1,
-                    RegisterOrPair.FAC2 -> AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, DataType.FLOAT, scope, register = registers)
+                    RegisterOrPair.FAC2 -> AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, DataType.FLOAT, scope, pos, register = registers)
                     RegisterOrPair.R0,
                     RegisterOrPair.R1,
                     RegisterOrPair.R2,
@@ -100,9 +99,31 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                     RegisterOrPair.R12,
                     RegisterOrPair.R13,
                     RegisterOrPair.R14,
-                    RegisterOrPair.R15 -> AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, if(signed) DataType.WORD else DataType.UWORD, scope, register = registers)
+                    RegisterOrPair.R15 -> AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, if(signed) DataType.WORD else DataType.UWORD, scope, pos, register = registers)
                 }
     }
+
+    fun isSameAs(left: PtExpression): Boolean =
+        when(kind) {
+            TargetStorageKind.VARIABLE -> {
+                val scopedName: String = if('.' in asmVarname)
+                    asmVarname
+                else {
+                    val scopeName = (scope as? PtNamedNode)?.scopedName
+                    if (scopeName == null) asmVarname else "$scopeName.$asmVarname"
+                }
+                left is PtIdentifier && left.name==scopedName
+            }
+            TargetStorageKind.ARRAY -> {
+                left is PtArrayIndexer && left isSameAs array!!
+            }
+            TargetStorageKind.MEMORY -> {
+                left isSameAs memory!!
+            }
+            TargetStorageKind.REGISTER, TargetStorageKind.STACK -> {
+                false
+            }
+        }
 }
 
 internal class AsmAssignSource(val kind: SourceStorageKind,

codeGenCpu6502/test/Dummies.kt

@@ -34,11 +34,15 @@ internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors:
     val warnings = mutableListOf<String>()
 
     override fun err(msg: String, position: Position) {
-        errors.add("${position.toClickableStr()} $msg")
+        val text = "${position.toClickableStr()} $msg"
+        if(text !in errors)
+            errors.add(text)
     }
 
     override fun warn(msg: String, position: Position) {
-        warnings.add("${position.toClickableStr()} $msg")
+        val text = "${position.toClickableStr()} $msg"
+        if(text !in warnings)
+            warnings.add(text)
     }
 
     override fun noErrors(): Boolean  = errors.isEmpty()

codeGenExperimental/src/prog8/codegen/experimental/ExperiCodeGen.kt

@@ -16,6 +16,7 @@ class ExperiCodeGen: ICodeGeneratorBackend {
         options: CompilationOptions,
         errors: IErrorReporter
     ): IAssemblyProgram? {
+
         // you could write a code generator directly on the PtProgram AST,
         // but you can also use the Intermediate Representation to build a codegen on:
         val irCodeGen = IRCodeGen(program, symbolTable, options, errors)

codeGenIntermediate/build.gradle

@@ -30,7 +30,7 @@ dependencies {
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
     implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.3.2'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.5.5'
 }
 
 sourceSets {

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

@@ -16,32 +16,28 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         return translateRegularAssign(assignment)
     }
 
-    internal fun translate(augmentedAssign: PtAugmentedAssign): IRCodeChunks {
-        if(augmentedAssign.target.children.single() is PtMachineRegister)
+    internal fun translate(augAssign: PtAugmentedAssign): IRCodeChunks {
+        if(augAssign.target.children.single() is PtMachineRegister)
             throw AssemblyError("assigning to a register should be done by just evaluating the expression into resultregister")
 
-        return translateInplaceAssign(augmentedAssign)
-    }
-
-    private fun translateInplaceAssign(assignment: PtAugmentedAssign): IRCodeChunks {
-        val ident = assignment.target.identifier
-        val memory = assignment.target.memory
-        val array = assignment.target.array
+        val ident = augAssign.target.identifier
+        val memory = augAssign.target.memory
+        val array = augAssign.target.array
 
         return if(ident!=null) {
-            assignVarAugmented(ident.name, assignment)
+            assignVarAugmented(ident.name, augAssign)
         } else if(memory != null) {
             if(memory.address is PtNumber)
-                assignMemoryAugmented((memory.address as PtNumber).number.toInt(), assignment)
+                assignMemoryAugmented((memory.address as PtNumber).number.toInt(), augAssign)
             else
-                fallbackAssign(assignment)
+                fallbackAssign(augAssign)
         } else if(array!=null) {
             // NOTE: naive fallback assignment here will sometimes generate code that loads the index value multiple times
             // in a register. It's way too much work to optimize that here - instead, we trust that the generated IL assembly
             // will be optimized later and have the double assignments removed.
-            fallbackAssign(assignment)
+            fallbackAssign(augAssign)
         } else {
-            fallbackAssign(assignment)
+            fallbackAssign(augAssign)
         }
     }
 
@@ -50,7 +46,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         assignment: PtAugmentedAssign
     ): IRCodeChunks {
         val value = assignment.value
-        val vmDt = codeGen.irType(value.type)
+        val vmDt = irType(value.type)
         return when(assignment.operator) {
             "+" -> expressionEval.operatorPlusInplace(address, null, vmDt, value)
             "-" -> expressionEval.operatorMinusInplace(address, null, vmDt, value)
@@ -61,25 +57,40 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             "^" -> expressionEval.operatorXorInplace(address, null, vmDt, value)
             "<<" -> expressionEval.operatorShiftLeftInplace(address, null, vmDt, value)
             ">>" -> expressionEval.operatorShiftRightInplace(address, null, vmDt, value.type in SignedDatatypes, value)
+            "%=" -> expressionEval.operatorModuloInplace(address, null, vmDt, value)
+            "==" -> expressionEval.operatorEqualsInplace(address, null, vmDt, value)
+            "!=" -> expressionEval.operatorNotEqualsInplace(address, null, vmDt, value)
+            "<" -> expressionEval.operatorLessInplace(address, null, vmDt, value.type in SignedDatatypes, value)
+            ">" -> expressionEval.operatorGreaterInplace(address, null, vmDt, value.type in SignedDatatypes, value)
+            "<=" -> expressionEval.operatorLessEqualInplace(address, null, vmDt, value.type in SignedDatatypes, value)
+            ">=" -> expressionEval.operatorGreaterEqualInplace(address, null, vmDt, value.type in SignedDatatypes, value)
             in PrefixOperators -> inplacePrefix(assignment.operator, vmDt, address, null)
+
             else -> throw AssemblyError("invalid augmented assign operator ${assignment.operator}")
         }
     }
 
     private fun assignVarAugmented(symbol: String, assignment: PtAugmentedAssign): IRCodeChunks {
         val value = assignment.value
-        val valueVmDt = codeGen.irType(value.type)
+        val targetDt = irType(assignment.target.type)
         return when (assignment.operator) {
-            "+=" -> expressionEval.operatorPlusInplace(null, symbol, valueVmDt, value)
-            "-=" -> expressionEval.operatorMinusInplace(null, symbol, valueVmDt, value)
-            "*=" -> expressionEval.operatorMultiplyInplace(null, symbol, valueVmDt, value)
-            "/=" -> expressionEval.operatorDivideInplace(null, symbol, valueVmDt, value.type in SignedDatatypes, value)
-            "|=" -> expressionEval.operatorOrInplace(null, symbol, valueVmDt, value)
-            "&=" -> expressionEval.operatorAndInplace(null, symbol, valueVmDt, value)
-            "^=" -> expressionEval.operatorXorInplace(null, symbol, valueVmDt, value)
-            "<<=" -> expressionEval.operatorShiftLeftInplace(null, symbol, valueVmDt, value)
-            ">>=" -> expressionEval.operatorShiftRightInplace(null, symbol, valueVmDt, value.type in SignedDatatypes, value)
-            in PrefixOperators -> inplacePrefix(assignment.operator, valueVmDt, null, symbol)
+            "+=" -> expressionEval.operatorPlusInplace(null, symbol, targetDt, value)
+            "-=" -> expressionEval.operatorMinusInplace(null, symbol, targetDt, value)
+            "*=" -> expressionEval.operatorMultiplyInplace(null, symbol, targetDt, value)
+            "/=" -> expressionEval.operatorDivideInplace(null, symbol, targetDt, value.type in SignedDatatypes, value)
+            "|=" -> expressionEval.operatorOrInplace(null, symbol, targetDt, value)
+            "&=" -> expressionEval.operatorAndInplace(null, symbol, targetDt, value)
+            "^=" -> expressionEval.operatorXorInplace(null, symbol, targetDt, value)
+            "<<=" -> expressionEval.operatorShiftLeftInplace(null, symbol, targetDt, value)
+            ">>=" -> expressionEval.operatorShiftRightInplace(null, symbol, targetDt, value.type in SignedDatatypes, value)
+            "%=" -> expressionEval.operatorModuloInplace(null, symbol, targetDt, value)
+            "==" -> expressionEval.operatorEqualsInplace(null, symbol, targetDt, value)
+            "!=" -> expressionEval.operatorNotEqualsInplace(null, symbol, targetDt, value)
+            "<" -> expressionEval.operatorLessInplace(null, symbol, targetDt, value.type in SignedDatatypes, value)
+            ">" -> expressionEval.operatorGreaterInplace(null, symbol, targetDt, value.type in SignedDatatypes, value)
+            "<=" -> expressionEval.operatorLessEqualInplace(null, symbol, targetDt, value.type in SignedDatatypes, value)
+            ">=" -> expressionEval.operatorGreaterEqualInplace(null, symbol, targetDt, value.type in SignedDatatypes, value)
+            in PrefixOperators -> inplacePrefix(assignment.operator, targetDt, null, symbol)
             else -> throw AssemblyError("invalid augmented assign operator ${assignment.operator}")
         }
     }
@@ -87,19 +98,36 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
     private fun fallbackAssign(origAssign: PtAugmentedAssign): IRCodeChunks {
         if (codeGen.options.slowCodegenWarnings)
             codeGen.errors.warn("indirect code for in-place assignment", origAssign.position)
-        val normalAssign = PtAssignment(origAssign.position)
-        normalAssign.add(origAssign.target)
         val value: PtExpression
         if(origAssign.operator in PrefixOperators) {
             value = PtPrefix(origAssign.operator, origAssign.value.type, origAssign.value.position)
             value.add(origAssign.value)
         } else {
             require(origAssign.operator.endsWith('='))
-            value = PtBinaryExpression(origAssign.operator.dropLast(1), origAssign.value.type, origAssign.value.position)
-            val left: PtExpression = origAssign.target.children.single() as PtExpression
-            value.add(left)
-            value.add(origAssign.value)
+            if(codeGen.options.useNewExprCode) {
+                // X += Y  ->   temp = X,  temp += Y,  X = temp
+                val tempvar = codeGen.getReusableTempvar(origAssign.definingSub()!!, origAssign.target.type)
+                val assign = PtAssignment(origAssign.position)
+                val target = PtAssignTarget(origAssign.position)
+                target.add(tempvar)
+                assign.add(target)
+                assign.add(origAssign.target.children.single())
+                val augAssign = PtAugmentedAssign(origAssign.operator, origAssign.position)
+                augAssign.add(target)
+                augAssign.add(origAssign.value)
+                val assignBack = PtAssignment(origAssign.position)
+                assignBack.add(origAssign.target)
+                assignBack.add(tempvar)
+                return translateRegularAssign(assign) + translate(augAssign) + translateRegularAssign(assignBack)
+            } else {
+                value = PtBinaryExpression(origAssign.operator.dropLast(1), origAssign.value.type, origAssign.value.position)
+                val left: PtExpression = origAssign.target.children.single() as PtExpression
+                value.add(left)
+                value.add(origAssign.value)
+            }
         }
+        val normalAssign = PtAssignment(origAssign.position)
+        normalAssign.add(origAssign.target)
         normalAssign.add(value)
         return translateRegularAssign(normalAssign)
     }
@@ -110,16 +138,16 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             "+" -> { }
             "-" -> {
                 code += if(address!=null)
-                    IRInstruction(Opcode.NEGM, vmDt, value = address)
+                    IRInstruction(Opcode.NEGM, vmDt, address = address)
                 else
                     IRInstruction(Opcode.NEGM, vmDt, labelSymbol = symbol)
             }
             "~" -> {
                 val regMask = codeGen.registers.nextFree()
                 val mask = if(vmDt==IRDataType.BYTE) 0x00ff else 0xffff
-                code += IRInstruction(Opcode.LOAD, vmDt, reg1=regMask, value = mask)
+                code += IRInstruction(Opcode.LOAD, vmDt, reg1=regMask, immediate = mask)
                 code += if(address!=null)
-                    IRInstruction(Opcode.XORM, vmDt, reg1=regMask, value = address)
+                    IRInstruction(Opcode.XORM, vmDt, reg1=regMask, address = address)
                 else
                     IRInstruction(Opcode.XORM, vmDt, reg1=regMask, labelSymbol = symbol)
             }
@@ -130,119 +158,139 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
 
     private fun translateRegularAssign(assignment: PtAssignment): IRCodeChunks {
         // note: assigning array and string values is done via an explicit memcopy/stringcopy function call.
-        val ident = assignment.target.identifier
-        val memory = assignment.target.memory
-        val array = assignment.target.array
-        val vmDt = codeGen.irType(assignment.value.type)
+        val targetIdent = assignment.target.identifier
+        val targetMemory = assignment.target.memory
+        val targetArray = assignment.target.array
+        val valueDt = irType(assignment.value.type)
+        val targetDt = irType(assignment.target.type)
         val result = mutableListOf<IRCodeChunkBase>()
-        var resultRegister = -1
-        var resultFpRegister = -1
+
+        var valueRegister = -1
+        var valueFpRegister = -1
         val zero = codeGen.isZero(assignment.value)
         if(!zero) {
             // calculate the assignment value
-            if (vmDt == IRDataType.FLOAT) {
-                resultFpRegister = codeGen.registers.nextFreeFloat()
-                result += expressionEval.translateExpression(assignment.value, -1, resultFpRegister)
+            if (valueDt == IRDataType.FLOAT) {
+                val tr = expressionEval.translateExpression(assignment.value)
+                valueFpRegister = tr.resultFpReg
+                addToResult(result, tr, -1, valueFpRegister)
             } else {
-                resultRegister = if (assignment.value is PtMachineRegister) {
-                    (assignment.value as PtMachineRegister).register
+                val extendByteToWord = if(targetDt != valueDt) {
+                    // usually an error EXCEPT when a byte is assigned to a word.
+                    if(targetDt==IRDataType.WORD && valueDt==IRDataType.BYTE)
+                        true
+                    else
+                        throw AssemblyError("assignment value and target dt mismatch")
+                } else false
+                if (assignment.value is PtMachineRegister) {
+                    valueRegister = (assignment.value as PtMachineRegister).register
+                    if(extendByteToWord)
+                        addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=valueRegister), null)
                 } else {
-                    val reg = codeGen.registers.nextFree()
-                    result += expressionEval.translateExpression(assignment.value, reg, -1)
-                    reg
+                    val tr = expressionEval.translateExpression(assignment.value)
+                    valueRegister = tr.resultReg
+                    addToResult(result, tr, valueRegister, -1)
+                    if(extendByteToWord) {
+                        val opcode = if(assignment.value.type in SignedDatatypes) Opcode.EXTS else Opcode.EXT
+                        addInstr(result, IRInstruction(opcode, IRDataType.BYTE, reg1 = valueRegister), null)
+                    }
                 }
             }
         }
-        if(ident!=null) {
+
+        if(targetIdent!=null) {
             val instruction = if(zero) {
-                IRInstruction(Opcode.STOREZM, vmDt, labelSymbol = ident.name)
+                IRInstruction(Opcode.STOREZM, targetDt, labelSymbol = targetIdent.name)
             } else {
-                if (vmDt == IRDataType.FLOAT)
-                    IRInstruction(Opcode.STOREM, vmDt, fpReg1 = resultFpRegister, labelSymbol = ident.name)
+                if (targetDt == IRDataType.FLOAT)
+                    IRInstruction(Opcode.STOREM, targetDt, fpReg1 = valueFpRegister, labelSymbol = targetIdent.name)
                 else
-                    IRInstruction(Opcode.STOREM, vmDt, reg1 = resultRegister, labelSymbol = ident.name)
+                    IRInstruction(Opcode.STOREM, targetDt, reg1 = valueRegister, labelSymbol = targetIdent.name)
             }
             result += IRCodeChunk(null, null).also { it += instruction }
             return result
         }
-        else if(array!=null) {
-            val variable = array.variable.name
-            val itemsize = codeGen.program.memsizer.memorySize(array.type)
+        else if(targetArray!=null) {
+            val variable = targetArray.variable.name
+            val itemsize = codeGen.program.memsizer.memorySize(targetArray.type)
 
-            if(array.variable.type==DataType.UWORD) {
+            if(targetArray.variable.type==DataType.UWORD) {
                 // indexing a pointer var instead of a real array or string
                 if(itemsize!=1)
                     throw AssemblyError("non-array var indexing requires bytes dt")
-                if(array.index.type!=DataType.UBYTE)
+                if(targetArray.index.type!=DataType.UBYTE)
                     throw AssemblyError("non-array var indexing requires bytes index")
-                val idxReg = codeGen.registers.nextFree()
-                result += expressionEval.translateExpression(array.index, idxReg, -1)
+                val tr = expressionEval.translateExpression(targetArray.index)
+                val idxReg = tr.resultReg
+                addToResult(result, tr, tr.resultReg, -1)
                 val code = IRCodeChunk(null, null)
                 if(zero) {
                     // there's no STOREZIX instruction
-                    resultRegister = codeGen.registers.nextFree()
-                    code += IRInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=0)
+                    valueRegister = codeGen.registers.nextFree()
+                    code += IRInstruction(Opcode.LOAD, targetDt, reg1=valueRegister, immediate = 0)
                 }
-                code += IRInstruction(Opcode.STOREIX, vmDt, reg1=resultRegister, reg2=idxReg, labelSymbol = variable)
+                code += IRInstruction(Opcode.STOREIX, targetDt, reg1=valueRegister, reg2=idxReg, labelSymbol = variable)
                 result += code
                 return result
             }
 
-            val fixedIndex = constIntValue(array.index)
+            val fixedIndex = constIntValue(targetArray.index)
             if(zero) {
                 if(fixedIndex!=null) {
                     val offset = fixedIndex*itemsize
-                    val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZM, vmDt, labelSymbol = "$variable+$offset") }
+                    val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZM, targetDt, labelSymbol = "$variable+$offset") }
                     result += chunk
                 } else {
-                    val indexReg = codeGen.registers.nextFree()
-                    result += loadIndexReg(array, itemsize, indexReg)
-                    result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZX, vmDt, reg1=indexReg, labelSymbol = variable) }
+                    val (code, indexReg) = loadIndexReg(targetArray, itemsize)
+                    result += code
+                    result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZX, targetDt, reg1=indexReg, labelSymbol = variable) }
                 }
             } else {
-                if(vmDt== IRDataType.FLOAT) {
+                if(targetDt== IRDataType.FLOAT) {
                     if(fixedIndex!=null) {
                         val offset = fixedIndex*itemsize
-                        val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREM, vmDt, fpReg1 = resultFpRegister, labelSymbol = "$variable+$offset") }
+                        val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREM, targetDt, fpReg1 = valueFpRegister, labelSymbol = "$variable+$offset") }
                         result += chunk
                     } else {
-                        val indexReg = codeGen.registers.nextFree()
-                        result += loadIndexReg(array, itemsize, indexReg)
-                        result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREX, vmDt, reg1 = indexReg, fpReg1 = resultFpRegister, labelSymbol = variable) }
+                        val (code, indexReg) = loadIndexReg(targetArray, itemsize)
+                        result += code
+                        result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREX, targetDt, reg1 = indexReg, fpReg1 = valueFpRegister, labelSymbol = variable) }
                     }
                 } else {
                     if(fixedIndex!=null) {
                         val offset = fixedIndex*itemsize
-                        val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREM, vmDt, reg1 = resultRegister, labelSymbol = "$variable+$offset") }
+                        val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREM, targetDt, reg1 = valueRegister, labelSymbol = "$variable+$offset") }
                         result += chunk
                     } else {
-                        val indexReg = codeGen.registers.nextFree()
-                        result += loadIndexReg(array, itemsize, indexReg)
-                        result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREX, vmDt, reg1 = resultRegister, reg2=indexReg, labelSymbol = variable) }
+                        val (code, indexReg) = loadIndexReg(targetArray, itemsize)
+                        result += code
+                        result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREX, targetDt, reg1 = valueRegister, reg2=indexReg, labelSymbol = variable) }
                     }
                 }
             }
             return result
         }
-        else if(memory!=null) {
-            require(vmDt== IRDataType.BYTE) { "must be byte type ${memory.position}"}
+        else if(targetMemory!=null) {
+            require(targetDt == IRDataType.BYTE) { "must be byte type ${targetMemory.position}"}
             if(zero) {
-                if(memory.address is PtNumber) {
-                    val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZM, vmDt, value=(memory.address as PtNumber).number.toInt()) }
+                if(targetMemory.address is PtNumber) {
+                    val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZM, targetDt, address = (targetMemory.address as PtNumber).number.toInt()) }
                     result += chunk
                 } else {
-                    val addressReg = codeGen.registers.nextFree()
-                    result += expressionEval.translateExpression(memory.address, addressReg, -1)
-                    result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZI, vmDt, reg1=addressReg) }
+                    val tr = expressionEval.translateExpression(targetMemory.address)
+                    val addressReg = tr.resultReg
+                    addToResult(result, tr, tr.resultReg, -1)
+                    result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZI, targetDt, reg1=addressReg) }
                 }
             } else {
-                if(memory.address is PtNumber) {
-                    val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREM, vmDt, reg1=resultRegister, value=(memory.address as PtNumber).number.toInt()) }
+                if(targetMemory.address is PtNumber) {
+                    val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREM, targetDt, reg1=valueRegister, address=(targetMemory.address as PtNumber).number.toInt()) }
                     result += chunk
                 } else {
-                    val addressReg = codeGen.registers.nextFree()
-                    result += expressionEval.translateExpression(memory.address, addressReg, -1)
-                    result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREI, vmDt, reg1=resultRegister, reg2=addressReg) }
+                    val tr = expressionEval.translateExpression(targetMemory.address)
+                    val addressReg = tr.resultReg
+                    addToResult(result, tr, tr.resultReg, -1)
+                    result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREI, targetDt, reg1=valueRegister, reg2=addressReg) }
                 }
             }
 
@@ -252,14 +300,29 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             throw AssemblyError("weird assigntarget")
     }
 
-    private fun loadIndexReg(array: PtArrayIndexer, itemsize: Int, indexReg: Int): IRCodeChunks {
-        return if(itemsize==1) {
-            expressionEval.translateExpression(array.index, indexReg, -1)
+    private fun loadIndexReg(array: PtArrayIndexer, itemsize: Int): Pair<IRCodeChunks, Int> {
+        // returns the code to load the Index into the register, which is also return\ed.
+
+        val result = mutableListOf<IRCodeChunkBase>()
+        if(itemsize==1) {
+            val tr = expressionEval.translateExpression(array.index)
+            addToResult(result, tr, tr.resultReg, -1)
+            return Pair(result, tr.resultReg)
+        }
+
+        if(codeGen.options.useNewExprCode) {
+            val tr = expressionEval.translateExpression(array.index)
+            result += tr.chunks
+            addInstr(result, IRInstruction(Opcode.MUL, tr.dt, reg1=tr.resultReg, immediate = itemsize), null)
+            return Pair(result, tr.resultReg)
         } else {
-            val mult = PtBinaryExpression("*", DataType.UBYTE, array.position)
+            val mult: PtExpression
+            mult = PtBinaryExpression("*", DataType.UBYTE, array.position)
             mult.children += array.index
             mult.children += PtNumber(DataType.UBYTE, itemsize.toDouble(), array.position)
-            expressionEval.translateExpression(mult, indexReg, -1)
+            val tr = expressionEval.translateExpression(mult)
+            addToResult(result, tr, tr.resultReg, -1)
+            return Pair(result, tr.resultReg)
         }
     }
 }

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

@@ -9,14 +9,16 @@ import prog8.intermediate.*
 
 internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGen: ExpressionGen) {
 
-    fun translate(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
+    fun translate(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         return when(call.name) {
-            "any" -> funcAny(call, resultRegister)
-            "all" -> funcAll(call, resultRegister)
-            "abs" -> funcAbs(call, resultRegister)
+            "any" -> funcAny(call)
+            "all" -> funcAll(call)
+            "abs" -> funcAbs(call)
             "cmp" -> funcCmp(call)
-            "sgn" -> funcSgn(call, resultRegister)
-            "sqrt16" -> funcSqrt16(call, resultRegister)
+            "sgn" -> funcSgn(call)
+            "sqrt16" -> funcSqrt16(call)
+            "divmod" -> funcDivmod(call, IRDataType.BYTE)
+            "divmodw" -> funcDivmod(call, IRDataType.WORD)
             "pop" -> funcPop(call)
             "popw" -> funcPopw(call)
             "push" -> funcPush(call)
@@ -24,40 +26,81 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
             "rsave",
             "rsavex",
             "rrestore",
-            "rrestorex" -> emptyList()  // vm doesn't have registers to save/restore
+            "rrestorex" -> ExpressionCodeResult.EMPTY  // vm doesn't have registers to save/restore
             "callfar" -> throw AssemblyError("callfar() is for cx16 target only")
-            "msb" -> funcMsb(call, resultRegister)
-            "lsb" -> funcLsb(call, resultRegister)
-            "memory" -> funcMemory(call, resultRegister)
-            "peek" -> funcPeek(call, resultRegister)
-            "peekw" -> funcPeekW(call, resultRegister)
+            "msb" -> funcMsb(call)
+            "lsb" -> funcLsb(call)
+            "memory" -> funcMemory(call)
+            "peek" -> funcPeek(call)
+            "peekw" -> funcPeekW(call)
             "poke" -> funcPoke(call)
             "pokew" -> funcPokeW(call)
-            "pokemon" -> emptyList()
-            "mkword" -> funcMkword(call, resultRegister)
+            "pokemon" -> ExpressionCodeResult.EMPTY     // easter egg function
+            "mkword" -> funcMkword(call)
             "sort" -> funcSort(call)
             "reverse" -> funcReverse(call)
-            "rol" -> funcRolRor(Opcode.ROXL, call, resultRegister)
-            "ror" -> funcRolRor(Opcode.ROXR, call, resultRegister)
-            "rol2" -> funcRolRor(Opcode.ROL, call, resultRegister)
-            "ror2" -> funcRolRor(Opcode.ROR, call, resultRegister)
+            "rol" -> funcRolRor(Opcode.ROXL, call)
+            "ror" -> funcRolRor(Opcode.ROXR, call)
+            "rol2" -> funcRolRor(Opcode.ROL, call)
+            "ror2" -> funcRolRor(Opcode.ROR, call)
+            "prog8_lib_stringcompare" -> funcStringCompare(call)
             else -> throw AssemblyError("missing builtinfunc for ${call.name}")
         }
     }
 
-    private fun funcCmp(call: PtBuiltinFunctionCall): IRCodeChunks {
-        val leftRegister = codeGen.registers.nextFree()
-        val rightRegister = codeGen.registers.nextFree()
+    private fun funcDivmod(call: PtBuiltinFunctionCall, type: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args[0], leftRegister, -1)
-        result += exprGen.translateExpression(call.args[1], rightRegister, -1)
-        result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.CMP, codeGen.irType(call.args[0].type), reg1=leftRegister, reg2=rightRegister)
+        val number = call.args[0]
+        val divident = call.args[1]
+        val divisionReg: Int
+        val remainderReg: Int
+        if(divident is PtNumber) {
+            val tr = exprGen.translateExpression(number)
+            addToResult(result, tr, tr.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.DIVMOD, type, reg1 = tr.resultReg, immediate = divident.number.toInt()), null)
+            divisionReg = tr.resultReg
+            remainderReg = codeGen.registers.nextFree()
+        } else {
+            val numTr = exprGen.translateExpression(number)
+            addToResult(result, numTr, numTr.resultReg, -1)
+            val dividentTr = exprGen.translateExpression(divident)
+            addToResult(result, dividentTr, dividentTr.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.DIVMODR, type, reg1 = numTr.resultReg, reg2=dividentTr.resultReg), null)
+            divisionReg = numTr.resultReg
+            remainderReg = dividentTr.resultReg
         }
-        return result
+        // DIVMOD result convention: on value stack, division and remainder on top.
+        addInstr(result, IRInstruction(Opcode.POP, type, reg1=remainderReg), null)
+        addInstr(result, IRInstruction(Opcode.POP, type, reg1=divisionReg), null)
+        result += assignRegisterTo(call.args[2], divisionReg)
+        result += assignRegisterTo(call.args[3], remainderReg)
+        return ExpressionCodeResult(result, type, -1, -1)
     }
 
-    private fun funcAny(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
+    private fun funcStringCompare(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val left  = exprGen.translateExpression(call.args[0])
+        val right = exprGen.translateExpression(call.args[1])
+        addToResult(result, left, left.resultReg, -1)
+        addToResult(result, right, right.resultReg, -1)
+        result += codeGen.makeSyscall(IMSyscall.COMPARE_STRINGS, listOf(IRDataType.WORD to left.resultReg, IRDataType.WORD to right.resultReg), IRDataType.BYTE to left.resultReg)
+        return ExpressionCodeResult(result, IRDataType.BYTE, left.resultReg, -1)
+    }
+
+    private fun funcCmp(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val leftTr = exprGen.translateExpression(call.args[0])
+        addToResult(result, leftTr, leftTr.resultReg, -1)
+        val rightTr = exprGen.translateExpression(call.args[1])
+        addToResult(result, rightTr, rightTr.resultReg, -1)
+        val dt = irType(call.args[0].type)
+        result += IRCodeChunk(null, null).also {
+            it += IRInstruction(Opcode.CMP, dt, reg1=leftTr.resultReg, reg2=rightTr.resultReg)
+        }
+        return ExpressionCodeResult(result, dt, leftTr.resultReg, -1)
+    }
+
+    private fun funcAny(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
         val array = codeGen.symbolTable.flat.getValue(arrayName.name) as StStaticVariable
         val syscall =
@@ -70,17 +113,15 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type")
             }
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args[0], SyscallRegisterBase, -1)
-        result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = SyscallRegisterBase+1, value = array.length)
-            it += IRInstruction(Opcode.SYSCALL, value = syscall.number)
-            if(resultRegister!=0)
-                it += IRInstruction(Opcode.LOADR, IRDataType.BYTE, reg1 = resultRegister, reg2 = 0)
-        }
-        return result
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
+        val lengthReg = codeGen.registers.nextFree()
+        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = array.length), null)
+        result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to tr.resultReg)
+        return ExpressionCodeResult(result, IRDataType.BYTE, tr.resultReg, -1)
     }
 
-    private fun funcAll(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
+    private fun funcAll(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
         val array = codeGen.symbolTable.flat.getValue(arrayName.name) as StStaticVariable
         val syscall =
@@ -93,115 +134,120 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type")
             }
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args[0], SyscallRegisterBase, -1)
-        result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = SyscallRegisterBase+1, value = array.length)
-            it += IRInstruction(Opcode.SYSCALL, value = syscall.number)
-            if(resultRegister!=0)
-                it += IRInstruction(Opcode.LOADR, IRDataType.BYTE, reg1 = resultRegister, reg2 = 0)
-        }
-        return result
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
+        val lengthReg = codeGen.registers.nextFree()
+        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = array.length), null)
+        result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to tr.resultReg)
+        return ExpressionCodeResult(result, IRDataType.BYTE, tr.resultReg, -1)
     }
 
-    private fun funcAbs(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
+    private fun funcAbs(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val sourceDt = call.args.single().type
         val result = mutableListOf<IRCodeChunkBase>()
-        if(sourceDt!=DataType.UWORD) {
-            result += exprGen.translateExpression(call.args[0], resultRegister, -1)
-            when (sourceDt) {
-                DataType.UBYTE -> {
-                    result += IRCodeChunk(null, null).also {
-                        it += IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1 = resultRegister)
-                    }
+        if(sourceDt==DataType.UWORD)
+            return ExpressionCodeResult.EMPTY
+
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
+        when (sourceDt) {
+            DataType.UBYTE -> {
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1 = tr.resultReg)
                 }
-                DataType.BYTE -> {
-                    val notNegativeLabel = codeGen.createLabelName()
-                    val compareReg = codeGen.registers.nextFree()
-                    result += IRCodeChunk(null, null).also {
-                        it += IRInstruction(Opcode.LOADR, IRDataType.BYTE, reg1=compareReg, reg2=resultRegister)
-                        it += IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=compareReg, value=0x80)
-                        it += IRInstruction(Opcode.BZ, IRDataType.BYTE, reg1=compareReg, labelSymbol = notNegativeLabel)
-                        it += IRInstruction(Opcode.NEG, IRDataType.BYTE, reg1=resultRegister)
-                        it += IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=resultRegister)
-                    }
-                    result += IRCodeChunk(notNegativeLabel, null)
-                }
-                DataType.WORD -> {
-                    val notNegativeLabel = codeGen.createLabelName()
-                    val compareReg = codeGen.registers.nextFree()
-                    result += IRCodeChunk(null, null).also {
-                        it += IRInstruction(Opcode.LOADR, IRDataType.WORD, reg1=compareReg, reg2=resultRegister)
-                        it += IRInstruction(Opcode.AND, IRDataType.WORD, reg1=compareReg, value=0x8000)
-                        it += IRInstruction(Opcode.BZ, IRDataType.WORD, reg1=compareReg, labelSymbol = notNegativeLabel)
-                        it += IRInstruction(Opcode.NEG, IRDataType.WORD, reg1=resultRegister)
-                    }
-                    result += IRCodeChunk(notNegativeLabel, null)
-                }
-                else -> throw AssemblyError("weird type")
+                return ExpressionCodeResult(result, IRDataType.BYTE, tr.resultReg, -1)
             }
+            DataType.BYTE -> {
+                val notNegativeLabel = codeGen.createLabelName()
+                val compareReg = codeGen.registers.nextFree()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADR, IRDataType.BYTE, reg1=compareReg, reg2=tr.resultReg)
+                    it += IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=compareReg, immediate = 0x80)
+                    it += IRInstruction(Opcode.BEQ, IRDataType.BYTE, reg1=compareReg, immediate = 0, labelSymbol = notNegativeLabel)
+                    it += IRInstruction(Opcode.NEG, IRDataType.BYTE, reg1=tr.resultReg)
+                    it += IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=tr.resultReg)
+                }
+                result += IRCodeChunk(notNegativeLabel, null)
+                return ExpressionCodeResult(result, IRDataType.BYTE, tr.resultReg, -1)
+            }
+            DataType.WORD -> {
+                val notNegativeLabel = codeGen.createLabelName()
+                val compareReg = codeGen.registers.nextFree()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADR, IRDataType.WORD, reg1=compareReg, reg2=tr.resultReg)
+                    it += IRInstruction(Opcode.AND, IRDataType.WORD, reg1=compareReg, immediate = 0x8000)
+                    it += IRInstruction(Opcode.BEQ, IRDataType.WORD, reg1=compareReg, immediate = 0, labelSymbol = notNegativeLabel)
+                    it += IRInstruction(Opcode.NEG, IRDataType.WORD, reg1=tr.resultReg)
+                }
+                result += IRCodeChunk(notNegativeLabel, null)
+                return ExpressionCodeResult(result, IRDataType.WORD, tr.resultReg, -1)
+            }
+            else -> throw AssemblyError("weird type")
         }
-        return result
     }
 
-    private fun funcSgn(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
-        val reg = codeGen.registers.nextFree()
+    private fun funcSgn(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args.single(), reg, -1)
+        val vmDt = irType(call.type)
+        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.SGN, codeGen.irType(call.type), reg1 = resultRegister, reg2 = reg)
+            it += IRInstruction(Opcode.SGN, vmDt, reg1 = resultReg, reg2 = tr.resultReg)
         }
-        return result
+        return ExpressionCodeResult(result, vmDt, resultReg, -1)
     }
 
-    private fun funcSqrt16(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
-        val reg = codeGen.registers.nextFree()
+    private fun funcSqrt16(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args.single(), reg, -1)
+        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.SQRT, IRDataType.WORD, reg1=resultRegister, reg2=reg)
+            it += IRInstruction(Opcode.SQRT, IRDataType.WORD, reg1=resultReg, reg2=tr.resultReg)
         }
-        return result
+        return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
     }
 
-    private fun funcPop(call: PtBuiltinFunctionCall): IRCodeChunks {
+    private fun funcPop(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val code = IRCodeChunk(null, null)
         val reg = codeGen.registers.nextFree()
         code += IRInstruction(Opcode.POP, IRDataType.BYTE, reg1=reg)
         val result = mutableListOf<IRCodeChunkBase>(code)
         result += assignRegisterTo(call.args.single(), reg)
-        return result
+        return ExpressionCodeResult(result, IRDataType.BYTE, reg, -1)
     }
 
-    private fun funcPopw(call: PtBuiltinFunctionCall): IRCodeChunks {
+    private fun funcPopw(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val code = IRCodeChunk(null, null)
         val reg = codeGen.registers.nextFree()
         code += IRInstruction(Opcode.POP, IRDataType.WORD, reg1=reg)
         val result = mutableListOf<IRCodeChunkBase>(code)
         result += assignRegisterTo(call.args.single(), reg)
-        return result
+        return ExpressionCodeResult(result, IRDataType.WORD, reg, -1)
     }
 
-    private fun funcPush(call: PtBuiltinFunctionCall): IRCodeChunks {
+    private fun funcPush(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        val reg = codeGen.registers.nextFree()
-        result += exprGen.translateExpression(call.args.single(), reg, -1)
+        val tr = exprGen.translateExpression(call.args.single())
+        addToResult(result, tr, tr.resultReg, -1)
         result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.PUSH, IRDataType.BYTE, reg1=reg)
+            it += IRInstruction(Opcode.PUSH, IRDataType.BYTE, reg1=tr.resultReg)
         }
-        return result
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcPushw(call: PtBuiltinFunctionCall): IRCodeChunks {
+    private fun funcPushw(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        val reg = codeGen.registers.nextFree()
-        result += exprGen.translateExpression(call.args.single(), reg, -1)
+        val tr = exprGen.translateExpression(call.args.single())
+        addToResult(result, tr, tr.resultReg, -1)
         result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.PUSH, IRDataType.WORD, reg1 = reg)
+            it += IRInstruction(Opcode.PUSH, IRDataType.WORD, reg1 = tr.resultReg)
         }
-        return result
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcReverse(call: PtBuiltinFunctionCall): IRCodeChunks {
+    private fun funcReverse(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
         val array = codeGen.symbolTable.flat.getValue(arrayName.name) as StStaticVariable
         val syscall =
@@ -212,15 +258,15 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type to reverse")
             }
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args[0], SyscallRegisterBase, -1)
-        result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = SyscallRegisterBase+1, value = array.length)
-            it += IRInstruction(Opcode.SYSCALL, value = syscall.number)
-        }
-        return result
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
+        val lengthReg = codeGen.registers.nextFree()
+        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(array.dt==DataType.STR) array.length!!-1 else array.length), null)
+        result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcSort(call: PtBuiltinFunctionCall): IRCodeChunks {
+    private fun funcSort(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
         val array = codeGen.symbolTable.flat.getValue(arrayName.name) as StStaticVariable
         val syscall =
@@ -234,160 +280,173 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type to sort")
             }
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args[0], SyscallRegisterBase, -1)
-        result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = SyscallRegisterBase+1, value = array.length)
-            it += IRInstruction(Opcode.SYSCALL, value = syscall.number)
-        }
-        return result
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
+        val lengthReg = codeGen.registers.nextFree()
+        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(array.dt==DataType.STR) array.length!!-1 else array.length), null)
+        result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), null)
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcMkword(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
-        val msbReg = codeGen.registers.nextFree()
+    private fun funcMkword(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args[0], msbReg, -1)
-        result += exprGen.translateExpression(call.args[1], resultRegister, -1)
+        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)
         result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1 = resultRegister, reg2 = msbReg)
+            it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1 = lsbTr.resultReg, reg2 = msbTr.resultReg)
         }
-        return result
+        return ExpressionCodeResult(result, IRDataType.WORD, lsbTr.resultReg, -1)
     }
 
-    private fun funcPokeW(call: PtBuiltinFunctionCall): IRCodeChunks {
+    private fun funcPokeW(call: PtBuiltinFunctionCall): 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, value = address)
+                    it += IRInstruction(Opcode.STOREZM, IRDataType.WORD, address = address)
                 }
             } else {
-                val addressReg = codeGen.registers.nextFree()
-                result += exprGen.translateExpression(call.args[0], addressReg, -1)
+                val tr = exprGen.translateExpression(call.args[0])
+                addToResult(result, tr, tr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZI, IRDataType.WORD, reg2 = addressReg)
+                    it += IRInstruction(Opcode.STOREZI, IRDataType.WORD, reg1 = tr.resultReg)
                 }
             }
         } else {
-            val valueReg = codeGen.registers.nextFree()
             if (call.args[0] is PtNumber) {
                 val address = (call.args[0] as PtNumber).number.toInt()
-                result += exprGen.translateExpression(call.args[1], valueReg, -1)
+                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 = valueReg, value = address)
+                    it += IRInstruction(Opcode.STOREM, IRDataType.WORD, reg1 = tr.resultReg, address = address)
                 }
             } else {
-                val addressReg = codeGen.registers.nextFree()
-                result += exprGen.translateExpression(call.args[0], addressReg, -1)
-                result += exprGen.translateExpression(call.args[1], valueReg, -1)
+                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 = valueReg, reg2 = addressReg)
+                    it += IRInstruction(Opcode.STOREI, IRDataType.WORD, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
                 }
             }
         }
-        return result
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcPoke(call: PtBuiltinFunctionCall): IRCodeChunks {
+    private fun funcPoke(call: PtBuiltinFunctionCall): 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.BYTE, value = address)
+                    it += IRInstruction(Opcode.STOREZM, IRDataType.BYTE, address = address)
                 }
             } else {
-                val addressReg = codeGen.registers.nextFree()
-                result += exprGen.translateExpression(call.args[0], addressReg, -1)
+                val tr = exprGen.translateExpression(call.args[0])
+                addToResult(result, tr, tr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg2 = addressReg)
+                    it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = tr.resultReg)
                 }
             }
         } else {
-            val valueReg = codeGen.registers.nextFree()
             if (call.args[0] is PtNumber) {
                 val address = (call.args[0] as PtNumber).number.toInt()
-                result += exprGen.translateExpression(call.args[1], valueReg, -1)
+                val tr = exprGen.translateExpression(call.args[1])
+                addToResult(result, tr, tr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = valueReg, value = address)
+                    it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = tr.resultReg, address = address)
                 }
             } else {
-                val addressReg = codeGen.registers.nextFree()
-                result += exprGen.translateExpression(call.args[0], addressReg, -1)
-                result += exprGen.translateExpression(call.args[1], valueReg, -1)
+                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.BYTE, reg1 = valueReg, reg2 = addressReg)
+                    it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
                 }
             }
         }
-        return result
+        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcPeekW(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
+    private fun funcPeekW(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        if(call.args[0] is PtNumber) {
+        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.WORD, reg1 = resultRegister, value = address)
+                it += IRInstruction(Opcode.LOADM, IRDataType.WORD, reg1 = resultRegister, address = address)
             }
+            ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
         } else {
-            val addressReg = codeGen.registers.nextFree()
-            result += exprGen.translateExpression(call.args.single(), addressReg, -1)
+            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.WORD, reg1 = resultRegister, reg2 = addressReg)
+                it += IRInstruction(Opcode.LOADI, IRDataType.WORD, reg1 = resultReg, reg2 = tr.resultReg)
             }
+            ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
         }
-        return result
     }
 
-    private fun funcPeek(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
+    private fun funcPeek(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        if(call.args[0] is PtNumber) {
+        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, value = address)
+                it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1 = resultRegister, address = address)
             }
+            ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
         } else {
-            val addressReg = codeGen.registers.nextFree()
-            result += exprGen.translateExpression(call.args.single(), addressReg, -1)
+            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 = resultRegister, reg2 = addressReg)
+                it += IRInstruction(Opcode.LOADI, IRDataType.BYTE, reg1 = resultReg, reg2 = tr.resultReg)
             }
+            ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
         }
-        return result
     }
 
-    private fun funcMemory(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
+    private fun funcMemory(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val name = (call.args[0] as PtString).value
         val code = IRCodeChunk(null, null)
-        code += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1=resultRegister, labelSymbol = "prog8_slabs.prog8_memoryslab_$name")
-        return listOf(code)
+        val resultReg = codeGen.registers.nextFree()
+        code += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1=resultReg, labelSymbol = "prog8_slabs.prog8_memoryslab_$name")
+        return ExpressionCodeResult(code, IRDataType.BYTE, resultReg, -1)
     }
 
-    private fun funcLsb(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
-        return exprGen.translateExpression(call.args.single(), resultRegister, -1)
+    private fun funcLsb(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        return exprGen.translateExpression(call.args.single())
         // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
     }
 
-    private fun funcMsb(call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
+    private fun funcMsb(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args.single(), resultRegister, -1)
+        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.MSIG, IRDataType.BYTE, reg1 = resultRegister, reg2 = resultRegister)
+            it += IRInstruction(Opcode.MSIG, IRDataType.BYTE, reg1 = resultReg, reg2 = tr.resultReg)
         }
         // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
-        return result
+        return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
     }
 
-    private fun funcRolRor(opcode: Opcode, call: PtBuiltinFunctionCall, resultRegister: Int): IRCodeChunks {
-        val vmDt = codeGen.irType(call.args[0].type)
+    private fun funcRolRor(opcode: Opcode, call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val vmDt = irType(call.args[0].type)
         val result = mutableListOf<IRCodeChunkBase>()
-        result += exprGen.translateExpression(call.args[0], resultRegister, -1)
+        val tr = exprGen.translateExpression(call.args[0])
+        addToResult(result, tr, tr.resultReg, -1)
         result += IRCodeChunk(null, null).also {
-            it += IRInstruction(opcode, vmDt, reg1 = resultRegister)
+            it += IRInstruction(opcode, vmDt, reg1 = tr.resultReg)
         }
-        result += assignRegisterTo(call.args[0], resultRegister)
-        return result
+        result += assignRegisterTo(call.args[0], tr.resultReg)
+        return ExpressionCodeResult(result, vmDt, -1, -1)
     }
 
     private fun assignRegisterTo(target: PtExpression, register: Int): IRCodeChunks {

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

@@ -1,10 +1,39 @@
 package prog8.codegen.intermediate
 
+import prog8.code.core.IErrorReporter
 import prog8.intermediate.*
 
-internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
-    fun optimize() {
+class IRPeepholeOptimizer(private val irprog: IRProgram) {
+    fun optimize(optimizationsEnabled: Boolean, errors: IErrorReporter) {
+        if(!optimizationsEnabled)
+            return optimizeOnlyJoinChunks()
+
+        peepholeOptimize()
+        val remover = IRUnusedCodeRemover(irprog, errors)
+        var totalRemovals = 0
+        do {
+            val numRemoved = remover.optimize()
+            totalRemovals += numRemoved
+        } while(numRemoved>0 && errors.noErrors())
+        errors.report()
+
+        if(totalRemovals>0) {
+            irprog.linkChunks()  // re-link again.
+        }
+    }
+
+    private fun optimizeOnlyJoinChunks() {
         irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
+            joinChunks(sub)
+            removeEmptyChunks(sub)
+            joinChunks(sub)
+        }
+        irprog.linkChunks() // re-link
+    }
+
+    private fun peepholeOptimize() {
+        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
+            joinChunks(sub)
             removeEmptyChunks(sub)
             joinChunks(sub)
             sub.chunks.withIndex().forEach { (index, chunk1) ->
@@ -28,7 +57,7 @@ internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
             removeEmptyChunks(sub)
         }
 
-        irprog.linkChunks() // re-link
+        irprog.linkChunks()  // re-link
     }
 
     private fun removeEmptyChunks(sub: IRSubroutine) {
@@ -38,7 +67,7 @@ internal 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: consolidate labels into 1)
+            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 is last chunk -> keep chunk in place because of the label.
         Empty Code chunk without label ->
             should not have been generated! ERROR.
@@ -63,7 +92,7 @@ internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
                             if (chunk.label == nextchunk.label)
                                 removeChunks += index
                             else {
-                                // TODO: consolidate labels on same chunk
+                                // TODO: merge labels on same chunk
                             }
                         }
                     }
@@ -85,7 +114,7 @@ internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
         if(sub.chunks.isEmpty())
             return
 
-        fun mayJoin(previous: IRCodeChunkBase, chunk: IRCodeChunkBase): Boolean {
+        fun mayJoinCodeChunks(previous: IRCodeChunkBase, chunk: IRCodeChunkBase): Boolean {
             if(chunk.label!=null)
                 return false
             if(previous is IRCodeChunk && chunk is IRCodeChunk) {
@@ -102,12 +131,39 @@ internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
         chunks += sub.chunks[0]
         for(ix in 1 until sub.chunks.size) {
             val lastChunk = chunks.last()
-            if(mayJoin(lastChunk, sub.chunks[ix])) {
-                lastChunk.instructions += sub.chunks[ix].instructions
-                lastChunk.next = sub.chunks[ix].next
+            val candidate = sub.chunks[ix]
+            when(candidate) {
+                is IRCodeChunk -> {
+                    if(mayJoinCodeChunks(lastChunk, candidate)) {
+                        lastChunk.instructions += candidate.instructions
+                        lastChunk.next = candidate.next
+                    }
+                    else
+                        chunks += candidate
+                }
+                is IRInlineAsmChunk -> {
+                    if(candidate.label!=null)
+                        chunks += candidate
+                    else if(lastChunk.isEmpty()) {
+                        val label = lastChunk.label
+                        if(label!=null)
+                            chunks += IRInlineAsmChunk(label, candidate.assembly, candidate.isIR, candidate.next)
+                        else
+                            chunks += candidate
+                    }
+                }
+                is IRInlineBinaryChunk -> {
+                    if(candidate.label!=null)
+                        chunks += candidate
+                    else if(lastChunk.isEmpty()) {
+                        val label = lastChunk.label
+                        if(label!=null)
+                            chunks += IRInlineBinaryChunk(label, candidate.data, candidate.next)
+                        else
+                            chunks += candidate
+                    }
+                }
             }
-            else
-                chunks += sub.chunks[ix]
         }
         sub.chunks.clear()
         sub.chunks += chunks
@@ -119,8 +175,8 @@ internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
         indexedInstructions.reversed().forEach { (idx, ins) ->
             if(ins.opcode== Opcode.PUSH) {
                 if(idx < chunk.instructions.size-1) {
-                    val insAfter = chunk.instructions[idx+1] as? IRInstruction
-                    if(insAfter!=null && insAfter.opcode == Opcode.POP) {
+                    val insAfter = chunk.instructions[idx+1]
+                    if(insAfter.opcode == Opcode.POP) {
                         if(ins.reg1==insAfter.reg1) {
                             chunk.instructions.removeAt(idx)
                             chunk.instructions.removeAt(idx)
@@ -143,16 +199,16 @@ internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
         indexedInstructions.reversed().forEach { (idx, ins) ->
             if(ins.opcode== Opcode.SEC || ins.opcode== Opcode.CLC) {
                 if(idx < chunk.instructions.size-1) {
-                    val insAfter = chunk.instructions[idx+1] as? IRInstruction
-                    if(insAfter?.opcode == ins.opcode) {
+                    val insAfter = chunk.instructions[idx+1]
+                    if(insAfter.opcode == ins.opcode) {
                         chunk.instructions.removeAt(idx)
                         changed = true
                     }
-                    else if(ins.opcode== Opcode.SEC && insAfter?.opcode== Opcode.CLC) {
+                    else if(ins.opcode== Opcode.SEC && insAfter.opcode== Opcode.CLC) {
                         chunk.instructions.removeAt(idx)
                         changed = true
                     }
-                    else if(ins.opcode== Opcode.CLC && insAfter?.opcode== Opcode.SEC) {
+                    else if(ins.opcode== Opcode.CLC && insAfter.opcode== Opcode.SEC) {
                         chunk.instructions.removeAt(idx)
                         changed = true
                     }
@@ -174,14 +230,36 @@ internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
                     changed = true
                 }
             }
+
             // remove useless RETURN
-            if(ins.opcode == Opcode.RETURN && idx>0) {
-                val previous = chunk.instructions[idx-1] as? IRInstruction
-                if(previous?.opcode in OpcodesThatJump) {
+            if(idx>0 && (ins.opcode == Opcode.RETURN || ins.opcode==Opcode.RETURNR)) {
+                val previous = chunk.instructions[idx-1]
+                if(previous.opcode in OpcodesThatJump) {
                     chunk.instructions.removeAt(idx)
                     changed = true
                 }
             }
+
+            // replace subsequent opcodes that jump by just the first
+            if(idx>0 && (ins.opcode in OpcodesThatJump)) {
+                val previous = chunk.instructions[idx-1]
+                if(previous.opcode in OpcodesThatJump) {
+                    chunk.instructions.removeAt(idx)
+                    changed = true
+                }
+            }
+
+            // replace call + return --> jump
+            // This can no longer be done here on the IR level, with the current CALL opcode that encodes the full subroutine call setup.
+            // If machine code is ever generated from this IR, *that* should possibly optimize the JSR + RTS into a JMP.
+//            if(idx>0 && ins.opcode==Opcode.RETURN) {
+//                val previous = chunk.instructions[idx-1]
+//                if(previous.opcode==Opcode.CALL) {
+//                    chunk.instructions[idx-1] = IRInstruction(Opcode.JUMP, address = previous.address, labelSymbol = previous.labelSymbol, branchTarget = previous.branchTarget)
+//                    chunk.instructions.removeAt(idx)
+//                    changed = true
+//                }
+//            }
         }
         return changed
     }
@@ -192,47 +270,47 @@ internal class IRPeepholeOptimizer(private val irprog: IRProgram) {
         indexedInstructions.reversed().forEach { (idx, ins) ->
             when (ins.opcode) {
                 Opcode.DIV, Opcode.DIVS, Opcode.MUL, Opcode.MOD -> {
-                    if (ins.value == 1) {
+                    if (ins.immediate == 1) {
                         chunk.instructions.removeAt(idx)
                         changed = true
                     }
                 }
                 Opcode.ADD, Opcode.SUB -> {
-                    if (ins.value == 1) {
+                    if (ins.immediate == 1) {
                         chunk.instructions[idx] = IRInstruction(
                             if (ins.opcode == Opcode.ADD) Opcode.INC else Opcode.DEC,
                             ins.type,
                             ins.reg1
                         )
                         changed = true
-                    } else if (ins.value == 0) {
+                    } else if (ins.immediate == 0) {
                         chunk.instructions.removeAt(idx)
                         changed = true
                     }
                 }
                 Opcode.AND -> {
-                    if (ins.value == 0) {
-                        chunk.instructions[idx] = IRInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, value = 0)
+                    if (ins.immediate == 0) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, immediate = 0)
                         changed = true
-                    } else if (ins.value == 255 && ins.type == IRDataType.BYTE) {
+                    } else if (ins.immediate == 255 && ins.type == IRDataType.BYTE) {
                         chunk.instructions.removeAt(idx)
                         changed = true
-                    } else if (ins.value == 65535 && ins.type == IRDataType.WORD) {
+                    } else if (ins.immediate == 65535 && ins.type == IRDataType.WORD) {
                         chunk.instructions.removeAt(idx)
                         changed = true
                     }
                 }
                 Opcode.OR -> {
-                    if (ins.value == 0) {
+                    if (ins.immediate == 0) {
                         chunk.instructions.removeAt(idx)
                         changed = true
-                    } else if ((ins.value == 255 && ins.type == IRDataType.BYTE) || (ins.value == 65535 && ins.type == IRDataType.WORD)) {
-                        chunk.instructions[idx] = IRInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, value = ins.value)
+                    } else if ((ins.immediate == 255 && ins.type == IRDataType.BYTE) || (ins.immediate == 65535 && ins.type == IRDataType.WORD)) {
+                        chunk.instructions[idx] = IRInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, immediate = ins.immediate)
                         changed = true
                     }
                 }
                 Opcode.XOR -> {
-                    if (ins.value == 0) {
+                    if (ins.immediate == 0) {
                         chunk.instructions.removeAt(idx)
                         changed = true
                     }

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

@@ -5,34 +5,18 @@ import prog8.code.core.SourceCode.Companion.libraryFilePrefix
 import prog8.intermediate.*
 
 
-internal class IRUnusedCodeRemover(private val irprog: IRProgram, private val errors: IErrorReporter) {
+class IRUnusedCodeRemover(
+    private val irprog: IRProgram,
+    private val errors: IErrorReporter
+) {
     fun optimize(): Int {
-        val allLabeledChunks = mutableMapOf<String, IRCodeChunkBase>()
-
-        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
-            sub.chunks.forEach { chunk ->
-                chunk.label?.let { allLabeledChunks[it] = chunk }
-            }
-        }
-
-        var numRemoved = removeSimpleUnlinked(allLabeledChunks) + removeUnreachable(allLabeledChunks)
-
-        // remove empty subs
-        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)
-                    numRemoved++
-                }
-            }
-        }
+        var numRemoved = removeUnusedSubroutines() + removeUnusedAsmSubroutines()
 
         // remove empty blocks
         irprog.blocks.reversed().forEach { block ->
             if(block.isEmpty()) {
                 irprog.blocks.remove(block)
+                irprog.st.removeTree(block.label)
                 numRemoved++
             }
         }
@@ -40,8 +24,106 @@ internal class IRUnusedCodeRemover(private val irprog: IRProgram, private val er
         return numRemoved
     }
 
+    private fun removeUnusedSubroutines(): Int {
+        val allLabeledChunks = mutableMapOf<String, IRCodeChunkBase>()
+        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
+            sub.chunks.forEach { chunk ->
+                chunk.label?.let { allLabeledChunks[it] = chunk }
+            }
+        }
+
+        var numRemoved = removeSimpleUnlinked(allLabeledChunks) + removeUnreachable(allLabeledChunks)
+        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++
+                }
+            }
+        }
+
+        return numRemoved
+    }
+
+    private fun removeUnusedAsmSubroutines(): Int {
+        val allLabeledAsmsubs = irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRAsmSubroutine>() }
+            .associateBy { it.label }
+
+        var numRemoved = removeSimpleUnlinkedAsmsubs(allLabeledAsmsubs)
+        irprog.blocks.forEach { block ->
+            block.children.filterIsInstance<IRAsmSubroutine>().reversed().forEach { sub ->
+                if(sub.isEmpty()) {
+                    if(!sub.position.file.startsWith(libraryFilePrefix)) {
+                        errors.warn("unused asmsubroutine ${sub.label}", sub.position)
+                    }
+                    block.children.remove(sub)
+                    irprog.st.removeTree(sub.label)
+                    numRemoved++
+                }
+            }
+        }
+
+        return numRemoved
+    }
+
+    private fun removeSimpleUnlinkedAsmsubs(allSubs: Map<String, IRAsmSubroutine>): Int {
+        val linkedAsmSubs = mutableSetOf<IRAsmSubroutine>()
+
+        // TODO: asmsubs in library modules are never removed, we can't really tell here if they're actually being called or not...
+
+        // check if asmsub is called from another asmsub
+        irprog.blocks.asSequence().forEach { block ->
+            block.children.filterIsInstance<IRAsmSubroutine>().forEach { sub ->
+                if (block.forceOutput || block.library)
+                    linkedAsmSubs += sub
+                if (sub.asmChunk.isNotEmpty()) {
+                    allSubs.forEach { (label, asmsub) ->
+                        if (sub.asmChunk.assembly.contains(label))
+                            linkedAsmSubs += asmsub
+                    }
+                }
+                val inlineAsm = sub.asmChunk.next as? IRInlineAsmChunk
+                if(inlineAsm!=null) {
+                    allSubs.forEach { (label, asmsub) ->
+                        if (inlineAsm.assembly.contains(label))
+                            linkedAsmSubs += asmsub
+                    }
+                }
+            }
+        }
+
+        // check if asmsub is linked or called from another regular subroutine
+        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
+            sub.chunks.forEach { chunk ->
+                chunk.instructions.forEach {
+                    it.labelSymbol?.let { label -> allSubs[label]?.let { cc -> linkedAsmSubs += cc } }
+                    // note: branchTarget can't yet point to another IRAsmSubroutine, so do nothing when it's set
+                }
+            }
+        }
+
+        return removeUnlinkedAsmsubs(linkedAsmSubs)
+    }
+
+    private fun removeUnlinkedAsmsubs(linkedAsmSubs: Set<IRAsmSubroutine>): Int {
+        var numRemoved = 0
+        irprog.blocks.asSequence().forEach { block ->
+            block.children.withIndex().reversed().forEach { (index, child) ->
+                if(child is IRAsmSubroutine && child !in linkedAsmSubs) {
+                    block.children.removeAt(index)
+                    numRemoved++
+                }
+            }
+        }
+        return numRemoved
+    }
+
     private fun removeUnreachable(allLabeledChunks: MutableMap<String, IRCodeChunkBase>): Int {
-        val entrypointSub = irprog.blocks.single { it.name=="main" }.children.single { it is IRSubroutine && it.label=="main.start" }
+        val entrypointSub = irprog.blocks.single { it.label=="main" }.children.single { it is IRSubroutine && it.label=="main.start" }
         val reachable = mutableSetOf((entrypointSub as IRSubroutine).chunks.first())
 
         fun grow() {
@@ -91,7 +173,7 @@ internal class IRUnusedCodeRemover(private val irprog: IRProgram, private val er
     }
 
     private fun removeUnlinkedChunks(
-        linkedChunks: MutableSet<IRCodeChunkBase>
+        linkedChunks: Set<IRCodeChunkBase>
     ): Int {
         var numRemoved = 0
         irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->

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

@@ -1,10 +1,7 @@
 package prog8.codegen.intermediate
 
-import prog8.code.core.AssemblyError
-import prog8.intermediate.SyscallRegisterBase
-
 internal class RegisterPool {
-    // reserve 0,1,2 for return values of subroutine calls and syscalls
+    // reserve 0,1,2 for return values of subroutine calls and syscalls in IR assembly code
     private var firstFree: Int=3
     private var firstFreeFloat: Int=3
 
@@ -14,16 +11,12 @@ internal class RegisterPool {
     fun nextFree(): Int {
         val result = firstFree
         firstFree++
-        if(firstFree >= SyscallRegisterBase)
-            throw AssemblyError("out of virtual registers (int)")
         return result
     }
 
     fun nextFreeFloat(): Int {
         val result = firstFreeFloat
         firstFreeFloat++
-        if(firstFreeFloat >= SyscallRegisterBase)
-            throw AssemblyError("out of virtual registers (fp)")
         return result
     }
 }

codeGenIntermediate/src/prog8/codegen/vm/VmCodeGen.kt

@@ -26,7 +26,7 @@ class VmCodeGen: ICodeGeneratorBackend {
 
 internal class VmAssemblyProgram(override val name: String, internal val irProgram: IRProgram): IAssemblyProgram {
 
-    override fun assemble(options: CompilationOptions): Boolean {
+    override fun assemble(options: CompilationOptions, errors: IErrorReporter): Boolean {
         // the VM reads the IR file from disk.
         IRFileWriter(irProgram, null).write()
         return true

codeGenIntermediate/test/Dummies.kt

@@ -32,11 +32,15 @@ internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors:
     val warnings = mutableListOf<String>()
 
     override fun err(msg: String, position: Position) {
-        errors.add("${position.toClickableStr()} $msg")
+        val text = "${position.toClickableStr()} $msg"
+        if(text !in errors)
+            errors.add(text)
     }
 
     override fun warn(msg: String, position: Position) {
-        warnings.add("${position.toClickableStr()} $msg")
+        val text = "${position.toClickableStr()} $msg"
+        if(text !in warnings)
+            warnings.add(text)
     }
 
     override fun noErrors(): Boolean  = errors.isEmpty()

codeGenIntermediate/test/TestIRPeepholeOpt.kt

@@ -8,7 +8,7 @@ import prog8.intermediate.*
 class TestIRPeepholeOpt: FunSpec({
     fun makeIRProgram(chunks: List<IRCodeChunkBase>): IRProgram {
         require(chunks.first().label=="main.start")
-        val block = IRBlock("main", null, IRBlock.BlockAlignment.NONE, Position.DUMMY)
+        val block = IRBlock("main", null, false, false, IRBlock.BlockAlignment.NONE, Position.DUMMY)
         val sub = IRSubroutine("main.start", emptyList(), null, Position.DUMMY)
         chunks.forEach { sub += it }
         block += sub
@@ -40,13 +40,13 @@ class TestIRPeepholeOpt: FunSpec({
 
     test("remove nops") {
         val irProg = makeIRProgram(listOf(
-            IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=1, value=42),
+            IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=1, immediate=42),
             IRInstruction(Opcode.NOP),
             IRInstruction(Opcode.NOP)
         ))
         irProg.chunks().single().instructions.size shouldBe 3
         val opt = IRPeepholeOptimizer(irProg)
-        opt.optimize()
+        opt.optimize(true, ErrorReporterForTests())
         irProg.chunks().single().instructions.size shouldBe 1
     }
 
@@ -65,7 +65,7 @@ class TestIRPeepholeOpt: FunSpec({
         irProg.chunks().size shouldBe 4
         irProg.chunks().flatMap { it.instructions }.size shouldBe 5
         val opt = IRPeepholeOptimizer(irProg)
-        opt.optimize()
+        opt.optimize(true, ErrorReporterForTests())
         irProg.chunks().size shouldBe 4
         irProg.chunks()[0].label shouldBe "main.start"
         irProg.chunks()[1].label shouldBe "label"
@@ -92,7 +92,7 @@ class TestIRPeepholeOpt: FunSpec({
         ))
         irProg.chunks().single().instructions.size shouldBe 6
         val opt = IRPeepholeOptimizer(irProg)
-        opt.optimize()
+        opt.optimize(true, ErrorReporterForTests())
         val instr = irProg.chunks().single().instructions
         instr.size shouldBe 1
         instr[0].opcode shouldBe Opcode.CLC
@@ -107,7 +107,7 @@ class TestIRPeepholeOpt: FunSpec({
         ))
         irProg.chunks().single().instructions.size shouldBe 4
         val opt = IRPeepholeOptimizer(irProg)
-        opt.optimize()
+        opt.optimize(true, ErrorReporterForTests())
         val instr = irProg.chunks().single().instructions
         instr.size shouldBe 1
         instr[0].opcode shouldBe Opcode.LOADR
@@ -117,31 +117,31 @@ class TestIRPeepholeOpt: FunSpec({
 
     test("remove useless div/mul, add/sub") {
         val irProg = makeIRProgram(listOf(
-            IRInstruction(Opcode.DIV, IRDataType.BYTE, reg1=42, value = 1),
-            IRInstruction(Opcode.DIVS, IRDataType.BYTE, reg1=42, value = 1),
-            IRInstruction(Opcode.MUL, IRDataType.BYTE, reg1=42, value = 1),
-            IRInstruction(Opcode.MOD, IRDataType.BYTE, reg1=42, value = 1),
-            IRInstruction(Opcode.DIV, IRDataType.BYTE, reg1=42, value = 2),
-            IRInstruction(Opcode.DIVS, IRDataType.BYTE, reg1=42, value = 2),
-            IRInstruction(Opcode.MUL, IRDataType.BYTE, reg1=42, value = 2),
-            IRInstruction(Opcode.MOD, IRDataType.BYTE, reg1=42, value = 2),
-            IRInstruction(Opcode.ADD, IRDataType.BYTE, reg1=42, value = 0),
-            IRInstruction(Opcode.SUB, IRDataType.BYTE, reg1=42, value = 0)
+            IRInstruction(Opcode.DIV, IRDataType.BYTE, reg1=42, immediate = 1),
+            IRInstruction(Opcode.DIVS, IRDataType.BYTE, reg1=42, immediate = 1),
+            IRInstruction(Opcode.MUL, IRDataType.BYTE, reg1=42, immediate = 1),
+            IRInstruction(Opcode.MOD, IRDataType.BYTE, reg1=42, immediate = 1),
+            IRInstruction(Opcode.DIV, IRDataType.BYTE, reg1=42, immediate = 2),
+            IRInstruction(Opcode.DIVS, IRDataType.BYTE, reg1=42, immediate = 2),
+            IRInstruction(Opcode.MUL, IRDataType.BYTE, reg1=42, immediate = 2),
+            IRInstruction(Opcode.MOD, IRDataType.BYTE, reg1=42, immediate = 2),
+            IRInstruction(Opcode.ADD, IRDataType.BYTE, reg1=42, immediate = 0),
+            IRInstruction(Opcode.SUB, IRDataType.BYTE, reg1=42, immediate = 0)
         ))
         irProg.chunks().single().instructions.size shouldBe 10
         val opt = IRPeepholeOptimizer(irProg)
-        opt.optimize()
+        opt.optimize(true, ErrorReporterForTests())
         irProg.chunks().single().instructions.size shouldBe 4
     }
 
     test("replace add/sub 1 by inc/dec") {
         val irProg = makeIRProgram(listOf(
-            IRInstruction(Opcode.ADD, IRDataType.BYTE, reg1=42, value = 1),
-            IRInstruction(Opcode.SUB, IRDataType.BYTE, reg1=42, value = 1)
+            IRInstruction(Opcode.ADD, IRDataType.BYTE, reg1=42, immediate = 1),
+            IRInstruction(Opcode.SUB, IRDataType.BYTE, reg1=42, immediate = 1)
         ))
         irProg.chunks().single().instructions.size shouldBe 2
         val opt = IRPeepholeOptimizer(irProg)
-        opt.optimize()
+        opt.optimize(true, ErrorReporterForTests())
         val instr = irProg.chunks().single().instructions
         instr.size shouldBe 2
         instr[0].opcode shouldBe Opcode.INC
@@ -150,40 +150,40 @@ class TestIRPeepholeOpt: FunSpec({
 
     test("remove useless and/or/xor") {
         val irProg = makeIRProgram(listOf(
-            IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=42, value = 255),
-            IRInstruction(Opcode.AND, IRDataType.WORD, reg1=42, value = 65535),
-            IRInstruction(Opcode.OR, IRDataType.BYTE, reg1=42, value = 0),
-            IRInstruction(Opcode.XOR, IRDataType.BYTE, reg1=42, value = 0),
-            IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=42, value = 200),
-            IRInstruction(Opcode.AND, IRDataType.WORD, reg1=42, value = 60000),
-            IRInstruction(Opcode.OR, IRDataType.BYTE, reg1=42, value = 1),
-            IRInstruction(Opcode.XOR, IRDataType.BYTE, reg1=42, value = 1)
+            IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=42, immediate = 255),
+            IRInstruction(Opcode.AND, IRDataType.WORD, reg1=42, immediate = 65535),
+            IRInstruction(Opcode.OR, IRDataType.BYTE, reg1=42, immediate = 0),
+            IRInstruction(Opcode.XOR, IRDataType.BYTE, reg1=42, immediate = 0),
+            IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=42, immediate = 200),
+            IRInstruction(Opcode.AND, IRDataType.WORD, reg1=42, immediate = 60000),
+            IRInstruction(Opcode.OR, IRDataType.BYTE, reg1=42, immediate = 1),
+            IRInstruction(Opcode.XOR, IRDataType.BYTE, reg1=42, immediate = 1)
         ))
         irProg.chunks().single().instructions.size shouldBe 8
         val opt = IRPeepholeOptimizer(irProg)
-        opt.optimize()
+        opt.optimize(true, ErrorReporterForTests())
         irProg.chunks().single().instructions.size shouldBe 4
     }
 
     test("replace and/or/xor by constant number") {
         val irProg = makeIRProgram(listOf(
-            IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=42, value = 0),
-            IRInstruction(Opcode.AND, IRDataType.WORD, reg1=42, value = 0),
-            IRInstruction(Opcode.OR, IRDataType.BYTE, reg1=42, value = 255),
-            IRInstruction(Opcode.OR, IRDataType.WORD, reg1=42, value = 65535)
+            IRInstruction(Opcode.AND, IRDataType.BYTE, reg1=42, immediate = 0),
+            IRInstruction(Opcode.AND, IRDataType.WORD, reg1=42, immediate = 0),
+            IRInstruction(Opcode.OR, IRDataType.BYTE, reg1=42, immediate = 255),
+            IRInstruction(Opcode.OR, IRDataType.WORD, reg1=42, immediate = 65535)
         ))
         irProg.chunks().single().instructions.size shouldBe 4
         val opt = IRPeepholeOptimizer(irProg)
-        opt.optimize()
+        opt.optimize(true, ErrorReporterForTests())
         val instr = irProg.chunks().single().instructions
         instr.size shouldBe 4
         instr[0].opcode shouldBe Opcode.LOAD
         instr[1].opcode shouldBe Opcode.LOAD
         instr[2].opcode shouldBe Opcode.LOAD
         instr[3].opcode shouldBe Opcode.LOAD
-        instr[0].value shouldBe 0
-        instr[1].value shouldBe 0
-        instr[2].value shouldBe 255
-        instr[3].value shouldBe 65535
+        instr[0].immediate shouldBe 0
+        instr[1].immediate shouldBe 0
+        instr[2].immediate shouldBe 255
+        instr[3].immediate shouldBe 65535
     }
 })

codeGenIntermediate/test/TestVmCodeGen.kt

@@ -1,5 +1,6 @@
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.ints.shouldBeGreaterThan
+import io.kotest.matchers.shouldBe
 import prog8.code.SymbolTableMaker
 import prog8.code.ast.*
 import prog8.code.core.*
@@ -7,6 +8,7 @@ import prog8.code.target.VMTarget
 import prog8.codegen.vm.VmAssemblyProgram
 import prog8.codegen.vm.VmCodeGen
 import prog8.intermediate.IRSubroutine
+import prog8.intermediate.Opcode
 
 class TestVmCodeGen: FunSpec({
 
@@ -93,6 +95,69 @@ class TestVmCodeGen: FunSpec({
         cx16block.add(PtMemMapped("r0", DataType.UWORD, 100u, null, Position.DUMMY))
         program.add(cx16block)
 
+        val options = getTestOptions()
+        val st = SymbolTableMaker(program, options).make()
+        val errors = ErrorReporterForTests()
+        val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
+        val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
+        irChunks.size shouldBe 1
+    }
+
+    test("float comparison expressions against zero") {
+//main {
+//    sub start() {
+//        float @shared f1
+//
+//        if f1==0
+//            nop
+//        if f1!=0
+//            nop
+//        if f1>0
+//            nop
+//        if f1<0
+//            nop
+//    }
+//}
+        val codegen = VmCodeGen()
+        val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val block = PtBlock("main", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val sub = PtSub("start", emptyList(), null, Position.DUMMY)
+        sub.add(PtVariable("f1", DataType.FLOAT, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
+        val if1 = PtIfElse(Position.DUMMY)
+        val cmp1 = PtBinaryExpression("==", DataType.UBYTE, Position.DUMMY)
+        cmp1.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp1.add(PtNumber(DataType.FLOAT, 0.0, Position.DUMMY))
+        if1.add(cmp1)
+        if1.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if1.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if1)
+        val if2 = PtIfElse(Position.DUMMY)
+        val cmp2 = PtBinaryExpression("!=", DataType.UBYTE, Position.DUMMY)
+        cmp2.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp2.add(PtNumber(DataType.FLOAT, 0.0, Position.DUMMY))
+        if2.add(cmp2)
+        if2.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if2.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if2)
+        val if3 = PtIfElse(Position.DUMMY)
+        val cmp3 = PtBinaryExpression("<", DataType.UBYTE, Position.DUMMY)
+        cmp3.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp3.add(PtNumber(DataType.FLOAT, 0.0, Position.DUMMY))
+        if3.add(cmp3)
+        if3.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if3.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if3)
+        val if4 = PtIfElse(Position.DUMMY)
+        val cmp4 = PtBinaryExpression(">", DataType.UBYTE, Position.DUMMY)
+        cmp4.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp4.add(PtNumber(DataType.FLOAT, 0.0, Position.DUMMY))
+        if4.add(cmp4)
+        if4.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if4.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if4)
+        block.add(sub)
+        program.add(block)
+
         val options = getTestOptions()
         val st = SymbolTableMaker(program, options).make()
         val errors = ErrorReporterForTests()
@@ -100,4 +165,309 @@ class TestVmCodeGen: FunSpec({
         val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
         irChunks.size shouldBeGreaterThan 4
     }
+
+    test("float comparison expressions against nonzero") {
+//main {
+//    sub start() {
+//        float @shared f1
+//
+//        if f1==42
+//            nop
+//        if f1!=42
+//            nop
+//        if f1>42
+//            nop
+//        if f1<42
+//            nop
+//    }
+//}
+        val codegen = VmCodeGen()
+        val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val block = PtBlock("main", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val sub = PtSub("start", emptyList(), null, Position.DUMMY)
+        sub.add(PtVariable("f1", DataType.FLOAT, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
+        val if1 = PtIfElse(Position.DUMMY)
+        val cmp1 = PtBinaryExpression("==", DataType.UBYTE, Position.DUMMY)
+        cmp1.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp1.add(PtNumber(DataType.FLOAT, 42.0, Position.DUMMY))
+        if1.add(cmp1)
+        if1.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if1.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if1)
+        val if2 = PtIfElse(Position.DUMMY)
+        val cmp2 = PtBinaryExpression("!=", DataType.UBYTE, Position.DUMMY)
+        cmp2.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp2.add(PtNumber(DataType.FLOAT, 42.0, Position.DUMMY))
+        if2.add(cmp2)
+        if2.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if2.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if2)
+        val if3 = PtIfElse(Position.DUMMY)
+        val cmp3 = PtBinaryExpression("<", DataType.UBYTE, Position.DUMMY)
+        cmp3.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp3.add(PtNumber(DataType.FLOAT, 42.0, Position.DUMMY))
+        if3.add(cmp3)
+        if3.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if3.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if3)
+        val if4 = PtIfElse(Position.DUMMY)
+        val cmp4 = PtBinaryExpression(">", DataType.UBYTE, Position.DUMMY)
+        cmp4.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp4.add(PtNumber(DataType.FLOAT, 42.0, Position.DUMMY))
+        if4.add(cmp4)
+        if4.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if4.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if4)
+        block.add(sub)
+        program.add(block)
+
+        val options = getTestOptions()
+        val st = SymbolTableMaker(program, options).make()
+        val errors = ErrorReporterForTests()
+        val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
+        val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
+        irChunks.size shouldBeGreaterThan 4
+    }
+
+    test("float conditional jump") {
+//main {
+//    sub start() {
+//        float @shared f1
+//
+//        if f1==42
+//            goto $c000
+//        if f1>42
+//            goto $c000
+//    }
+//}
+        val codegen = VmCodeGen()
+        val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val block = PtBlock("main", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val sub = PtSub("start", emptyList(), null, Position.DUMMY)
+        sub.add(PtVariable("f1", DataType.FLOAT, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
+        val if1 = PtIfElse(Position.DUMMY)
+        val cmp1 = PtBinaryExpression("==", DataType.UBYTE, Position.DUMMY)
+        cmp1.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp1.add(PtNumber(DataType.FLOAT, 42.0, Position.DUMMY))
+        if1.add(cmp1)
+        if1.add(PtNodeGroup().also { it.add(PtJump(null, 0xc000u, null, Position.DUMMY)) })
+        if1.add(PtNodeGroup())
+        sub.add(if1)
+        val if2 = PtIfElse(Position.DUMMY)
+        val cmp2 = PtBinaryExpression(">", DataType.UBYTE, Position.DUMMY)
+        cmp2.add(PtIdentifier("main.start.f1", DataType.FLOAT, Position.DUMMY))
+        cmp2.add(PtNumber(DataType.FLOAT, 42.0, Position.DUMMY))
+        if2.add(cmp2)
+        if2.add(PtNodeGroup().also { it.add(PtJump(null, 0xc000u, null, Position.DUMMY)) })
+        if2.add(PtNodeGroup())
+        sub.add(if2)
+        block.add(sub)
+        program.add(block)
+
+        val options = getTestOptions()
+        val st = SymbolTableMaker(program, options).make()
+        val errors = ErrorReporterForTests()
+        val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
+        val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
+        irChunks.size shouldBe 1
+    }
+
+    test("integer comparison expressions against zero") {
+//main {
+//    sub start() {
+//        byte @shared sb1
+//
+//        if sb1==0
+//            nop
+//        if sb1!=0
+//            nop
+//        if sb1>0
+//            nop
+//        if sb1<0
+//            nop
+//    }
+//}
+        val codegen = VmCodeGen()
+        val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val block = PtBlock("main", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val sub = PtSub("start", emptyList(), null, Position.DUMMY)
+        sub.add(PtVariable("sb1", DataType.BYTE, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
+        val if1 = PtIfElse(Position.DUMMY)
+        val cmp1 = PtBinaryExpression("==", DataType.BYTE, Position.DUMMY)
+        cmp1.add(PtIdentifier("main.start.sb1", DataType.BYTE, Position.DUMMY))
+        cmp1.add(PtNumber(DataType.BYTE, 0.0, Position.DUMMY))
+        if1.add(cmp1)
+        if1.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if1.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if1)
+        val if2 = PtIfElse(Position.DUMMY)
+        val cmp2 = PtBinaryExpression("!=", DataType.BYTE, Position.DUMMY)
+        cmp2.add(PtIdentifier("main.start.sb1", DataType.BYTE, Position.DUMMY))
+        cmp2.add(PtNumber(DataType.BYTE, 0.0, Position.DUMMY))
+        if2.add(cmp2)
+        if2.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if2.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if2)
+        val if3 = PtIfElse(Position.DUMMY)
+        val cmp3 = PtBinaryExpression("<", DataType.BYTE, Position.DUMMY)
+        cmp3.add(PtIdentifier("main.start.sb1", DataType.BYTE, Position.DUMMY))
+        cmp3.add(PtNumber(DataType.BYTE, 0.0, Position.DUMMY))
+        if3.add(cmp3)
+        if3.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if3.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if3)
+        val if4 = PtIfElse(Position.DUMMY)
+        val cmp4 = PtBinaryExpression(">", DataType.BYTE, Position.DUMMY)
+        cmp4.add(PtIdentifier("main.start.sb1", DataType.BYTE, Position.DUMMY))
+        cmp4.add(PtNumber(DataType.BYTE, 0.0, Position.DUMMY))
+        if4.add(cmp4)
+        if4.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if4.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if4)
+        block.add(sub)
+        program.add(block)
+
+        val options = getTestOptions()
+        val st = SymbolTableMaker(program, options).make()
+        val errors = ErrorReporterForTests()
+        val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
+        val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
+        irChunks.size shouldBeGreaterThan 4
+    }
+
+    test("integer comparison expressions against nonzero") {
+//main {
+//    sub start() {
+//        byte @shared sb1
+//
+//        if sb1==42
+//            nop
+//        if sb1!=42
+//            nop
+//        if sb1>42
+//            nop
+//        if sb1<42
+//            nop
+//    }
+//}
+        val codegen = VmCodeGen()
+        val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val block = PtBlock("main", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val sub = PtSub("start", emptyList(), null, Position.DUMMY)
+        sub.add(PtVariable("sb1", DataType.BYTE, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
+        val if1 = PtIfElse(Position.DUMMY)
+        val cmp1 = PtBinaryExpression("==", DataType.BYTE, Position.DUMMY)
+        cmp1.add(PtIdentifier("main.start.sb1", DataType.BYTE, Position.DUMMY))
+        cmp1.add(PtNumber(DataType.BYTE, 42.0, Position.DUMMY))
+        if1.add(cmp1)
+        if1.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if1.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if1)
+        val if2 = PtIfElse(Position.DUMMY)
+        val cmp2 = PtBinaryExpression("!=", DataType.BYTE, Position.DUMMY)
+        cmp2.add(PtIdentifier("main.start.sb1", DataType.BYTE, Position.DUMMY))
+        cmp2.add(PtNumber(DataType.BYTE, 42.0, Position.DUMMY))
+        if2.add(cmp2)
+        if2.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if2.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if2)
+        val if3 = PtIfElse(Position.DUMMY)
+        val cmp3 = PtBinaryExpression("<", DataType.BYTE, Position.DUMMY)
+        cmp3.add(PtIdentifier("main.start.sb1", DataType.BYTE, Position.DUMMY))
+        cmp3.add(PtNumber(DataType.BYTE, 42.0, Position.DUMMY))
+        if3.add(cmp3)
+        if3.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if3.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if3)
+        val if4 = PtIfElse(Position.DUMMY)
+        val cmp4 = PtBinaryExpression(">", DataType.BYTE, Position.DUMMY)
+        cmp4.add(PtIdentifier("main.start.sb1", DataType.BYTE, Position.DUMMY))
+        cmp4.add(PtNumber(DataType.BYTE, 42.0, Position.DUMMY))
+        if4.add(cmp4)
+        if4.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        if4.add(PtNodeGroup().also { it.add(PtNop(Position.DUMMY)) })
+        sub.add(if4)
+        block.add(sub)
+        program.add(block)
+
+        val options = getTestOptions()
+        val st = SymbolTableMaker(program, options).make()
+        val errors = ErrorReporterForTests()
+        val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
+        val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
+        irChunks.size shouldBeGreaterThan 4
+    }
+
+    test("integer conditional jump") {
+//main {
+//    sub start() {
+//        ubyte @shared ub1
+//
+//        if ub1==42
+//            goto $c000
+//        if ub1>42
+//            goto $c000
+//    }
+//}
+        val codegen = VmCodeGen()
+        val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val block = PtBlock("main", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val sub = PtSub("start", emptyList(), null, Position.DUMMY)
+        sub.add(PtVariable("ub1", DataType.UBYTE, ZeropageWish.DONTCARE, null, null, Position.DUMMY))
+        val if1 = PtIfElse(Position.DUMMY)
+        val cmp1 = PtBinaryExpression("==", DataType.UBYTE, Position.DUMMY)
+        cmp1.add(PtIdentifier("main.start.ub1", DataType.UBYTE, Position.DUMMY))
+        cmp1.add(PtNumber(DataType.UBYTE, 42.0, Position.DUMMY))
+        if1.add(cmp1)
+        if1.add(PtNodeGroup().also { it.add(PtJump(null, 0xc000u, null, Position.DUMMY)) })
+        if1.add(PtNodeGroup())
+        sub.add(if1)
+        val if2 = PtIfElse(Position.DUMMY)
+        val cmp2 = PtBinaryExpression(">", DataType.UBYTE, Position.DUMMY)
+        cmp2.add(PtIdentifier("main.start.ub1", DataType.UBYTE, Position.DUMMY))
+        cmp2.add(PtNumber(DataType.UBYTE, 42.0, Position.DUMMY))
+        if2.add(cmp2)
+        if2.add(PtNodeGroup().also { it.add(PtJump(null, 0xc000u, null, Position.DUMMY)) })
+        if2.add(PtNodeGroup())
+        sub.add(if2)
+        block.add(sub)
+        program.add(block)
+
+        val options = getTestOptions()
+        val st = SymbolTableMaker(program, options).make()
+        val errors = ErrorReporterForTests()
+        val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
+        val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
+        irChunks.size shouldBe 1
+    }
+
+    test("romsub allowed in ir-codegen") {
+//main {
+//    romsub $5000 = routine()
+//
+//    sub start()  {
+//        routine()
+//    }
+//}
+        val codegen = VmCodeGen()
+        val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val block = PtBlock("main", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val romsub = PtAsmSub("routine", 0x5000u, setOf(CpuRegister.Y), emptyList(), emptyList(), false, Position.DUMMY)
+        block.add(romsub)
+        val sub = PtSub("start", emptyList(), null, Position.DUMMY)
+        val call = PtFunctionCall("main.routine", true, DataType.UNDEFINED, Position.DUMMY)
+        sub.add(call)
+        block.add(sub)
+        program.add(block)
+
+        val options = getTestOptions()
+        val st = SymbolTableMaker(program, options).make()
+        val errors = ErrorReporterForTests()
+        val result = codegen.generate(program, st, options, errors) as VmAssemblyProgram
+        val irChunks = (result.irProgram.blocks.first().children.single() as IRSubroutine).chunks
+        irChunks.size shouldBe 1
+        val callInstr = irChunks.single().instructions.single()
+        callInstr.opcode shouldBe Opcode.CALL
+        callInstr.address shouldBe 0x5000
+    }
 })

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -87,8 +87,27 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
         if(forloop!=null && identifier===forloop.loopVar)
             return noModifications
 
+        val dt = identifier.inferType(program)
+        if(!dt.isKnown || !dt.isNumeric)
+            return noModifications
+
         try {
             val cval = identifier.constValue(program) ?: return noModifications
+            val arrayIdx = identifier.parent as? ArrayIndexedExpression
+            if(arrayIdx!=null && cval.type in NumericDatatypes) {
+                // special case when the identifier is used as a pointer var
+                // var = constpointer[x] --> var = @(constvalue+x) [directmemoryread]
+                // constpointer[x] = var -> @(constvalue+x) [directmemorywrite] = var
+                val add = BinaryExpression(NumericLiteral(cval.type, cval.number, identifier.position), "+", arrayIdx.indexer.indexExpr, identifier.position)
+                return if(arrayIdx.parent is AssignTarget) {
+                    val memwrite = DirectMemoryWrite(add, identifier.position)
+                    val assignTarget = AssignTarget(null, null, memwrite, identifier.position)
+                    listOf(IAstModification.ReplaceNode(arrayIdx.parent, assignTarget, arrayIdx.parent.parent))
+                } else {
+                    val memread = DirectMemoryRead(add, identifier.position)
+                    listOf(IAstModification.ReplaceNode(arrayIdx, memread, arrayIdx.parent))
+                }
+            }
             return when (cval.type) {
                 in NumericDatatypes -> listOf(
                     IAstModification.ReplaceNode(
@@ -223,6 +242,17 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                         }
                     }
                 }
+                DataType.ARRAY_BOOL -> {
+                    val numericLv = decl.value as? NumericLiteral
+                    val size = decl.arraysize?.constIndex() ?: return noModifications
+                    if(numericLv!=null) {
+                        // arraysize initializer is a single int, and we know the size.
+                        val fillvalue = if(numericLv.number==0.0) 0.0 else 1.0
+                        val array = Array(size) {fillvalue}.map { NumericLiteral(DataType.UBYTE, fillvalue, numericLv.position) }.toTypedArray<Expression>()
+                        val refValue = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_BOOL), array, position = numericLv.position)
+                        return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
+                    }
+                }
                 else -> {
                     // nothing to do for this type
                 }

codeOptimizers/src/prog8/optimizer/Inliner.kt

@@ -184,6 +184,7 @@ class Inliner(val program: Program): AstWalker() {
             }
             return if(sub.isAsmSubroutine) {
                 // simply insert the asm for the argument-less routine
+                sub.hasBeenInlined=true
                 listOf(IAstModification.ReplaceNode(origNode, sub.statements.single().copy(), parent))
             } else {
                 // note that we don't have to process any args, because we online inline parameterless subroutines.
@@ -192,12 +193,16 @@ class Inliner(val program: Program): AstWalker() {
                         val fcall = toInline.value as? FunctionCallExpression
                         if(fcall!=null) {
                             // insert the function call expression as a void function call directly
+                            sub.hasBeenInlined=true
                             val call = FunctionCallStatement(fcall.target.copy(), fcall.args.map { it.copy() }.toMutableList(), true, fcall.position)
                             listOf(IAstModification.ReplaceNode(origNode, call, parent))
                         } else
                             noModifications
                     }
-                    else -> listOf(IAstModification.ReplaceNode(origNode, toInline.copy(), parent))
+                    else -> {
+                        sub.hasBeenInlined=true
+                        listOf(IAstModification.ReplaceNode(origNode, toInline.copy(), parent))
+                    }
                 }
             }
         }
@@ -226,8 +231,10 @@ class Inliner(val program: Program): AstWalker() {
                     is Return -> {
                         // is an expression, so we have to have a Return here in the inlined sub
                         // note that we don't have to process any args, because we online inline parameterless subroutines.
-                        if(toInline.value!=null)
+                        if(toInline.value!=null) {
+                            sub.hasBeenInlined=true
                             listOf(IAstModification.ReplaceNode(functionCallExpr, toInline.value!!.copy(), parent))
+                        }
                         else
                             noModifications
                     }

codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt

@@ -166,6 +166,16 @@ class StatementOptimizer(private val program: Program,
             }
         }
 
+        val iterationCount = forLoop.constIterationCount(program)
+        if(iterationCount!=null) {
+            val loopName = forLoop.loopVar.nameInSource
+            if(!forLoop.iterable.referencesIdentifier(loopName) && !forLoop.body.referencesIdentifier(loopName)) {
+                errors.warn("for loop can be replaced with repeat loop", forLoop.position)
+                val repeat = RepeatLoop(NumericLiteral.optimalNumeric(iterationCount, forLoop.position), forLoop.body, forLoop.position)
+                return listOf(IAstModification.ReplaceNode(forLoop, repeat, parent))
+            }
+        }
+
         return noModifications
     }
 
@@ -316,13 +326,13 @@ class StatementOptimizer(private val program: Program,
                         if (rightCv == 0.0) {
                             return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
                         } else if (targetDt in IntegerDatatypes && floor(rightCv) == rightCv) {
-                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..4.0 && compTarget.name!=VMTarget.NAME) {
+                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..3.0 && compTarget.name!=VMTarget.NAME) {
                                 // replace by several INCs if it's not a memory address (inc on a memory mapped register doesn't work very well)
                                 val incs = AnonymousScope(mutableListOf(), assignment.position)
                                 repeat(rightCv.toInt()) {
                                     incs.statements.add(PostIncrDecr(assignment.target.copy(), "++", assignment.position))
                                 }
-                                listOf(IAstModification.ReplaceNode(assignment, if(incs.statements.size==1) incs.statements[0] else incs, parent))
+                                return listOf(IAstModification.ReplaceNode(assignment, if(incs.statements.size==1) incs.statements[0] else incs, parent))
                             }
                         }
                     }
@@ -330,7 +340,7 @@ class StatementOptimizer(private val program: Program,
                         if (rightCv == 0.0) {
                             return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
                         } else if (targetDt in IntegerDatatypes && floor(rightCv) == rightCv) {
-                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..4.0 && compTarget.name!=VMTarget.NAME) {
+                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..3.0 && compTarget.name!=VMTarget.NAME) {
                                 // replace by several DECs if it's not a memory address (dec on a memory mapped register doesn't work very well)
                                 val decs = AnonymousScope(mutableListOf(), assignment.position)
                                 repeat(rightCv.toInt()) {
@@ -374,4 +384,11 @@ class StatementOptimizer(private val program: Program,
 
         return noModifications
     }
+
+    override fun before(unrollLoop: UnrollLoop, parent: Node): Iterable<IAstModification> {
+        return if(unrollLoop.iterations<1)
+            listOf(IAstModification.Remove(unrollLoop, parent as IStatementContainer))
+        else
+            noModifications
+    }
 }

codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -64,13 +64,17 @@ class UnusedCodeRemover(private val program: Program,
     override fun after(block: Block, parent: Node): Iterable<IAstModification> {
         if("force_output" !in block.options()) {
             if (block.containsNoCodeNorVars) {
-                if(block.name != internedStringsModuleName)
-                    errors.warn("removing unused block '${block.name}'", block.position)
+                if(block.name != internedStringsModuleName) {
+                    if(!block.statements.any { it is Subroutine && it.hasBeenInlined })
+                        errors.warn("removing unused block '${block.name}'", block.position)
+                }
                 return listOf(IAstModification.Remove(block, parent as IStatementContainer))
             }
             if(callgraph.unused(block)) {
-                if(block.statements.any{ it !is VarDecl || it.type== VarDeclType.VAR})
-                    errors.warn("removing unused block '${block.name}'", block.position)
+                if(block.statements.any{ it !is VarDecl || it.type== VarDeclType.VAR}) {
+                    if(!block.statements.any { it is Subroutine && it.hasBeenInlined })
+                        errors.warn("removing unused block '${block.name}'", block.position)
+                }
                 program.removeInternedStringsFromRemovedBlock(block)
                 return listOf(IAstModification.Remove(block, parent as IStatementContainer))
             }
@@ -81,7 +85,7 @@ class UnusedCodeRemover(private val program: Program,
 
     override fun after(subroutine: Subroutine, parent: Node): Iterable<IAstModification> {
         val forceOutput = "force_output" in subroutine.definingBlock.options()
-        if (subroutine !== program.entrypoint && !forceOutput && !subroutine.inline && !subroutine.isAsmSubroutine) {
+        if (subroutine !== program.entrypoint && !forceOutput && !subroutine.isAsmSubroutine) {
             if(callgraph.unused(subroutine)) {
                 if(subroutine.containsNoCodeNorVars) {
                     if(!subroutine.definingModule.isLibrary)
@@ -93,9 +97,12 @@ class UnusedCodeRemover(private val program: Program,
                     }
                     return removals
                 }
-                if(!subroutine.definingModule.isLibrary)
-                    errors.warn("removing unused subroutine '${subroutine.name}'", subroutine.position)
-                program.removeInternedStringsFromRemovedSubroutine(subroutine)
+                if(!subroutine.definingModule.isLibrary && !subroutine.hasBeenInlined) {
+                    errors.warn("unused subroutine '${subroutine.name}'", subroutine.position)
+                }
+                if(!subroutine.inline) {
+                    program.removeInternedStringsFromRemovedSubroutine(subroutine)
+                }
                 return listOf(IAstModification.Remove(subroutine, parent as IStatementContainer))
             }
         }
@@ -110,7 +117,7 @@ class UnusedCodeRemover(private val program: Program,
             if (!forceOutput && decl.origin==VarDeclOrigin.USERCODE && !decl.sharedWithAsm) {
                 val usages = callgraph.usages(decl)
                 if (usages.isEmpty()) {
-                    // if(!decl.definingModule.isLibrary)
+                    if(!decl.definingModule.isLibrary)
                         errors.warn("removing unused variable '${decl.name}'", decl.position)
                     return listOf(IAstModification.Remove(decl, parent as IStatementContainer))
                 }
@@ -118,8 +125,8 @@ class UnusedCodeRemover(private val program: Program,
                     if(usages.size==1) {
                         val singleUse = usages[0].parent
                         if(singleUse is AssignTarget) {
-                            val assignment = singleUse.parent as Assignment
-                            if(assignment.origin==AssignmentOrigin.VARINIT) {
+                            val assignment = singleUse.parent as? Assignment
+                            if(assignment!=null && assignment.origin==AssignmentOrigin.VARINIT) {
                                 if(assignment.value.isSimple) {
                                     // remove the vardecl
                                     if(!decl.definingModule.isLibrary)

compiler/build.gradle

@@ -34,14 +34,14 @@ dependencies {
     implementation project(':codeGenIntermediate')
     implementation project(':codeGenExperimental')
     implementation project(':virtualmachine')
-    implementation 'org.antlr:antlr4-runtime:4.11.1'
+    implementation "org.antlr:antlr4-runtime:4.12.0"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.4'
+    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.5'
     implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
 
     testImplementation project(':intermediate')
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.3.2'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.5.5'
 }
 
 configurations.all {

compiler/res/prog8lib/c128/floats.asm

@@ -1,664 +0,0 @@
-; --- low level floating point assembly routines for the C128
-;     these are almost all identical to the C64 except for a few details
-;     so we have to have a separate library file for the C128 unfortunately.
-
-
-FL_ONE_const	.byte  129     			; 1.0
-FL_ZERO_const	.byte  0,0,0,0,0		; 0.0
-FL_LOG2_const	.byte  $80, $31, $72, $17, $f8	; log(2)
-
-
-floats_store_reg	.byte  0		; temp storage
-
-
-ub2float	.proc
-		; -- convert ubyte in SCRATCH_ZPB1 to float at address A/Y
-		;    clobbers A, Y
-		stx  P8ZP_SCRATCH_REG
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		ldy  P8ZP_SCRATCH_B1
-		lda  #0
-		jsr  GIVAYF
-_fac_to_mem	ldx  P8ZP_SCRATCH_W2
-		ldy  P8ZP_SCRATCH_W2+1
-		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-b2float		.proc
-		; -- convert byte in SCRATCH_ZPB1 to float at address A/Y
-		;    clobbers A, Y
-		stx  P8ZP_SCRATCH_REG
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		lda  P8ZP_SCRATCH_B1
-		jsr  FREADSA
-		jmp  ub2float._fac_to_mem
-		.pend
-
-uw2float	.proc
-		; -- convert uword in SCRATCH_ZPWORD1 to float at address A/Y
-		stx  P8ZP_SCRATCH_REG
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		lda  P8ZP_SCRATCH_W1
-		ldy  P8ZP_SCRATCH_W1+1
-		jsr  GIVUAYFAY
-		jmp  ub2float._fac_to_mem
-		.pend
-
-w2float		.proc
-		; -- convert word in SCRATCH_ZPWORD1 to float at address A/Y
-		stx  P8ZP_SCRATCH_REG
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		ldy  P8ZP_SCRATCH_W1
-		lda  P8ZP_SCRATCH_W1+1
-		jsr  GIVAYF
-		jmp  ub2float._fac_to_mem
-		.pend
-
-
-cast_from_uw	.proc
-		; -- uword in A/Y into float var at (P8ZP_SCRATCH_W2)
-		stx  P8ZP_SCRATCH_REG
-		jsr  GIVUAYFAY
-		jmp  ub2float._fac_to_mem
-		.pend
-
-
-cast_from_w	.proc
-		; -- word in A/Y into float var at (P8ZP_SCRATCH_W2)
-		stx  P8ZP_SCRATCH_REG
-		jsr  GIVAYFAY
-		jmp  ub2float._fac_to_mem
-		.pend
-
-
-cast_from_ub	.proc
-		; -- ubyte in Y into float var at (P8ZP_SCRATCH_W2)
-		stx  P8ZP_SCRATCH_REG
-		jsr  FREADUY
-		jmp  ub2float._fac_to_mem
-		.pend
-
-
-cast_from_b	.proc
-		; -- byte in A into float var at (P8ZP_SCRATCH_W2)
-		stx  P8ZP_SCRATCH_REG
-		jsr  FREADSA
-		jmp  ub2float._fac_to_mem
-		.pend
-
-cast_as_uw_into_ya	.proc               ; also used for float 2 ub
-		; -- cast float at A/Y to uword into Y/A
-		jsr  MOVFM
-		jmp  cast_FAC1_as_uw_into_ya
-		.pend
-
-cast_as_w_into_ay	.proc               ; also used for float 2 b
-		; -- cast float at A/Y to word into A/Y
-		jsr  MOVFM
-		jmp  cast_FAC1_as_w_into_ay
-		.pend
-
-cast_FAC1_as_uw_into_ya	.proc               ; also used for float 2 ub
-		; -- cast fac1 to uword into Y/A
-		stx  P8ZP_SCRATCH_REG
-		jsr  GETADR     ; into Y/A
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-cast_FAC1_as_w_into_ay	.proc               ; also used for float 2 b
-		; -- cast fac1 to word into A/Y
-		stx  P8ZP_SCRATCH_REG
-		jsr  AYINT
-		ldy  floats.AYINT_facmo
-		lda  floats.AYINT_facmo+1
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-
-stack_b2float	.proc
-		; -- b2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  FREADSA
-		jmp  push_fac1._internal
-		.pend
-
-stack_w2float	.proc
-		; -- w2float operating on the stack
-		inx
-		ldy  P8ESTACK_LO,x
-		lda  P8ESTACK_HI,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  GIVAYF
-		jmp  push_fac1._internal
-		.pend
-
-stack_ub2float	.proc
-		; -- ub2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		stx  P8ZP_SCRATCH_REG
-		tay
-		lda  #0
-		jsr  GIVAYF
-		jmp  push_fac1._internal
-		.pend
-
-stack_uw2float	.proc
-		; -- uw2float operating on the stack
-		inx
-		lda  P8ESTACK_LO,x
-		ldy  P8ESTACK_HI,x
-		stx  P8ZP_SCRATCH_REG
-		jsr  GIVUAYFAY
-		jmp  push_fac1._internal
-		.pend
-
-stack_float2w	.proc               ; also used for float2b
-		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG
-		jsr  AYINT
-		ldx  P8ZP_SCRATCH_REG
-		lda  floats.AYINT_facmo
-		sta  P8ESTACK_HI,x
-		lda  floats.AYINT_facmo+1
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-stack_float2uw	.proc               ; also used for float2ub
-		jsr  pop_float_fac1
-		stx  P8ZP_SCRATCH_REG
-		jsr  GETADR
-		ldx  P8ZP_SCRATCH_REG
-		sta  P8ESTACK_HI,x
-		tya
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-push_float	.proc
-		; ---- push mflpt5 in A/Y onto stack
-		; (taking 3 stack positions = 6 bytes of which 1 is padding)
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_HI,x
-		dex
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_HI,x
-		dex
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-pop_float	.proc
-		; ---- pops mflpt5 from stack to memory A/Y
-		; (frees 3 stack positions = 6 bytes of which 1 is padding)
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #4
-		inx
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		inx
-		lda  P8ESTACK_HI,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		inx
-		lda  P8ESTACK_HI,x
-		sta  (P8ZP_SCRATCH_W1),y
-		dey
-		lda  P8ESTACK_LO,x
-		sta  (P8ZP_SCRATCH_W1),y
-		rts
-		.pend
-
-pop_float_fac1	.proc
-		; -- pops float from stack into FAC1
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jmp  MOVFM
-		.pend
-
-copy_float	.proc
-		; -- copies the 5 bytes of the mflt value pointed to by SCRATCH_ZPWORD1,
-		;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
-		sta  _target+1
-		sty  _target+2
-		ldy  #4
-_loop		lda  (P8ZP_SCRATCH_W1),y
-_target		sta  $ffff,y			; modified
-		dey
-		bpl  _loop
-		rts
-		.pend
-
-inc_var_f	.proc
-		; -- add 1 to float pointed to by A/Y
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		stx  P8ZP_SCRATCH_REG
-		jsr  MOVFM
-		lda  #<FL_ONE_const
-		ldy  #>FL_ONE_const
-		jsr  FADD
-		ldx  P8ZP_SCRATCH_W1
-		ldy  P8ZP_SCRATCH_W1+1
-		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-dec_var_f	.proc
-		; -- subtract 1 from float pointed to by A/Y
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<FL_ONE_const
-		ldy  #>FL_ONE_const
-		jsr  MOVFM
-		lda  P8ZP_SCRATCH_W1
-		ldy  P8ZP_SCRATCH_W1+1
-		jsr  FSUB
-		ldx  P8ZP_SCRATCH_W1
-		ldy  P8ZP_SCRATCH_W1+1
-		jsr  MOVMF
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-
-pop_2_floats_f2_in_fac1	.proc
-		; -- pop 2 floats from stack, load the second one in FAC1 as well
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jmp  MOVFM
-		.pend
-
-
-fmath_float1	.byte 0,0,0,0,0	; storage for a mflpt5 value
-fmath_float2	.byte 0,0,0,0,0	; storage for a mflpt5 value
-
-
-push_fac1	.proc
-		; -- push the float in FAC1 onto the stack
-		stx  P8ZP_SCRATCH_REG
-_internal	ldx  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVMF
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		ldx  P8ZP_SCRATCH_REG
-		jmp  push_float
-		.pend
-
-div_f		.proc
-		; -- push f1/f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FDIV
-		jmp  push_fac1._internal
-		.pend
-
-add_f		.proc
-		; -- push f1+f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FADD
-		jmp  push_fac1._internal
-		.pend
-
-sub_f		.proc
-		; -- push f1-f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FSUB
-		jmp  push_fac1._internal
-		.pend
-
-mul_f		.proc
-		; -- push f1*f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  P8ZP_SCRATCH_REG
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FMULT
-		jmp  push_fac1._internal
-		.pend
-
-neg_f		.proc
-		; -- toggle the sign bit on the stack
-		lda  P8ESTACK_HI+3,x
-		eor  #$80
-		sta  P8ESTACK_HI+3,x
-		rts
-		.pend
-
-var_fac1_less_f	.proc
-		; -- is the float in FAC1 < the variable AY?
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
-		cmp  #255
-		beq  +
-		lda  #0
-		rts
-+		lda  #1
-		rts
-		.pend
-
-var_fac1_lesseq_f	.proc
-		; -- is the float in FAC1 <= the variable AY?
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
-		cmp  #0
-		beq  +
-		cmp  #255
-		beq  +
-		lda  #0
-		rts
-+		lda  #1
-		rts
-		.pend
-
-var_fac1_greater_f	.proc
-		; -- is the float in FAC1 > the variable AY?
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
-		cmp  #1
-		beq  +
-		lda  #0
-		rts
-+		lda  #1
-		rts
-		.pend
-
-var_fac1_greatereq_f	.proc
-		; -- is the float in FAC1 >= the variable AY?
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
-		cmp  #0
-		beq  +
-		cmp  #1
-		beq  +
-		lda  #0
-		rts
-+		lda  #1
-		rts
-		.pend
-
-var_fac1_notequal_f	.proc
-		; -- are the floats numbers in FAC1 and the variable AY *not* identical?
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
-		and  #1
-		rts
-		.pend
-
-vars_equal_f	.proc
-		; -- are the mflpt5 numbers in P8ZP_SCRATCH_W1 and AY identical?
-		sta  P8ZP_SCRATCH_W2
-		sty  P8ZP_SCRATCH_W2+1
-		ldy  #0
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  (P8ZP_SCRATCH_W2),y
-		bne  _false
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  (P8ZP_SCRATCH_W2),y
-		bne  _false
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  (P8ZP_SCRATCH_W2),y
-		bne  _false
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  (P8ZP_SCRATCH_W2),y
-		bne  _false
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  (P8ZP_SCRATCH_W2),y
-		bne  _false
-		lda  #1
-		rts
-_false		lda  #0
-		rts
-		.pend
-
-equal_f		.proc
-		; -- are the two mflpt5 numbers on the stack identical?
-		inx
-		inx
-		inx
-		inx
-		lda  P8ESTACK_LO-3,x
-		cmp  P8ESTACK_LO,x
-		bne  _equals_false
-		lda  P8ESTACK_LO-2,x
-		cmp  P8ESTACK_LO+1,x
-		bne  _equals_false
-		lda  P8ESTACK_LO-1,x
-		cmp  P8ESTACK_LO+2,x
-		bne  _equals_false
-		lda  P8ESTACK_HI-2,x
-		cmp  P8ESTACK_HI+1,x
-		bne  _equals_false
-		lda  P8ESTACK_HI-1,x
-		cmp  P8ESTACK_HI+2,x
-		bne  _equals_false
-_equals_true	lda  #1
-_equals_store	inx
-		sta  P8ESTACK_LO+1,x
-		rts
-_equals_false	lda  #0
-		beq  _equals_store
-		.pend
-
-notequal_f	.proc
-		; -- are the two mflpt5 numbers on the stack different?
-		jsr  equal_f
-		eor  #1		; invert the result
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-vars_less_f	.proc
-		; -- is float in AY < float in P8ZP_SCRATCH_W2 ?
-		jsr  MOVFM
-		lda  P8ZP_SCRATCH_W2
-		ldy  P8ZP_SCRATCH_W2+1
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
-		cmp  #255
-		bne  +
-		lda  #1
-		rts
-+		lda  #0
-		rts
-		.pend
-
-vars_lesseq_f	.proc
-		; -- is float in AY <= float in P8ZP_SCRATCH_W2 ?
-		jsr  MOVFM
-		lda  P8ZP_SCRATCH_W2
-		ldy  P8ZP_SCRATCH_W2+1
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP
-		ldx  P8ZP_SCRATCH_REG
-		cmp  #255
-		bne  +
--		lda  #1
-		rts
-+		cmp  #0
-		beq  -
-		lda  #0
-		rts
-		.pend
-
-less_f		.proc
-		; -- is f1 < f2?
-		jsr  compare_floats
-		cmp  #255
-		beq  compare_floats._return_true
-		bne  compare_floats._return_false
-		.pend
-
-
-lesseq_f	.proc
-		; -- is f1 <= f2?
-		jsr  compare_floats
-		cmp  #255
-		beq  compare_floats._return_true
-		cmp  #0
-		beq  compare_floats._return_true
-		bne  compare_floats._return_false
-		.pend
-
-greater_f	.proc
-		; -- is f1 > f2?
-		jsr  compare_floats
-		cmp  #1
-		beq  compare_floats._return_true
-		bne  compare_floats._return_false
-		.pend
-
-greatereq_f	.proc
-		; -- is f1 >= f2?
-		jsr  compare_floats
-		cmp  #1
-		beq  compare_floats._return_true
-		cmp  #0
-		beq  compare_floats._return_true
-		bne  compare_floats._return_false
-		.pend
-
-compare_floats	.proc
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVFM		; fac1 = flt1
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		stx  P8ZP_SCRATCH_REG
-		jsr  FCOMP		; A = flt1 compared with flt2 (0=equal, 1=flt1>flt2, 255=flt1<flt2)
-		ldx  P8ZP_SCRATCH_REG
-		rts
-_return_false	lda  #0
-_return_result  sta  P8ESTACK_LO,x
-		dex
-		rts
-_return_true	lda  #1
-		bne  _return_result
-		.pend
-
-set_array_float_from_fac1	.proc
-		; -- set the float in FAC1 in the array (index in A, array in P8ZP_SCRATCH_W1)
-		sta  P8ZP_SCRATCH_B1
-		asl  a
-		asl  a
-		clc
-		adc  P8ZP_SCRATCH_B1
-		ldy  P8ZP_SCRATCH_W1+1
-		clc
-		adc  P8ZP_SCRATCH_W1
-		bcc  +
-		iny
-+		stx  floats_store_reg
-		tax
-		jsr  MOVMF
-		ldx  floats_store_reg
-		rts
-		.pend
-
-
-set_0_array_float	.proc
-		; -- set a float in an array to zero (index in A, array in P8ZP_SCRATCH_W1)
-		sta  P8ZP_SCRATCH_B1
-		asl  a
-		asl  a
-		clc
-		adc  P8ZP_SCRATCH_B1
-		tay
-		lda  #0
-		sta  (P8ZP_SCRATCH_W1),y
-		iny
-		sta  (P8ZP_SCRATCH_W1),y
-		iny
-		sta  (P8ZP_SCRATCH_W1),y
-		iny
-		sta  (P8ZP_SCRATCH_W1),y
-		iny
-		sta  (P8ZP_SCRATCH_W1),y
-		rts
-		.pend
-
-
-set_array_float		.proc
-		; -- set a float in an array to a value (index in A, float in P8ZP_SCRATCH_W1, array in P8ZP_SCRATCH_W2)
-		sta  P8ZP_SCRATCH_B1
-		asl  a
-		asl  a
-		clc
-		adc  P8ZP_SCRATCH_B1
-		adc  P8ZP_SCRATCH_W2
-		ldy  P8ZP_SCRATCH_W2+1
-		bcc  +
-		iny
-+		jmp  copy_float
-			; -- copies the 5 bytes of the mflt value pointed to by SCRATCH_ZPWORD1,
-			;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
-		.pend
-
-

compiler/res/prog8lib/c128/floats.p8

@@ -1,158 +0,0 @@
-; Prog8 definitions for floating point handling on the Commodore 128
-
-%option enable_floats
-%import floats_functions
-
-floats {
-	; ---- this block contains C-128 compatible floating point related functions ----
-
-        const float  PI     = 3.141592653589793
-        const float  TWOPI  = 6.283185307179586
-
-
-; ---- ROM float functions ----
-
-		; note: the fac1 and fac2 are working registers and take 6 bytes each,
-		; floats in memory  (and rom) are stored in 5-byte MFLPT packed format.
-
-; note: fac1/2 might get clobbered even if not mentioned in the function's name.
-; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.
-
-romsub $af00 = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 102-103 ($66-$67) MSB FIRST. (might throw ILLEGAL QUANTITY)
-
-; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1
-; there is also floats.GIVUAYFAY - unsigned word in A/Y (lo/hi) to fac1
-; (tip: use GIVAYFAY to use A/Y input; lo/hi switched to normal order)
-romsub $af03 = GIVAYF(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)
-
-romsub $af06 = FOUT() clobbers(X) -> uword @ AY             ; fac1 -> string, address returned in AY
-; romsub $af09 = VAL_1() clobbers(A,X,Y)                      ; convert ASCII string to floating point [not yet implemented!!!]
-
-; 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)
-romsub $af0c = GETADR() clobbers(X) -> ubyte @ Y, ubyte @ A
-romsub $af0f = FLOATC() clobbers(A,X,Y)                     ; convert address to floating point
-
-romsub $af12 = FSUB(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt from A/Y - fac1
-romsub $af15 = FSUBT() clobbers(A,X,Y)                      ; fac1 = fac2-fac1   mind the order of the operands         NOTE: use FSUBT2() instead!
-romsub $af18 = FADD(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 += mflpt value from A/Y
-romsub $af1b = FADDT() clobbers(A,X,Y)                      ; fac1 += fac2      NOTE: use FADDT2() instead!
-romsub $af1e = FMULT(uword mflpt @ AY) clobbers(A,X,Y)      ; fac1 *= mflpt value from A/Y
-romsub $af21 = FMULTT() clobbers(A,X,Y)                     ; fac1 *= fac2      NOTE: use FMULTT2() instead!
-romsub $af24 = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
-romsub $af27 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands  NOTE: use FDIVT2() instead!
-romsub $af2a = LOG() clobbers(A,X,Y)                        ; fac1 = LN(fac1)  (natural log)
-romsub $af2d = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to round instead of trunc
-romsub $af30 = SQR() clobbers(A,X,Y)                        ; fac1 = SQRT(fac1)
-romsub $af33 = NEGOP() clobbers(A)                          ; switch the sign of fac1 (fac1 = -fac1)
-romsub $af36 = FPWR(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = fac2 ** float in A/Y
-romsub $af39 = FPWRT() clobbers(A,X,Y)                      ; fac1 = fac2 ** fac1           NOTE: use FPWRT2() instead!
-romsub $af3c = EXP() clobbers(A,X,Y)                        ; fac1 = EXP(fac1)  (e ** fac1)
-romsub $af3f = COS() clobbers(A,X,Y)                        ; fac1 = COS(fac1)
-romsub $af42 = SIN() clobbers(A,X,Y)                        ; fac1 = SIN(fac1)
-romsub $af45 = TAN() clobbers(A,X,Y)                        ; fac1 = TAN(fac1)
-romsub $af48 = ATN() clobbers(A,X,Y)                        ; fac1 = ATN(fac1)
-romsub $af4b = ROUND() clobbers(A,X,Y)                      ; round fac1
-romsub $af4e = ABS() clobbers(A,X,Y)                        ; fac1 = ABS(fac1)
-romsub $af51 = SIGN() clobbers(X,Y) -> ubyte @ A            ; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
-romsub $af54 = 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 $af57 = RND_0() clobbers(A,X,Y)                      ; fac1 = RND(fac1) float random number generator
-romsub $af57 = RND() clobbers(A,X,Y)                        ; alias for RND_0
-romsub $af5a = CONUPK(uword mflpt @ AY) clobbers(A,X,Y)     ; load mflpt value from memory  in A/Y into fac2
-romsub $af5d = ROMUPK(uword mflpt @ AY) clobbers(A,X,Y)     ; load mflpt value from memory in current bank in A/Y into fac2
-romsub $af60 = MOVFRM(uword mflpt @ AY) clobbers(A,X,Y)     ; load mflpt value from memory in A/Y into fac1  (use MOVFM instead)
-romsub $af63 = MOVFM(uword mflpt @ AY) clobbers(A,X,Y)      ; load mflpt value from memory  in A/Y into fac1
-romsub $af66 = MOVMF(uword mflpt @ XY) clobbers(A,X,Y)      ; store fac1 to memory  X/Y as 5-byte mflpt
-romsub $af69 = MOVFA() clobbers(A,X)                        ; copy fac2 to fac1
-romsub $af6c = MOVAF() clobbers(A,X)                        ; copy fac1 to fac2  (rounded)
-
-; X16 additions
-romsub $af6f = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for rounding- call this before INT
-romsub $af72 = FADDT2() clobbers(A,X,Y)                     ; fac1 += fac2
-romsub $af75 = ZEROFC() clobbers(A,X,Y)                     ; fac1 = 0
-romsub $af78 = NORMAL() clobbers(A,X,Y)                     ; normalize fac1 (?)
-romsub $af7b = NEGFAC() clobbers(A)                         ; switch the sign of fac1 (fac1 = -fac1) (juse use NEGOP() instead!)
-romsub $af7e = FMULTT2() clobbers(A,X,Y)                    ; fac1 *= fac2
-romsub $af81 = MUL10() clobbers(A,X,Y)                      ; fac1 *= 10
-romsub $af84 = DIV10() clobbers(A,X,Y)                      ; fac1 /= 10 , CAUTION: result is always positive!
-romsub $af87 = FDIVT2() clobbers(A,X,Y)                     ; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
-romsub $af8a = MOVEF() clobbers(A,X)                        ; copy fac1 to fac2
-romsub $af8d = SGN() clobbers(A,X,Y)                        ; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
-romsub $af90 = FLOAT() clobbers(A,X,Y)                      ; FAC = (u8).A
-romsub $af93 = FLOATS() clobbers(A,X,Y)                     ; FAC = (s16)facho+1:facho
-romsub $af9C = QINT() clobbers(A,X,Y)                       ; facho:facho+1:facho+2:facho+3 = u32(FAC)
-romsub $af9f = FINLOG(byte value @A) clobbers (A, X, Y)     ; fac1 += signed byte in A
-romsub $afa5 = FPWRT2() clobbers(A,X,Y)                     ; fac1 = fac2 ** fac1
-
-asmsub  FREADSA  (byte value @A) clobbers(A,X,Y) {
-    ; ---- 8 bit signed A -> float in fac1
-    %asm {{
-        tay
-        bpl  +
-        lda  #$ff
-        jmp  GIVAYF
-+       lda  #0
-        jmp  GIVAYF
-    }}
-}
-
-asmsub  GIVUAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- unsigned 16 bit word in A/Y (lo/hi) to fac1
-	%asm {{
-	phx
-	sty  $64        ; facmo
-	sta  $65        ; facmo+1
-	ldx  #$90
-	sec
-	jsr  FLOATC
-	plx
-	rts
-	}}
-}
-
-asmsub  GIVAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
-	; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1
-	%asm {{
-		sta  P8ZP_SCRATCH_B1
-		tya
-		ldy  P8ZP_SCRATCH_B1
-		jmp  GIVAYF		; this uses the inverse order, Y/A
-	}}
-}
-
-asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
-	; ---- fac1 to unsigned word in A/Y
-	%asm {{
-		jsr  GETADR		; this uses the inverse order, Y/A
-		sta  P8ZP_SCRATCH_B1
-		tya
-		ldy  P8ZP_SCRATCH_B1
-		rts
-	}}
-}
-
-asmsub  FREADUY (ubyte value @Y) {
-    ; -- 8 bit unsigned Y -> float in fac1
-    %asm {{
-        tya
-        jmp  FLOAT
-    }}
-}
-
-&uword AYINT_facmo = $66      ; $66/$67 contain result of AYINT
-
-sub rndf() -> float {
-    %asm {{
-        stx  P8ZP_SCRATCH_REG
-        lda  #1
-        jsr  RND_0
-        ldx  P8ZP_SCRATCH_REG
-        rts
-    }}
-}
-
-
-%asminclude "library:c128/floats.asm"
-%asminclude "library:c64/floats_funcs.asm"
-
-}

compiler/res/prog8lib/c128/syslib.p8

@@ -8,10 +8,9 @@ c64 {
         &ubyte  TIME_LO         = $a2       ;    .. lo byte. Updated by IRQ every 1/60 sec
         &ubyte  STATUS          = $90       ; kernal status variable for I/O
         &ubyte  STKEY           = $91       ; various keyboard statuses (updated by IRQ)
-        ;;&ubyte  SFDX            = $cb       ; current key pressed (matrix value) (updated by IRQ)     // TODO c128 ??
-
-        &ubyte  COLOR           = $00f1     ; cursor color
-        ;;&ubyte  HIBASE          = $0288     ; screen base address / 256 (hi-byte of screen memory address)        // TODO c128 ??
+        &ubyte  SHFLAG          = $d3       ; various modifier key status (updated by IRQ)
+        &ubyte  SFDX            = $d4       ; current key pressed (matrix value) (updated by IRQ)
+        &ubyte  COLOR           = $f1       ; cursor color
 
         &uword  IERROR          = $0300
         &uword  IMAIN           = $0302
@@ -311,7 +310,7 @@ asmsub  set_irq(uword handler @AY, ubyte useKernal @Pc) clobbers(A)  {
 	        sta  _modified+1
 	        sty  _modified+2
 	        lda  #0
-	        adc  #0
+	        rol  a
 	        sta  _use_kernal
 		sei
 		lda  #<_irq_handler
@@ -340,8 +339,7 @@ _modified	jsr  $ffff                      ; modified
 _use_kernal     .byte  0
 
 _irq_handler_init
-		; save all zp scratch registers and the X register as these might be clobbered by the irq routine
-		stx  IRQ_X_REG
+		; 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
@@ -354,18 +352,15 @@ _irq_handler_init
 		sta  IRQ_SCRATCH_ZPWORD2
 		lda  P8ZP_SCRATCH_W2+1
 		sta  IRQ_SCRATCH_ZPWORD2+1
-		; stack protector; make sure we don't clobber the top of the evaluation stack
-		dex
-		dex
-		dex
-		dex
-		dex
-		dex
+		; Set X to the bottom 32 bytes of the evaluation stack, to HOPEFULLY not clobber it.
+		; This leaves 128-32=96 stack entries for the main program, and 32 stack entries for the IRQ handler.
+		; We assume IRQ handlers don't contain complex expressions taking up more than that.
+		ldx  #32
 		cld
 		rts
 
 _irq_handler_end
-		; restore all zp scratch registers and the X register
+		; restore all zp scratch registers
 		lda  IRQ_SCRATCH_ZPB1
 		sta  P8ZP_SCRATCH_B1
 		lda  IRQ_SCRATCH_ZPREG
@@ -378,10 +373,8 @@ _irq_handler_end
 		sta  P8ZP_SCRATCH_W2
 		lda  IRQ_SCRATCH_ZPWORD2+1
 		sta  P8ZP_SCRATCH_W2+1
-		ldx  IRQ_X_REG
 		rts
 
-IRQ_X_REG		.byte  0
 IRQ_SCRATCH_ZPB1	.byte  0
 IRQ_SCRATCH_ZPREG	.byte  0
 IRQ_SCRATCH_ZPWORD1	.word  0
@@ -411,7 +404,7 @@ asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0, ubyte useKernal @P
 	        sta  _modified+1
 	        sty  _modified+2
 	        lda  #0
-	        adc  #0
+	        rol  a
 	        sta  set_irq._use_kernal
 		lda  cx16.r0
 		ldy  cx16.r0+1
@@ -486,10 +479,8 @@ asmsub  init_system()  {
     %asm {{
         sei
         cld
-        ;;lda  #%00101111                     ; TODO c128 ram and rom bank selection how?
-        ;;sta  $00
-        ;;lda  #%00100111
-        ;;sta  $01
+        lda  #0
+        sta  $ff00      ; select default bank 15
         jsr  c64.IOINIT
         jsr  c64.RESTOR
         jsr  c64.CINT
@@ -555,8 +546,8 @@ sys {
         ; Soft-reset the system back to initial power-on Basic prompt.
         %asm {{
             sei
-            ;lda  #14
-            ;sta  $01        ; bank the kernal in       TODO c128 how to do this?
+            lda  #0
+            sta  $ff00      ; default bank 15
             jmp  (c64.RESET_VEC)
         }}
     }
@@ -737,8 +728,8 @@ _longcopy
     inline asmsub exit(ubyte returnvalue @A) {
         ; -- immediately exit the program with a return code in the A register
         %asm {{
-            ;lda  #14
-            ;sta  $01        ; bank the kernal in       TODO c128 how to do this?
+            lda  #0
+            sta  $ff00          ; default bank 15
             jsr  c64.CLRCHN		; reset i/o channels
             jsr  c64.enable_runstop_and_charsetswitch
             ldx  prog8_lib.orig_stackpointer

compiler/res/prog8lib/c64/floats.asm

@@ -6,7 +6,7 @@ FL_LOG2_const	.byte  $80, $31, $72, $17, $f8	; log(2)
 
 
 floats_store_reg	.byte  0		; temp storage
-
+floats_temp_var         .byte  0,0,0,0,0        ; temporary storage for a float
 
 ub2float	.proc
 		; -- convert ubyte in SCRATCH_ZPB1 to float at address A/Y

compiler/res/prog8lib/c64/floats.p8

@@ -60,8 +60,8 @@ romsub $b853 = FSUBT() clobbers(A,X,Y)                      ; fac1 = fac2-fac1
 romsub $b850 = FSUB(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt from A/Y - fac1
 romsub $ba2b = FMULTT() clobbers(A,X,Y)                     ; fac1 *= fac2
 romsub $ba28 = FMULT(uword mflpt @ AY) clobbers(A,X,Y)      ; fac1 *= mflpt value from A/Y
-romsub $bb12 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
-romsub $bb0f = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
+romsub $bb12 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  mind the order of the operands
+romsub $bb0f = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1
 romsub $bf7b = FPWRT() clobbers(A,X,Y)                      ; fac1 = fac2 ** fac1
 romsub $bf78 = FPWR(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = fac2 ** mflpt from A/Y
 romsub $bd7e = FINLOG(byte value @A) clobbers (A, X, Y)     ; fac1 += signed byte in A

compiler/res/prog8lib/c64/syslib.p8

@@ -8,6 +8,7 @@ c64 {
         &ubyte  STATUS          = $90       ; kernal status variable for I/O
         &ubyte  STKEY           = $91       ; various keyboard statuses (updated by IRQ)
         &ubyte  SFDX            = $cb       ; current key pressed (matrix value) (updated by IRQ)
+        &ubyte  SHFLAG          = $028d     ; various modifier key status (updated by IRQ)
 
         &ubyte  COLOR           = $0286     ; cursor color
         &ubyte  HIBASE          = $0288     ; screen base address / 256 (hi-byte of screen memory address)
@@ -355,7 +356,7 @@ asmsub  set_irq(uword handler @AY, ubyte useKernal @Pc) clobbers(A)  {
 	        sta  _modified+1
 	        sty  _modified+2
 	        lda  #0
-	        adc  #0
+	        rol  a
 	        sta  _use_kernal
 		sei
 		lda  #<_irq_handler
@@ -384,8 +385,7 @@ _modified	jsr  $ffff                      ; modified
 _use_kernal     .byte  0
 
 _irq_handler_init
-		; save all zp scratch registers and the X register as these might be clobbered by the irq routine
-		stx  IRQ_X_REG
+		; 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
@@ -398,18 +398,15 @@ _irq_handler_init
 		sta  IRQ_SCRATCH_ZPWORD2
 		lda  P8ZP_SCRATCH_W2+1
 		sta  IRQ_SCRATCH_ZPWORD2+1
-		; stack protector; make sure we don't clobber the top of the evaluation stack
-		dex
-		dex
-		dex
-		dex
-		dex
-		dex
+		; Set X to the bottom 32 bytes of the evaluation stack, to HOPEFULLY not clobber it.
+		; This leaves 128-32=96 stack entries for the main program, and 32 stack entries for the IRQ handler.
+		; We assume IRQ handlers don't contain complex expressions taking up more than that.
+		ldx  #32
 		cld
 		rts
 
 _irq_handler_end
-		; restore all zp scratch registers and the X register
+		; restore all zp scratch registers
 		lda  IRQ_SCRATCH_ZPB1
 		sta  P8ZP_SCRATCH_B1
 		lda  IRQ_SCRATCH_ZPREG
@@ -422,10 +419,8 @@ _irq_handler_end
 		sta  P8ZP_SCRATCH_W2
 		lda  IRQ_SCRATCH_ZPWORD2+1
 		sta  P8ZP_SCRATCH_W2+1
-		ldx  IRQ_X_REG
 		rts
 
-IRQ_X_REG		.byte  0
 IRQ_SCRATCH_ZPB1	.byte  0
 IRQ_SCRATCH_ZPREG	.byte  0
 IRQ_SCRATCH_ZPWORD1	.word  0
@@ -455,7 +450,7 @@ asmsub  set_rasterirq(uword handler @AY, uword rasterpos @R0, ubyte useKernal @P
 	        sta  _modified+1
 	        sty  _modified+2
 	        lda  #0
-	        adc  #0
+	        rol  a
 	        sta  set_irq._use_kernal
 		lda  cx16.r0
 		ldy  cx16.r0+1

compiler/res/prog8lib/cx16/floats.p8

@@ -5,7 +5,6 @@
 
 floats {
 	; ---- this block contains C-64 compatible floating point related functions ----
-	;      the addresses are from cx16 V39 emulator and roms! they won't work on older versions.
 
         const float  PI     = 3.141592653589793
         const float  TWOPI  = 6.283185307179586
@@ -40,8 +39,8 @@ romsub $fe18 = FADD(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 += mflpt valu
 romsub $fe1b = FADDT() clobbers(A,X,Y)                      ; fac1 += fac2
 romsub $fe1e = FMULT(uword mflpt @ AY) clobbers(A,X,Y)      ; fac1 *= mflpt value from A/Y
 romsub $fe21 = FMULTT() clobbers(A,X,Y)                     ; fac1 *= fac2
-romsub $fe24 = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
-romsub $fe27 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
+romsub $fe24 = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1
+romsub $fe27 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  mind the order of the operands
 romsub $fe2a = LOG() clobbers(A,X,Y)                        ; fac1 = LN(fac1)  (natural log)
 romsub $fe2d = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to round instead of trunc
 romsub $fe30 = SQR() clobbers(A,X,Y)                        ; fac1 = SQRT(fac1)
@@ -76,7 +75,7 @@ romsub $fe7b = MUL10() clobbers(A,X,Y)                      ; fac1 *= 10
 romsub $fe7e = DIV10() clobbers(A,X,Y)                      ; fac1 /= 10 , CAUTION: result is always positive!
 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 = (u8).A
+romsub $fe87 = FLOAT() clobbers(A,X,Y)                      ; FAC = (s8).A
 romsub $fe8a = FLOATS() clobbers(A,X,Y)                     ; FAC = (s16)facho+1:facho
 romsub $fe8d = QINT() clobbers(A,X,Y)                       ; facho:facho+1:facho+2:facho+3 = u32(FAC)
 romsub $fe90 = FINLOG(byte value @A) clobbers (A, X, Y)     ; fac1 += signed byte in A
@@ -133,8 +132,8 @@ asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
 asmsub  FREADUY (ubyte value @Y) {
     ; -- 8 bit unsigned Y -> float in fac1
     %asm {{
-        tya
-        jmp  FLOAT
+        lda  #0
+        jmp  GIVAYF
     }}
 }
 

compiler/res/prog8lib/cx16/graphics.p8

@@ -143,7 +143,7 @@ graphics {
     inline asmsub  plot(uword plotx @R0, uword ploty @R1) clobbers(A, X, Y) {
         %asm {{
             jsr  cx16.FB_cursor_position
-            lda  #1
+            lda  graphics.stroke_color
             jsr  cx16.FB_set_pixel
         }}
     }

compiler/res/prog8lib/cx16/psg.p8

@@ -22,6 +22,10 @@ psg {
         ;    waveform = one of PULSE,SAWTOOTH,TRIANGLE,NOISE.
         ;    pulsewidth = 0-63.  Specifies the pulse width for waveform=PULSE.
         envelope_states[voice_num] = 255
+        %asm {{
+            php
+            sei
+        }}
         cx16.r0 = $f9c2 + voice_num * 4
         cx16.VERA_CTRL = 0
         cx16.VERA_ADDR_L = lsb(cx16.r0)
@@ -32,6 +36,9 @@ psg {
         cx16.VERA_DATA0 = waveform | pulsewidth
         envelope_volumes[voice_num] = mkword(volume, 0)
         envelope_maxvolumes[voice_num] = volume
+        %asm {{
+            plp
+        }}
     }
 
 ;    sub freq_hz(ubyte voice_num, float hertz) {
@@ -44,48 +51,54 @@ psg {
     sub freq(ubyte voice_num, uword vera_freq) {
         ; -- Changes the frequency of the voice's sound.
         ;    voice_num = 0-15,  vera_freq = 0-65535  calculate this via the formula given in the Vera's PSG documentation.
-        ;    (https://github.com/commanderx16/x16-docs/blob/master/VERA%20Programmer's%20Reference.md)
-        cx16.r0 = $f9c0 + voice_num * 4
+        ;    (https://github.com/x16community/x16-docs/blob/master/VERA%20Programmer's%20Reference.md)
+        ;    Write freq MSB first and then LSB to reduce the chance on clicks
+        %asm {{
+            php
+            sei
+        }}
+        cx16.r0 = $f9c1 + voice_num * 4
         cx16.VERA_CTRL = 0
         cx16.VERA_ADDR_L = lsb(cx16.r0)
         cx16.VERA_ADDR_M = msb(cx16.r0)
         cx16.VERA_ADDR_H = 1
-        cx16.VERA_DATA0 = lsb(vera_freq)
-        cx16.VERA_ADDR_L++
         cx16.VERA_DATA0 = msb(vera_freq)
+        cx16.VERA_ADDR_L--
+        cx16.VERA_DATA0 = lsb(vera_freq)
+        %asm {{
+            plp
+        }}
     }
 
     sub volume(ubyte voice_num, ubyte vol) {
         ; -- Modifies the volume of this voice.
         ;    voice_num = 0-15, vol = 0-63 where 0=silent, 63=loudest.
-        cx16.r0 = $f9c2 + voice_num * 4
-        cx16.vpoke(1, cx16.r0, cx16.vpeek(1, cx16.r0) & %11000000 | vol)
         envelope_volumes[voice_num] = mkword(vol, 0)
+        cx16.vpoke_mask(1, $f9c2 + voice_num * 4, %11000000, vol)
         envelope_maxvolumes[voice_num] = vol
     }
 
     sub pulse_width(ubyte voice_num, ubyte pw) {
         ; -- Modifies the pulse width of this voice (when waveform=PULSE)
         ;    voice_num = 0-15, pw = 0-63  where 0=narrow, 63=50%cycle so square wave.
-        cx16.r0 = $f9c3 + voice_num * 4
-        cx16.vpoke(1, cx16.r0, cx16.vpeek(1, cx16.r0) & %11000000 | pw)
+        cx16.vpoke_mask(1, $f9c3 + voice_num * 4, %11000000, pw)
     }
 
     sub envelope(ubyte voice_num, ubyte maxvolume, ubyte attack, ubyte sustain, ubyte release) {
         ; -- Enables AttackSustainRelease volume envelope for a voice.
         ;    Note: this requires setting up envelopes_irq() as well, read its description.
         ;    voice_num = 0-15   maxvolume = 0-63
-        ;    attack, sustain, release = 0-255 that determine the speed of the A/D/R.
-        ;    TODO describe how the speeds are calculated. For now, experiment. Higher values means *slower* enveloping.
+        ;    attack, sustain, release = 0-255 that determine the speed of the A/D/R:
+        ;    attack time:    MAXVOL/15/attack  seconds.    higher value = faster attack.
+        ;    sustain time:   sustain/60 seconds    higher sustain value = longer sustain (!).
+        ;    release time:   MAXVOL/15/release seconds.   higher vaule = faster release.
+
         envelope_states[voice_num] = 255
         envelope_attacks[voice_num] = attack
         envelope_sustains[voice_num] = sustain
         envelope_releases[voice_num] = release
-        if attack
-            attack = 0
-        else
-            attack = maxvolume     ; max volume when no attack is set
-        envelope_volumes[voice_num] = mkword(attack, 0)
+        if maxvolume<envelope_volumes[voice_num]
+            envelope_volumes[voice_num] = maxvolume
         envelope_maxvolumes[voice_num] = maxvolume
         envelope_states[voice_num] = 0
     }
@@ -94,7 +107,6 @@ psg {
         ; -- Shut down all PSG voices.
         for cx16.r1L in 0 to 15 {
             envelope_states[cx16.r1L] = 255
-            envelope_volumes[cx16.r1L] = 0
             volume(cx16.r1L, 0)
         }
     }
@@ -104,11 +116,11 @@ psg {
         ; 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)
+        ; 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)
         ; cx16.r1L = the voice number
         ; cx16.r2L = attack value
-
         pushw(cx16.r0)
         push(cx16.r1L)
         push(cx16.r2L)
@@ -148,7 +160,7 @@ psg {
         }
 
         ; set new volumes of all 16 voices, using vera stride of 4
-        cx16.push_vera_context()
+        cx16.save_vera_context()
         cx16.VERA_CTRL = 0
         cx16.VERA_ADDR_L = $c2
         cx16.VERA_ADDR_M = $f9
@@ -160,7 +172,7 @@ psg {
         for cx16.r1L in 0 to 15 {
             cx16.VERA_DATA0 = cx16.VERA_DATA1 & %11000000 | msb(envelope_volumes[cx16.r1L])
         }
-        cx16.pop_vera_context()
+        cx16.restore_vera_context()
         popw(cx16.r9)
         pop(cx16.r2L)
         pop(cx16.r1L)

compiler/res/prog8lib/cx16/syslib.p8

@@ -233,14 +233,18 @@ cx16 {
     &ubyte  VERA_IEN            = VERA_BASE + $0006
     &ubyte  VERA_ISR            = VERA_BASE + $0007
     &ubyte  VERA_IRQ_LINE_L     = VERA_BASE + $0008
-    &ubyte  VERA_DC_VIDEO       = VERA_BASE + $0009
-    &ubyte  VERA_DC_HSCALE      = VERA_BASE + $000A
-    &ubyte  VERA_DC_VSCALE      = VERA_BASE + $000B
-    &ubyte  VERA_DC_BORDER      = VERA_BASE + $000C
-    &ubyte  VERA_DC_HSTART      = VERA_BASE + $0009
-    &ubyte  VERA_DC_HSTOP       = VERA_BASE + $000A
-    &ubyte  VERA_DC_VSTART      = VERA_BASE + $000B
-    &ubyte  VERA_DC_VSTOP       = VERA_BASE + $000C
+    &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
+    &ubyte  VERA_DC_BORDER      = VERA_BASE + $000C ; DCSEL= 0
+    &ubyte  VERA_DC_HSTART      = VERA_BASE + $0009 ; DCSEL= 1
+    &ubyte  VERA_DC_HSTOP       = VERA_BASE + $000A ; DCSEL= 1
+    &ubyte  VERA_DC_VSTART      = VERA_BASE + $000B ; DCSEL= 1
+    &ubyte  VERA_DC_VSTOP       = VERA_BASE + $000C ; DCSEL= 1
+    &ubyte  VERA_DC_VER0        = VERA_BASE + $0009 ; DCSEL=63
+    &ubyte  VERA_DC_VER1        = VERA_BASE + $000A ; DCSEL=63
+    &ubyte  VERA_DC_VER2        = VERA_BASE + $000B ; DCSEL=63
+    &ubyte  VERA_DC_VER3        = VERA_BASE + $000C ; DCSEL=63
     &ubyte  VERA_L0_CONFIG      = VERA_BASE + $000D
     &ubyte  VERA_L0_MAPBASE     = VERA_BASE + $000E
     &ubyte  VERA_L0_TILEBASE    = VERA_BASE + $000F
@@ -266,41 +270,41 @@ cx16 {
 
 ; I/O
 
-    const uword  via1   = $9f00                  ;VIA 6522 #1
-    &ubyte  d1prb	= via1+0
-    &ubyte  d1pra	= via1+1
-    &ubyte  d1ddrb	= via1+2
-    &ubyte  d1ddra	= via1+3
-    &ubyte  d1t1l	= via1+4
-    &ubyte  d1t1h	= via1+5
-    &ubyte  d1t1ll	= via1+6
-    &ubyte  d1t1lh	= via1+7
-    &ubyte  d1t2l	= via1+8
-    &ubyte  d1t2h	= via1+9
-    &ubyte  d1sr	= via1+10
-    &ubyte  d1acr	= via1+11
-    &ubyte  d1pcr	= via1+12
-    &ubyte  d1ifr	= via1+13
-    &ubyte  d1ier	= via1+14
-    &ubyte  d1ora	= via1+15
+    const uword  VIA1_BASE   = $9f00                  ;VIA 6522 #1
+    &ubyte  via1prb	= VIA1_BASE + 0
+    &ubyte  via1pra	= VIA1_BASE + 1
+    &ubyte  via1ddrb	= VIA1_BASE + 2
+    &ubyte  via1ddra	= VIA1_BASE + 3
+    &ubyte  via1t1l	= VIA1_BASE + 4
+    &ubyte  via1t1h	= VIA1_BASE + 5
+    &ubyte  via1t1ll	= VIA1_BASE + 6
+    &ubyte  via1t1lh	= VIA1_BASE + 7
+    &ubyte  via1t2l	= VIA1_BASE + 8
+    &ubyte  via1t2h	= VIA1_BASE + 9
+    &ubyte  via1sr	= VIA1_BASE + 10
+    &ubyte  via1acr	= VIA1_BASE + 11
+    &ubyte  via1pcr	= VIA1_BASE + 12
+    &ubyte  via1ifr	= VIA1_BASE + 13
+    &ubyte  via1ier	= VIA1_BASE + 14
+    &ubyte  via1ora	= VIA1_BASE + 15
 
-    const uword  via2   = $9f10                  ;VIA 6522 #2
-    &ubyte  d2prb	= via2+0
-    &ubyte  d2pra	= via2+1
-    &ubyte  d2ddrb	= via2+2
-    &ubyte  d2ddra	= via2+3
-    &ubyte  d2t1l	= via2+4
-    &ubyte  d2t1h	= via2+5
-    &ubyte  d2t1ll	= via2+6
-    &ubyte  d2t1lh	= via2+7
-    &ubyte  d2t2l	= via2+8
-    &ubyte  d2t2h	= via2+9
-    &ubyte  d2sr	= via2+10
-    &ubyte  d2acr	= via2+11
-    &ubyte  d2pcr	= via2+12
-    &ubyte  d2ifr	= via2+13
-    &ubyte  d2ier	= via2+14
-    &ubyte  d2ora	= via2+15
+    const uword  VIA2_BASE   = $9f10                  ;VIA 6522 #2
+    &ubyte  via2prb	= VIA2_BASE + 0
+    &ubyte  via2pra	= VIA2_BASE + 1
+    &ubyte  via2ddrb	= VIA2_BASE + 2
+    &ubyte  via2ddra	= VIA2_BASE + 3
+    &ubyte  via2t1l	= VIA2_BASE + 4
+    &ubyte  via2t1h	= VIA2_BASE + 5
+    &ubyte  via2t1ll	= VIA2_BASE + 6
+    &ubyte  via2t1lh	= VIA2_BASE + 7
+    &ubyte  via2t2l	= VIA2_BASE + 8
+    &ubyte  via2t2h	= VIA2_BASE + 9
+    &ubyte  via2sr	= VIA2_BASE + 10
+    &ubyte  via2acr	= VIA2_BASE + 11
+    &ubyte  via2pcr	= VIA2_BASE + 12
+    &ubyte  via2ifr	= VIA2_BASE + 13
+    &ubyte  via2ier	= VIA2_BASE + 14
+    &ubyte  via2ora	= VIA2_BASE + 15
 
 ; YM-2151 sound chip
     &ubyte  YM_ADDRESS	= $9f40
@@ -345,7 +349,7 @@ romsub $ff41 = GRAPH_put_next_char(ubyte char @A)  clobbers(A,X,Y)     ; alias f
 ; framebuffer
 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 bytecount @X)  clobbers(A,X,Y)
+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)
@@ -394,6 +398,14 @@ romsub $ff53 = joystick_scan()  clobbers(A, X, Y)
 romsub $ff56 = joystick_get(ubyte joynr @A) -> ubyte @A, ubyte @X, ubyte @Y
 romsub $ff56 = joystick_get2(ubyte joynr @A) clobbers(Y) -> uword @AX   ; alternative to above to not have the hassle to deal with multiple return values
 
+; Audio (bank 10)
+romsub $C04B = psg_init() clobbers(A,X,Y)
+romsub $C063 = ym_init() clobbers(A,X,Y) -> ubyte @Pc                   ; (re)init YM chip
+romsub $C066 = ym_loaddefpatches() clobbers(A,X,Y) -> ubyte @Pc         ; load default YM patches
+romsub $C09F = audio_init() clobbers(A,X,Y) -> ubyte @Pc                ; (re)initialize PSG and YM audio chips
+; TODO: add more of the audio routines?
+
+
 asmsub kbdbuf_clear() {
     ; -- convenience helper routine to clear the keyboard buffer
     %asm {{
@@ -592,39 +604,24 @@ asmsub vpoke_xor(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers (A)
     }}
 }
 
-
-sub FB_set_pixels_from_buf(uword buffer, uword count) {
+asmsub vpoke_mask(ubyte bank @A, uword address @R0, ubyte mask @X, ubyte value @Y) clobbers (A) {
+    ; -- bitwise or a single byte to the value already in the VERA's video memory at that location
+    ;    after applying the and-mask. Note: inefficient when writing multiple sequential bytes!
     %asm {{
-            ; -- This is replacement code for the normal FB_set_pixels subroutine in ROM
-            ;    However that routine contains a bug in the current v38 ROM that makes it crash when count > 255.
-            ;    So the code below replaces that. Once the ROM is patched this routine is no longer necessary.
-            ;    See https://github.com/commanderx16/x16-rom/issues/179
-            phx
-            lda  buffer
-            ldy  buffer+1
-            sta  P8ZP_SCRATCH_W1
-            sty  P8ZP_SCRATCH_W1+1
-            jsr  _pixels
-            plx
-            rts
-
-_pixels     lda  count+1
-            beq  +
-            ldx  #0
--           jsr  _loop
-            inc  P8ZP_SCRATCH_W1+1
-            dec  count+1
-            bne  -
-
-+           ldx  count
-_loop       ldy  #0
--           lda  (P8ZP_SCRATCH_W1),y
-            sta  cx16.VERA_DATA0
-            iny
-            dex
-            bne  -
-            rts
-        }}
+        sty  P8ZP_SCRATCH_B1
+        stz  cx16.VERA_CTRL
+        and  #1
+        sta  cx16.VERA_ADDR_H
+        lda  cx16.r0
+        sta  cx16.VERA_ADDR_L
+        lda  cx16.r0+1
+        sta  cx16.VERA_ADDR_M
+        txa
+        and  cx16.VERA_DATA0
+        ora  P8ZP_SCRATCH_B1
+        sta  cx16.VERA_DATA0
+        rts
+    }}
 }
 
 ; ---- system stuff -----
@@ -641,8 +638,9 @@ asmsub  init_system()  {
         lda  VERA_DC_VIDEO
         and  #%00000111 ; retain chroma + output mode
         sta  P8ZP_SCRATCH_REG
-        lda  #$80
-        sta  VERA_CTRL  ; reset vera
+        lda  #$0a
+        sta  $01        ; rom bank 10 (audio)
+        jsr  audio_init ; silence
         stz  $01        ; rom bank 0 (kernal)
         jsr  c64.IOINIT
         jsr  c64.RESTOR
@@ -650,7 +648,7 @@ asmsub  init_system()  {
         lda  VERA_DC_VIDEO
         and  #%11111000
         ora  P8ZP_SCRATCH_REG
-        sta  VERA_DC_VIDEO  ; keep old output mode
+        sta  VERA_DC_VIDEO  ; restore old output mode
         lda  #$90       ; black
         jsr  c64.CHROUT
         lda  #1
@@ -699,7 +697,7 @@ asmsub  set_irq(uword handler @AY, ubyte useKernal @Pc) clobbers(A)  {
 	        sta  _modified+1
 	        sty  _modified+2
 	        lda  #0
-	        adc  #0
+	        rol  a
 	        sta  _use_kernal
 		sei
 		lda  #<_irq_handler
@@ -729,8 +727,7 @@ _modified	jsr  $ffff                      ; modified
 _use_kernal     .byte  0
 
 _irq_handler_init
-		; save all zp scratch registers and the X register as these might be clobbered by the irq routine
-		stx  IRQ_X_REG
+		; 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
@@ -743,18 +740,15 @@ _irq_handler_init
 		sta  IRQ_SCRATCH_ZPWORD2
 		lda  P8ZP_SCRATCH_W2+1
 		sta  IRQ_SCRATCH_ZPWORD2+1
-		; stack protector; make sure we don't clobber the top of the evaluation stack
-		dex
-		dex
-		dex
-		dex
-		dex
-		dex
+		; Set X to the bottom 32 bytes of the evaluation stack, to HOPEFULLY not clobber it.
+		; This leaves 128-32=96 stack entries for the main program, and 32 stack entries for the IRQ handler.
+		; We assume IRQ handlers don't contain complex expressions taking up more than that.
+		ldx  #32
 		cld
 		rts
 
 _irq_handler_end
-		; restore all zp scratch registers and the X register
+		; restore all zp scratch registers
 		lda  IRQ_SCRATCH_ZPB1
 		sta  P8ZP_SCRATCH_B1
 		lda  IRQ_SCRATCH_ZPREG
@@ -767,10 +761,8 @@ _irq_handler_end
 		sta  P8ZP_SCRATCH_W2
 		lda  IRQ_SCRATCH_ZPWORD2+1
 		sta  P8ZP_SCRATCH_W2+1
-		ldx  IRQ_X_REG
 		rts
 
-IRQ_X_REG		.byte  0
 IRQ_SCRATCH_ZPB1	.byte  0
 IRQ_SCRATCH_ZPREG	.byte  0
 IRQ_SCRATCH_ZPWORD1	.word  0
@@ -779,7 +771,7 @@ IRQ_SCRATCH_ZPWORD2	.word  0
 		}}
 }
 
-asmsub push_vera_context() clobbers(A) {
+asmsub save_vera_context() clobbers(A) {
     ; -- use this at the start of your IRQ handler if it uses Vera registers, to save the state
     %asm {{
         ; note cannot store this on cpu hardware stack because this gets called as a subroutine
@@ -792,6 +784,7 @@ asmsub push_vera_context() clobbers(A) {
         lda  cx16.VERA_CTRL
         sta  _vera_storage+3
         eor  #1
+        sta  _vera_storage+7
         sta  cx16.VERA_CTRL
         lda  cx16.VERA_ADDR_L
         sta  _vera_storage+4
@@ -799,31 +792,29 @@ asmsub push_vera_context() clobbers(A) {
         sta  _vera_storage+5
         lda  cx16.VERA_ADDR_H
         sta  _vera_storage+6
-        lda  cx16.VERA_CTRL
-        sta  _vera_storage+7
         rts
 _vera_storage:  .byte 0,0,0,0,0,0,0,0
     }}
 }
 
-asmsub pop_vera_context() clobbers(A) {
+asmsub restore_vera_context() clobbers(A) {
     ; -- use this at the end of your IRQ handler if it uses Vera registers, to restore the state
     %asm {{
-        lda  cx16.push_vera_context._vera_storage+7
+        lda  cx16.save_vera_context._vera_storage+7
         sta  cx16.VERA_CTRL
-        lda  cx16.push_vera_context._vera_storage+6
+        lda  cx16.save_vera_context._vera_storage+6
         sta  cx16.VERA_ADDR_H
-        lda  cx16.push_vera_context._vera_storage+5
+        lda  cx16.save_vera_context._vera_storage+5
         sta  cx16.VERA_ADDR_M
-        lda  cx16.push_vera_context._vera_storage+4
+        lda  cx16.save_vera_context._vera_storage+4
         sta  cx16.VERA_ADDR_L
-        lda  cx16.push_vera_context._vera_storage+3
+        lda  cx16.save_vera_context._vera_storage+3
         sta  cx16.VERA_CTRL
-        lda  cx16.push_vera_context._vera_storage+2
+        lda  cx16.save_vera_context._vera_storage+2
         sta  cx16.VERA_ADDR_H
-        lda  cx16.push_vera_context._vera_storage+1
+        lda  cx16.save_vera_context._vera_storage+1
         sta  cx16.VERA_ADDR_M
-        lda  cx16.push_vera_context._vera_storage+0
+        lda  cx16.save_vera_context._vera_storage+0
         sta  cx16.VERA_ADDR_L
         rts
     }}
@@ -910,15 +901,27 @@ sys {
 
     asmsub reset_system() {
         ; Soft-reset the system back to initial power-on Basic prompt.
+        ; We do this via the SMC so that a true reset is performed that also resets the Vera fully.
         %asm {{
             sei
-            stz  $01                        ; bank the kernal in
-            lda  #$80
-            sta  cx16.VERA_CTRL             ; reset Vera (kernal doesn't do this?)
-            jmp  (cx16.RESET_VEC)
+            ldx #$42
+            ldy #1
+            tya
+            jsr  cx16.i2c_write_byte
+            bra  *
         }}
     }
 
+    sub poweroff_system() {
+        ; use the SMC to shutdown the computer
+        void cx16.i2c_write_byte($42, $01, $00)
+    }
+
+    sub set_leds_brightness(ubyte activity, ubyte power) {
+        void cx16.i2c_write_byte($42, $04, power)
+        void cx16.i2c_write_byte($42, $05, activity)
+    }
+
     asmsub wait(uword jiffies @AY) {
         ; --- wait approximately the given number of jiffies (1/60th seconds) (N or N+1)
         ;     note: the system irq handler has to be active for this to work as it depends on the system jiffy clock

compiler/res/prog8lib/prog8_lib.asm

@@ -997,6 +997,20 @@ _arg_s1		.word  0
 _arg_s2		.word  0
 		.pend
 
+strcmp_stack	.proc
+		; -- compare strings, both on stack.
+		;    Returns -1,0,1 in A, depeding on the ordering. Clobbers Y.
+		inx
+		lda  P8ESTACK_LO,x
+		ldy  P8ESTACK_HI,x
+		sta  P8ZP_SCRATCH_W2
+		sty  P8ZP_SCRATCH_W2+1
+		inx
+		lda  P8ESTACK_LO,x
+		ldy  P8ESTACK_HI,x
+		jmp  strcmp_mem
+		.pend
+
 
 strcmp_mem	.proc
 		; --   compares strings in s1 (AY) and s2 (P8ZP_SCRATCH_W2).

compiler/res/prog8lib/string.p8

@@ -292,7 +292,7 @@ str = P8ZP_SCRATCH_W1
 	sta  modify_pattern2+2
 	jsr  _match
 	lda  #0
-	adc  #0
+	rol  a
 	ldx  P8ZP_SCRATCH_REG
 	rts
 

compiler/res/prog8lib/virtual/conv.p8

@@ -196,9 +196,9 @@ sub  str2uword(str string) -> uword {
     ;    the number may NOT be preceded by a + sign and may NOT contain spaces
     ;    (any non-digit character will terminate the number string that is parsed)
     %ir {{
-        loadm.w r65500,conv.str2uword.string
-        syscall 11
-        return
+        loadm.w r65535,conv.str2uword.string
+        syscall 11 (r65535.w) : r0.w
+        returnr.w r0
     }}
 }
 
@@ -207,9 +207,9 @@ sub  str2word(str string) -> word {
     ;    the number may be preceded by a + or - sign but may NOT contain spaces
     ;    (any non-digit character will terminate the number string that is parsed)
     %ir {{
-        loadm.w r65500,conv.str2word.string
-        syscall 12
-        return
+        loadm.w r65535,conv.str2word.string
+        syscall 12 (r65535.w) : r0.w
+        returnr.w r0
     }}
 }
 

compiler/res/prog8lib/virtual/floats.p8

@@ -10,8 +10,8 @@ floats {
 sub print_f(float value) {
     ; ---- prints the floating point value (without a newline).
     %ir {{
-        loadm.f fr65500,floats.print_f.value
-        syscall 25
+        loadm.f fr65535,floats.print_f.value
+        syscall 25 (fr65535.f)
         return
     }}
 }
@@ -21,7 +21,7 @@ sub pow(float value, float power) -> float {
         loadm.f fr0,floats.pow.value
         loadm.f fr1,floats.pow.power
         fpow.f fr0,fr1
-        return
+        returnr.f fr0
     }}
 }
 
@@ -29,7 +29,7 @@ sub fabs(float value) -> float {
     %ir {{
         loadm.f fr0,floats.fabs.value
         fabs.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -37,7 +37,7 @@ sub sin(float angle) -> float {
     %ir {{
         loadm.f fr0,floats.sin.angle
         fsin.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -45,7 +45,7 @@ sub cos(float angle) -> float {
     %ir {{
         loadm.f fr0,floats.cos.angle
         fcos.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -53,7 +53,7 @@ sub tan(float value) -> float {
     %ir {{
         loadm.f fr0,floats.tan.value
         ftan.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -61,7 +61,7 @@ sub atan(float value) -> float {
     %ir {{
         loadm.f fr0,floats.atan.value
         fatan.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -69,7 +69,7 @@ sub ln(float value) -> float {
     %ir {{
         loadm.f fr0,floats.ln.value
         fln.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -77,7 +77,7 @@ sub log2(float value) -> float {
     %ir {{
         loadm.f fr0,floats.log2.value
         flog.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -85,7 +85,7 @@ sub sqrt(float value) -> float {
     %ir {{
         loadm.f fr0,floats.sqrt.value
         sqrt.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -103,7 +103,7 @@ sub round(float value) -> float {
     %ir {{
         loadm.f fr0,floats.round.value
         fround.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -111,7 +111,7 @@ sub floor(float value) -> float {
     %ir {{
         loadm.f fr0,floats.floor.value
         ffloor.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
@@ -120,21 +120,22 @@ sub ceil(float value) -> float {
     %ir {{
         loadm.f fr0,floats.ceil.value
         fceil.f fr0,fr0
-        return
+        returnr.f fr0
     }}
 }
 
 sub rndf() -> float {
     %ir {{
-        syscall 35
-        return
+        syscall 35 () : fr0.f
+        returnr.f fr0
     }}
 }
 
 sub rndseedf(float seed) {
     %ir {{
-        loadm.f  fr65500,floats.rndseedf.seed
-        syscall 32
+        loadm.f  fr65535,floats.rndseedf.seed
+        syscall 32 (fr65535.f)
+        return
     }}
 }
 

compiler/res/prog8lib/virtual/math.p8

@@ -161,24 +161,24 @@ math {
 
     sub rnd() -> ubyte {
         %ir {{
-            syscall 33
-            return
+            syscall 33 (): r0.b
+            returnr.b r0
         }}
     }
 
     sub rndw() -> uword {
         %ir {{
-            syscall 34
-            return
+            syscall 34 (): r0.w
+            returnr.w r0
         }}
     }
 
     sub rndseed(uword seed1, uword seed2) {
         ; -- reset the pseudo RNG's seed values. Defaults are: $a55a, $7653.
         %ir {{
-            loadm.w r65500,math.rndseed.seed1
-            loadm.w r65501,math.rndseed.seed2
-            syscall 31
+            loadm.w r65534,math.rndseed.seed1
+            loadm.w r65535,math.rndseed.seed2
+            syscall 31 (r65534.w, r65535.w)
             return
         }}
     }

compiler/res/prog8lib/virtual/string.p8

@@ -84,10 +84,10 @@ string {
         ; Note that you can also directly compare strings and string values with eachother using
         ; comparison operators ==, < etcetera (it will use strcmp for you under water automatically).
         %ir {{
-            loadm.w r65500,string.compare.st1
-            loadm.w r65501,string.compare.st2
-            syscall 29
-            return
+            loadm.w r65534,string.compare.st1
+            loadm.w r65535,string.compare.st2
+            syscall 29 (r65534.w, r65535.w) : r0.b
+            returnr.b r0
         }}
     }
 

compiler/res/prog8lib/virtual/syslib.p8

@@ -8,22 +8,22 @@ sys {
     sub  reset_system()  {
         ; Soft-reset the system back to initial power-on Basic prompt.
         %ir {{
-            syscall 0
+            syscall 0 ()
         }}
     }
 
     sub wait(uword jiffies) {
         ; --- wait approximately the given number of jiffies (1/60th seconds)
         %ir {{
-            loadm.w r65500,sys.wait.jiffies
-            syscall 13
+            loadm.w r65535,sys.wait.jiffies
+            syscall 13 (r65535.w)
         }}
     }
 
     sub waitvsync() {
         ; --- busy wait till the next vsync has occurred (approximately), without depending on custom irq handling.
         %ir {{
-            syscall 14
+            syscall 14()
         }}
     }
 
@@ -62,8 +62,8 @@ sys {
     sub exit(ubyte returnvalue) {
         ; -- immediately exit the program with a return code in the A register
         %ir {{
-            loadm.b r65500,sys.exit.returnvalue
-            syscall 1
+            loadm.b r65535,sys.exit.returnvalue
+            syscall 1 (r65535.b)
         }}
     }
 
@@ -82,33 +82,33 @@ sys {
 
     sub gfx_enable(ubyte mode) {
         %ir {{
-            loadm.b r65500,sys.gfx_enable.mode
-            syscall 8
+            loadm.b r65535,sys.gfx_enable.mode
+            syscall 8 (r65535.b)
         }}
     }
 
     sub gfx_clear(ubyte color) {
         %ir {{
-            loadm.b r65500,sys.gfx_clear.color
-            syscall 9
+            loadm.b r65535,sys.gfx_clear.color
+            syscall 9 (r65535.b)
         }}
     }
 
     sub gfx_plot(uword xx, uword yy, ubyte color) {
         %ir {{
-            loadm.w r65500,sys.gfx_plot.xx
-            loadm.w r65501,sys.gfx_plot.yy
-            loadm.b r65502,sys.gfx_plot.color
-            syscall 10
+            loadm.w r65533,sys.gfx_plot.xx
+            loadm.w r65534,sys.gfx_plot.yy
+            loadm.b r65535,sys.gfx_plot.color
+            syscall 10 (r65533.w, r65534.w, r65535.b)
         }}
     }
 
     sub gfx_getpixel(uword xx, uword yy) -> ubyte {
         %ir {{
-            loadm.w r65500,sys.gfx_getpixel.xx
-            loadm.w r65501,sys.gfx_getpixel.yy
-            syscall 30
-            return
+            loadm.w r65534,sys.gfx_getpixel.xx
+            loadm.w r65535,sys.gfx_getpixel.yy
+            syscall 30 (r65534.w, r65535.w): r0.b
+            returnr.b r0
         }}
     }
 }

compiler/res/prog8lib/virtual/textio.p8

@@ -4,11 +4,19 @@
 
 txt {
 
+sub width() -> ubyte {
+    return 80   ; just some chosen value for the 'width' of the console
+}
+
+sub height() -> ubyte {
+    return 30   ; just some chosen value for the 'height' of the console
+}
+
 sub  clear_screen() {
     str @shared sequence = "\x1b[2J\x1B[H"
     %ir {{
-        load.w r65500,txt.clear_screen.sequence
-        syscall 3
+        load.w r65535,txt.clear_screen.sequence
+        syscall 3 (r65535.w)
     }}
 }
 
@@ -30,15 +38,15 @@ sub uppercase() {
 
 sub chrout(ubyte char) {
     %ir {{
-        loadm.b r65500,txt.chrout.char
-        syscall 2
+        loadm.b r65535,txt.chrout.char
+        syscall 2 (r65535.b)
     }}
 }
 
 sub  print (str text) {
     %ir {{
-        loadm.w r65500,txt.print.text
-        syscall 3
+        loadm.w r65535,txt.print.text
+        syscall 3 (r65535.w)
     }}
 }
 
@@ -114,9 +122,10 @@ sub  input_chars  (uword buffer) -> ubyte  {
     ; ---- Input a string (max. 80 chars) from the keyboard. Returns length of input. (string is terminated with a 0 byte as well)
     ;      It assumes the keyboard is selected as I/O channel!
     %ir {{
-        loadm.w r65500,txt.input_chars.buffer
-        syscall 6
-        return
+        loadm.w r65534,txt.input_chars.buffer
+        load.b r65535,80
+        syscall 6 (r65534.w, r65535.b): r0.b
+        returnr.b r0
     }}
 }
 

compiler/res/version.txt

@@ -1 +1 @@
-8.10
+8.13

compiler/src/prog8/CompilerMain.kt

@@ -52,6 +52,7 @@ private fun compileMain(args: Array<String>): Boolean {
     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)")
     val varsHigh by cli.option(ArgType.Boolean, fullName = "varshigh", description = "put uninitialized variables in high memory area instead of at the end of the program")
+    val useNewExprCode by cli.option(ArgType.Boolean, fullName = "newexpr", description = "use new expression code-gen (experimental)")
     val moduleFiles by cli.argument(ArgType.String, fullName = "modules", description = "main module file(s) to compile").multiple(999)
 
     try {
@@ -126,6 +127,7 @@ private fun compileMain(args: Array<String>): Boolean {
                     asmListfile == true,
                     experimentalCodegen == true,
                     varsHigh == true,
+                    useNewExprCode == true,
                     compilationTarget,
                     evalStackAddr,
                     processedSymbols,
@@ -190,6 +192,7 @@ private fun compileMain(args: Array<String>): Boolean {
                     asmListfile == true,
                     experimentalCodegen == true,
                     varsHigh == true,
+                    useNewExprCode == true,
                     compilationTarget,
                     evalStackAddr,
                     processedSymbols,

compiler/src/prog8/compiler/Compiler.kt

@@ -4,11 +4,12 @@ import com.github.michaelbull.result.onFailure
 import prog8.ast.IBuiltinFunctions
 import prog8.ast.Program
 import prog8.ast.base.AstException
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.Directive
 import prog8.code.SymbolTableMaker
-import prog8.code.ast.PtProgram
+import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.code.target.*
 import prog8.codegen.vm.VmCodeGen
@@ -36,6 +37,7 @@ class CompilerArguments(val filepath: Path,
                         val asmListfile: Boolean,
                         val experimentalCodegen: Boolean,
                         val varsHigh: Boolean,
+                        val useNewExprCode: Boolean,
                         val compilationTarget: String,
                         val evalStackBaseAddress: UInt?,
                         val symbolDefs: Map<String, String>,
@@ -76,6 +78,7 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
                 asmListfile = args.asmListfile
                 experimentalCodegen = args.experimentalCodegen
                 varsHigh = args.varsHigh
+                useNewExprCode = args.useNewExprCode
                 evalStackBaseAddress = args.evalStackBaseAddress
                 outputDir = args.outputDir.normalize()
                 symbolDefs = args.symbolDefs
@@ -118,7 +121,7 @@ fun compileProgram(args: CompilerArguments): CompilationResult? {
 //                println("*********** COMPILER AST RIGHT BEFORE ASM GENERATION *************")
 //                printProgram(program)
 //                println("*********** AST RIGHT BEFORE ASM GENERATION *************")
-//                printAst(intermediateAst, ::println)
+//                printAst(intermediateAst, true, ::println)
 
                 if(!createAssemblyAndAssemble(intermediateAst, args.errors, compilationOptions)) {
                     System.err.println("Error in codegeneration or assembler")
@@ -255,8 +258,9 @@ fun parseMainModule(filepath: Path,
     for(lib in compTarget.machine.importLibs(compilerOptions, compTarget.name))
         importer.importImplicitLibraryModule(lib)
 
-    // always import prog8_lib and math
-    importer.importImplicitLibraryModule("math")
+    if(compilerOptions.compTarget.name!=VMTarget.NAME && !compilerOptions.experimentalCodegen) {
+        importer.importImplicitLibraryModule("math")
+    }
     importer.importImplicitLibraryModule("prog8_lib")
 
     if (compilerOptions.launcher == CbmPrgLauncherType.BASIC && compilerOptions.output != OutputType.PRG)
@@ -373,6 +377,9 @@ private fun optimizeAst(program: Program, compilerOptions: CompilationOptions, e
         if (optsDone1 + optsDone2 + optsDone3 + optsDone4 == 0)
             break
     }
+    val remover2 = UnusedCodeRemover(program, errors, compTarget)
+    remover2.visit(program)
+    remover2.applyModifications()
     errors.report()
 }
 
@@ -402,7 +409,18 @@ private fun createAssemblyAndAssemble(program: PtProgram,
     else if (compilerOptions.compTarget.name == VMTarget.NAME)
         VmCodeGen()
     else
-        throw NotImplementedError("no asm generator for cpu ${compilerOptions.compTarget.machine.cpu}")
+        throw NotImplementedError("no code generator for cpu ${compilerOptions.compTarget.machine.cpu}")
+
+    if(compilerOptions.useNewExprCode) {
+        if(compilerOptions.compTarget.machine.cpu !in arrayOf(CpuType.CPU6502, CpuType.CPU65c02)) {
+            // the IR code gen backend has its own, better, version of dealing with binary expressions.
+            throw IllegalArgumentException("'newexpr' expression rewrite should not be used with compilation target ${compilerOptions.compTarget.name}")
+        }
+
+        transformNewExpressions(program)
+    }
+
+    // printAst(program, true) { println(it) }
 
     val stMaker = SymbolTableMaker(program, compilerOptions)
     val symbolTable = stMaker.make()
@@ -410,8 +428,193 @@ private fun createAssemblyAndAssemble(program: PtProgram,
     errors.report()
 
     return if(assembly!=null && errors.noErrors()) {
-        assembly.assemble(compilerOptions)
+        assembly.assemble(compilerOptions, errors)
     } else {
         false
     }
 }
+
+private fun transformNewExpressions(program: PtProgram) {
+    val newVariables = mutableMapOf<PtSub, MutableList<PtVariable>>()
+    var countByteVars = 0
+    var countWordVars = 0
+    var countFloatVars = 0
+    // TODO: find a reliable way to reuse more temp vars across expressions
+
+    fun getExprVar(type: DataType, pos: Position, scope: PtSub): PtIdentifier {
+        val count = when(type) {
+            in ByteDatatypes -> {
+                countByteVars++
+                countByteVars
+            }
+            in WordDatatypes -> {
+                countWordVars++
+                countWordVars
+            }
+            DataType.FLOAT -> {
+                countFloatVars++
+                countFloatVars
+            }
+            else -> throw FatalAstException("weird dt")
+        }
+        val name = "p8p_exprvar_${count}_${type.toString().lowercase()}"
+        var subVars = newVariables[scope]
+        if(subVars==null) {
+            subVars = mutableListOf()
+            newVariables[scope] = subVars
+        }
+        if(subVars.all { it.name!=name }) {
+            subVars.add(PtVariable(name, type, ZeropageWish.DONTCARE, null, null, pos))
+        }
+        return PtIdentifier("${scope.scopedName}.$name", type, pos)
+    }
+
+    fun transformExpr(expr: PtBinaryExpression): Pair<PtExpression, List<IPtAssignment>> {
+        // depth first process the expression tree
+        val scope = expr.definingSub()!!
+        val assignments = mutableListOf<IPtAssignment>()
+
+        fun transformOperand(node: PtExpression): PtNode {
+            return when(node) {
+                is PtNumber, is PtIdentifier, is PtArray, is PtString, is PtMachineRegister -> node
+                is PtBinaryExpression -> {
+                    val (replacement, subAssigns) = transformExpr(node)
+                    assignments.addAll(subAssigns)
+                    replacement
+                }
+                else -> {
+                    val variable = getExprVar(node.type, node.position, scope)
+                    val assign = PtAssignment(node.position)
+                    val target = PtAssignTarget(variable.position)
+                    target.add(variable)
+                    assign.add(target)
+                    assign.add(node)
+                    assignments.add(assign)
+                    variable
+                }
+            }
+        }
+
+        val newLeft = transformOperand(expr.left)
+        val newRight = transformOperand(expr.right)
+
+        // process the binexpr
+
+        val resultVar =
+            if(expr.type == expr.left.type) {
+                getExprVar(expr.type, expr.position, scope)
+            } else {
+                if(expr.operator in ComparisonOperators && expr.type in ByteDatatypes) {
+                    // this is very common and should be dealth with correctly; byte==0, word>42
+                    val varType = if(expr.left.type in PassByReferenceDatatypes) DataType.UWORD else expr.left.type
+                    getExprVar(varType, expr.position, scope)
+                }
+                else if(expr.left.type in PassByReferenceDatatypes && expr.type==DataType.UBYTE) {
+                    // this is common and should be dealth with correctly; for instance "name"=="john"
+                    val varType = if (expr.left.type in PassByReferenceDatatypes) DataType.UWORD else expr.left.type
+                    getExprVar(varType, expr.position, scope)
+                } else if(expr.left.type equalsSize expr.type) {
+                    getExprVar(expr.type, expr.position, scope)
+                } else {
+                    TODO("expression type differs from left operand type! got ${expr.left.type} expected ${expr.type}   ${expr.position}")
+                }
+            }
+
+        if(resultVar.name!=(newLeft as? PtIdentifier)?.name) {
+            // resultvar = left
+            val assign1 = PtAssignment(newLeft.position)
+            val target1 = PtAssignTarget(resultVar.position)
+            target1.add(resultVar)
+            assign1.add(target1)
+            assign1.add(newLeft)
+            assignments.add(assign1)
+        }
+        // resultvar {oper}= right
+        val operator = if(expr.operator in ComparisonOperators) expr.operator else expr.operator+'='
+        val assign2 = PtAugmentedAssign(operator, newRight.position)
+        val target2 = PtAssignTarget(resultVar.position)
+        target2.add(resultVar.copy())
+        assign2.add(target2)
+        assign2.add(newRight)
+        assignments.add(assign2)
+        return Pair(resultVar, assignments)
+    }
+
+    fun isProperStatement(node: PtNode): Boolean {
+        return when(node) {
+            is PtAssignment -> true
+            is PtAugmentedAssign -> true
+            is PtBreakpoint -> true
+            is PtConditionalBranch -> true
+            is PtForLoop -> true
+            is PtIfElse -> true
+            is PtIncludeBinary -> true
+            is PtInlineAssembly -> true
+            is PtJump -> true
+            is PtAsmSub -> true
+            is PtLabel -> true
+            is PtSub -> true
+            is PtVariable -> true
+            is PtNop -> true
+            is PtPostIncrDecr -> true
+            is PtRepeatLoop -> true
+            is PtReturn -> true
+            is PtWhen -> true
+            is PtBuiltinFunctionCall -> node.void
+            is PtFunctionCall -> node.void
+            else -> false
+        }
+    }
+
+    fun transform(node: PtNode, parent: PtNode) {
+        if(node is PtBinaryExpression) {
+            node.children.toTypedArray().forEach {
+                transform(it, node)
+            }
+            val (rep, assignments) = transformExpr(node)
+            var replacement = rep
+            if(!(rep.type equalsSize node.type)) {
+                if(rep.type in NumericDatatypes && node.type in ByteDatatypes) {
+                    replacement = PtTypeCast(node.type, node.position)
+                    replacement.add(rep)
+                } else
+                    TODO("cast replacement type ${rep.type} -> ${node.type}")
+            }
+            var idx = parent.children.indexOf(node)
+            parent.children[idx] = replacement
+            replacement.parent = parent
+            // find the statement above which we should insert the assignments
+            var stmt = node
+            while(!isProperStatement(stmt))
+                stmt = stmt.parent
+            idx = stmt.parent.children.indexOf(stmt)
+            assignments.reversed().forEach {
+                stmt.parent.add(idx, it as PtNode)
+            }
+        } else {
+            node.children.toTypedArray().forEach { child -> transform(child, node) }
+        }
+    }
+
+    program.allBlocks().forEach { block ->
+        block.children.toTypedArray().forEach {
+            transform(it, block)
+        }
+    }
+
+    // add the new variables
+    newVariables.forEach { (sub, vars) ->
+        vars.forEach {
+            sub.add(0, it)
+        }
+    }
+
+    // extra check to see that all PtBinaryExpressions have been transformed
+    fun binExprCheck(node: PtNode) {
+        if(node is PtBinaryExpression)
+            throw IllegalArgumentException("still got binexpr $node ${node.position}")
+        node.children.forEach { binExprCheck(it) }
+    }
+    binExprCheck(program)
+}
+

compiler/src/prog8/compiler/ModuleImporter.kt

@@ -106,13 +106,18 @@ class ModuleImporter(private val program: Program,
         removeDirectivesFromImportedModule(importedModule)
 
         // modules can contain blocks with "merge" option.
-        // their content has to be merged into already existing block with the same name.
+        // 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.first { it.name==block.name}
-                existingBlock.statements.addAll(block.statements.filter { it !is Directive})
-                importedModule.statements.remove(block)
+                val existingBlock = program.allBlocks.firstOrNull { it.name==block.name && it !== block}
+                if(existingBlock!=null) {
+                    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)
+                }
             }
         }
 

compiler/src/prog8/compiler/astprocessing/AsmInstructionNamesReplacer.kt

@@ -87,7 +87,7 @@ class AsmInstructionNamesReplacer(
         return if(newName!=subroutine.name || changedParams.isNotEmpty()) {
             val newSub = Subroutine(newName, subroutine.parameters, subroutine.returntypes,
                 subroutine.asmParameterRegisters, subroutine.asmReturnvaluesRegisters, subroutine.asmClobbers, subroutine.asmAddress, subroutine.isAsmSubroutine,
-                subroutine.inline, subroutine.statements, subroutine.position)
+                subroutine.inline, false, subroutine.statements, subroutine.position)
             if(changedParams.isNotEmpty())
                 subsWithParamRefsToFix += newSub
             listOf(IAstModification.ReplaceNode(subroutine, newSub, parent))

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

@@ -60,15 +60,33 @@ internal class AstChecker(private val program: Program,
     }
 
     override fun visit(identifier: IdentifierReference) {
-        val target = identifier.targetVarDecl(program)
-        if(target != null && target.origin==VarDeclOrigin.SUBROUTINEPARAM) {
-            if(target.definingSubroutine!!.isAsmSubroutine) {
-                if(target.definingSubroutine!!.parameters.any { it.name == identifier.nameInSource.last() })
-                    errors.err("cannot refer to parameter of asmsub by name", identifier.position)
+        val stmt = identifier.targetStatement(program)
+        if(stmt==null)
+            errors.err("undefined symbol: ${identifier.nameInSource.joinToString(".")}", identifier.position)
+        else {
+            val target = stmt as? VarDecl
+            if (target != null && target.origin == VarDeclOrigin.SUBROUTINEPARAM) {
+                if (target.definingSubroutine!!.isAsmSubroutine) {
+                    if (target.definingSubroutine!!.parameters.any { it.name == identifier.nameInSource.last() })
+                        errors.err("cannot refer to parameter of asmsub by name", identifier.position)
+                }
             }
         }
     }
 
+    override fun visit(unrollLoop: UnrollLoop) {
+        if(unrollLoop.iterations<0 || unrollLoop.iterations>65535)
+            errors.err("invalid number of unrolls", unrollLoop.position)
+        unrollLoop.body.statements.forEach {
+            if(it !is InlineAssembly && it !is Assignment && it !is BuiltinFunctionCallStatement && it !is FunctionCallStatement && it !is PostIncrDecr)
+                errors.err("invalid statement in unroll loop", it.position)
+        }
+        if(unrollLoop.iterations * unrollLoop.body.statements.size > 256) {
+            errors.warn("large number of unrolls, potential code size issue", unrollLoop.position)
+        }
+        super.visit(unrollLoop)
+    }
+
     override fun visit(returnStmt: Return) {
         val expectedReturnValues = returnStmt.definingSubroutine?.returntypes ?: emptyList()
         if(expectedReturnValues.size>1) {
@@ -308,8 +326,6 @@ internal class AstChecker(private val program: Program,
             err("subroutines can only be defined in the scope of a block or within another subroutine")
 
         if(subroutine.isAsmSubroutine) {
-            if(compilerOptions.compTarget.name==VMTarget.NAME)
-                err("cannot use asmsub for vm target, use regular subs")
             if(subroutine.asmParameterRegisters.size != subroutine.parameters.size)
                 err("number of asm parameter registers is not the isSameAs as number of parameters")
             if(subroutine.asmReturnvaluesRegisters.size != subroutine.returntypes.size)
@@ -442,6 +458,13 @@ internal class AstChecker(private val program: Program,
         val iterations = repeatLoop.iterations?.constValue(program)
         if(iterations != null && iterations.number.toInt() > 65535)
             errors.err("repeat cannot go over 65535 iterations", iterations.position)
+
+        val ident = repeatLoop.iterations as? IdentifierReference
+        if(ident!=null) {
+            val targetVar = ident.targetVarDecl(program)
+            if(targetVar==null)
+                errors.err("invalid assignment value, maybe forgot '&' (address-of)", ident.position)
+        }
         super.visit(repeatLoop)
     }
 
@@ -626,8 +649,18 @@ internal class AstChecker(private val program: Program,
 
         val declValue = decl.value
         if(declValue!=null && decl.type==VarDeclType.VAR) {
-            if (declValue.inferType(program) isnot decl.datatype) {
-                err("initialisation value has incompatible type (${declValue.inferType(program)}) for the variable (${decl.datatype})")
+            val iDt = declValue.inferType(program)
+            if (iDt isnot decl.datatype) {
+                if(decl.datatype in ArrayDatatypes) {
+                    val eltDt = ArrayToElementTypes.getValue(decl.datatype)
+                    if(iDt isnot eltDt) {
+                        if(!(iDt.isBool && eltDt==DataType.UBYTE || iDt.istype(DataType.UBYTE) && eltDt==DataType.BOOL))
+                            err("initialisation value has incompatible type (${declValue.inferType(program)}) for the variable (${decl.datatype})")
+                    }
+                } else {
+                    if(!(iDt.isBool && decl.datatype==DataType.UBYTE || iDt.istype(DataType.UBYTE) && decl.datatype==DataType.BOOL))
+                        err("initialisation value has incompatible type (${declValue.inferType(program)}) for the variable (${decl.datatype})")
+                }
             }
         }
 
@@ -897,6 +930,14 @@ internal class AstChecker(private val program: Program,
                     errors.err("bitwise operator can only be used on integer operands", expr.right.position)
             }
             "in" -> throw FatalAstException("in expression should have been replaced by containmentcheck")
+            "<<", ">>" -> {
+                if(rightDt in WordDatatypes) {
+                    val shift = expr.right.constValue(program)?.number?.toInt()
+                    if(shift==null || shift > 255) {
+                        errors.err("shift by a word value not supported, max is a byte", expr.position)
+                    }
+                }
+            }
         }
 
         if(leftDt !in NumericDatatypes && leftDt != DataType.STR && leftDt != DataType.BOOL)
@@ -905,17 +946,23 @@ internal class AstChecker(private val program: Program,
             errors.err("right operand is not numeric or str", expr.right.position)
         if(leftDt!=rightDt) {
             if(leftDt==DataType.STR && rightDt in IntegerDatatypes && expr.operator=="*") {
-                // only exception allowed: str * constvalue
+                // exception allowed: str * constvalue
                 if(expr.right.constValue(program)==null)
                     errors.err("can only use string repeat with a constant number value", expr.left.position)
             } else if(leftDt==DataType.BOOL && rightDt in ByteDatatypes || leftDt in ByteDatatypes && rightDt==DataType.BOOL) {
                 // expression with one side BOOL other side (U)BYTE is allowed; bool==byte
+            } else if((expr.operator == "<<" || expr.operator == ">>") && (leftDt in WordDatatypes && rightDt in ByteDatatypes)) {
+                // exception allowed: shifting a word by a byte
             } else {
                 errors.err("left and right operands aren't the same type", expr.left.position)
             }
         }
 
-        if(expr.operator !in ComparisonOperators) {
+        if(expr.operator in ComparisonOperators) {
+            if(leftDt!=rightDt && !(leftDt in ByteDatatypes && rightDt in ByteDatatypes)) {
+                throw FatalAstException("got comparison with different operand types: $leftDt ${expr.operator} $rightDt  ${expr.position}")
+            }
+        } else  {
             if (leftDt == DataType.STR && rightDt == DataType.STR || leftDt in ArrayDatatypes && rightDt in ArrayDatatypes) {
                 // str+str  and  str*number have already been const evaluated before we get here.
                 errors.err("no computational or logical expressions with strings or arrays are possible", expr.position)
@@ -1095,6 +1142,22 @@ internal class AstChecker(private val program: Program,
                     }
                 }
             }
+            else if(funcName[0] == "divmod") {
+                if(functionCallStatement.args[2] !is IdentifierReference || functionCallStatement.args[3] !is IdentifierReference)
+                    errors.err("arguments 3 and 4 must be variables to receive the division and remainder", functionCallStatement.position)
+                if(functionCallStatement.args[2] is TypecastExpression || functionCallStatement.args[3] is TypecastExpression)
+                    errors.err("all arguments must be ubyte", functionCallStatement.position)
+                if(!functionCallStatement.args.all {it.inferType(program) istype DataType.UBYTE})
+                    errors.err("all arguments must be ubyte", functionCallStatement.position)
+            }
+            else if(funcName[0] == "divmodw") {
+                if(functionCallStatement.args[2] !is IdentifierReference || functionCallStatement.args[3] !is IdentifierReference)
+                    errors.err("arguments 3 and 4 must be variables to receive the division and remainder", functionCallStatement.position)
+                if(functionCallStatement.args[2] is TypecastExpression || functionCallStatement.args[3] is TypecastExpression)
+                    errors.err("all arguments must be uword", functionCallStatement.position)
+                if(!functionCallStatement.args.all {it.inferType(program) istype DataType.UWORD})
+                    errors.err("all arguments must be uword", functionCallStatement.position)
+            }
 
             if(funcName[0] in InplaceModifyingBuiltinFunctions) {
                 // in-place modification, can't be done on literals
@@ -1255,14 +1318,15 @@ internal class AstChecker(private val program: Program,
         val whenStmt = whenChoice.parent as When
         if(whenChoice.values!=null) {
             val conditionType = whenStmt.condition.inferType(program)
-            if(!conditionType.isKnown)
-                throw FatalAstException("can't determine when choice datatype $whenChoice")
             val constvalues = whenChoice.values!!.map { it.constValue(program) }
             for(constvalue 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)
-                    conditionType isnot constvalue.type -> errors.err("choice value datatype differs from condition value", whenChoice.position)
+                    conditionType isnot constvalue.type -> {
+                        if(conditionType.isKnown)
+                            errors.err("choice value datatype differs from condition value", whenChoice.position)
+                    }
                 }
             }
         } else {
@@ -1316,7 +1380,7 @@ internal class AstChecker(private val program: Program,
                 else
                     errors.err("cannot call that: ${target.nameInSource.joinToString(".")}", target.position)
             }
-            null -> errors.err("undefined function or subroutine: ${target.nameInSource.joinToString(".")}", target.position)
+            null -> errors.err("undefined symbol: ${target.nameInSource.joinToString(".")}", target.position)
             else -> errors.err("cannot call that: ${target.nameInSource.joinToString(".")}", target.position)
         }
         return null
@@ -1462,6 +1526,10 @@ internal class AstChecker(private val program: Program,
             DataType.BOOL -> {
                 return true
             }
+            in ArrayDatatypes -> {
+                val eltDt = ArrayToElementTypes.getValue(targetDt)
+                return checkValueTypeAndRange(eltDt, value)
+            }
             else -> return err("value of type ${value.type} not compatible with $targetDt")
         }
         return true

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

@@ -13,7 +13,9 @@ import prog8.code.core.IErrorReporter
 import prog8.code.core.Position
 import prog8.code.target.VMTarget
 
-
+/**
+ * This checks for naming conflicts, not for correct symbol references yet.
+ */
 internal class AstIdentifiersChecker(private val errors: IErrorReporter,
                                      private val program: Program,
                                      private val compTarget: ICompilationTarget

compiler/src/prog8/compiler/astprocessing/AstOnetimeTransforms.kt

@@ -30,7 +30,7 @@ internal class AstOnetimeTransforms(private val program: Program, private val op
     private fun replacePointerVarIndexWithMemreadOrMemwrite(arrayIndexedExpression: ArrayIndexedExpression, parent: Node): Iterable<IAstModification> {
         // note: The CodeDesugarer already does something similar, but that is meant ONLY to take
         //       into account the case where the index value is a word type.
-        //       The replacement here is to fix missing cases in the 6502 codegen.
+        //       The replacement here is to fix missing cases in the 6502 codegen. (VM codegen doesn't use this workaround)
         // TODO make the 6502 codegen better so this workaround can be removed
         val arrayVar = arrayIndexedExpression.arrayvar.targetVarDecl(program)
         if(arrayVar!=null && arrayVar.datatype == DataType.UWORD) {

compiler/src/prog8/compiler/astprocessing/BeforeAsmAstChanger.kt

@@ -36,6 +36,19 @@ internal class BeforeAsmAstChanger(val program: Program,
         return noModifications
     }
 
+    override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+        if(expr.operator in ComparisonOperators && expr.left.inferType(program) istype DataType.STR && expr.right.inferType(program) istype DataType.STR) {
+            // replace string comparison expressions with calls to string.compare()
+            val stringCompare = BuiltinFunctionCall(
+                IdentifierReference(listOf("prog8_lib_stringcompare"), expr.position),
+                mutableListOf(expr.left.copy(), expr.right.copy()), expr.position)
+            val zero = NumericLiteral.optimalInteger(0, expr.position)
+            val comparison = BinaryExpression(stringCompare, expr.operator, zero, expr.position)
+            return listOf(IAstModification.ReplaceNode(expr, comparison, parent))
+        }
+        return noModifications
+    }
+
     override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
         if (decl.type == VarDeclType.VAR && decl.value != null && decl.datatype in NumericDatatypes)
             throw InternalCompilerException("vardecls for variables, with initial numerical value, should have been rewritten as plain vardecl + assignment $decl")

compiler/src/prog8/compiler/astprocessing/BeforeAsmTypecastCleaner.kt

@@ -139,6 +139,10 @@ internal class BeforeAsmTypecastCleaner(val program: Program,
                     errors.warn("shift always results in 0", expr.position)
                 if(dt.istype(DataType.UWORD) && shifts.number>=16.0)
                     errors.warn("shift always results in 0", expr.position)
+                if(shifts.number<=255.0 && shifts.type in WordDatatypes) {
+                    val byteVal = NumericLiteral(DataType.UBYTE, shifts.number, shifts.position)
+                    return listOf(IAstModification.ReplaceNode(expr.right, byteVal, expr))
+                }
             }
         }
         return noModifications

compiler/src/prog8/compiler/astprocessing/BoolRemover.kt

@@ -65,7 +65,7 @@ internal class BoolRemover(val program: Program) : AstWalker() {
             }.toMutableList()
             val newSubroutine = Subroutine(subroutine.name, newParams, newReturnTypes,
                 subroutine.asmParameterRegisters, subroutine.asmReturnvaluesRegisters, subroutine.asmClobbers,
-                subroutine.asmAddress, subroutine.isAsmSubroutine, subroutine.inline, subroutine.statements,
+                subroutine.asmAddress, subroutine.isAsmSubroutine, subroutine.inline, false, subroutine.statements,
                 subroutine.position)
             return listOf(IAstModification.ReplaceNode(subroutine, newSubroutine, parent))
         }

compiler/src/prog8/compiler/astprocessing/CodeDesugarer.kt

@@ -79,7 +79,7 @@ if CONDITION==0
 while CONDITION { STUFF }
     ==>
 _whileloop:
-  if CONDITION==0 goto _after
+  if INVERTED-CONDITION goto _after
   STUFF
   goto _whileloop
 _after:
@@ -142,8 +142,8 @@ _after:
         val indexExpr = arrayIndexedExpression.indexer.indexExpr
         val indexerDt = indexExpr.inferType(program)
         if(indexerDt.isWords) {
-            val arrayVar = arrayIndexedExpression.arrayvar.targetVarDecl(program)!!
-            if(arrayVar.datatype==DataType.UWORD) {
+            val arrayVar = arrayIndexedExpression.arrayvar.targetVarDecl(program)
+            if(arrayVar!=null && arrayVar.datatype==DataType.UWORD) {
                 val add: Expression =
                     if(indexExpr.constValue(program)?.number==0.0)
                         arrayIndexedExpression.arrayvar.copy()

compiler/src/prog8/compiler/astprocessing/IntermediateAstMaker.kt

@@ -9,10 +9,7 @@ import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.code.ast.*
-import prog8.code.core.BuiltinFunctions
-import prog8.code.core.CompilationOptions
-import prog8.code.core.DataType
-import prog8.code.core.SourceCode
+import prog8.code.core.*
 import prog8.compiler.builtinFunctionReturnType
 import java.io.File
 import kotlin.io.path.Path
@@ -55,6 +52,7 @@ class IntermediateAstMaker(private val program: Program, private val options: Co
             is Label -> transform(statement)
             is PostIncrDecr -> transform(statement)
             is RepeatLoop -> transform(statement)
+            is UnrollLoop -> transform(statement)
             is Return -> transform(statement)
             is Subroutine -> {
                 if(statement.isAsmSubroutine)
@@ -94,14 +92,12 @@ class IntermediateAstMaker(private val program: Program, private val options: Co
             val srcExpr = srcAssign.value
             val (operator: String, augmentedValue: Expression?) = when(srcExpr) {
                 is BinaryExpression -> {
-                    if(srcExpr.operator=="==" || srcExpr.operator=="%") {
-                        // no special code possible for 'in-place comparison and result as boolean' or 'remainder'
-                        Pair("", null)
-                    }
-                    else if(srcExpr.left isSameAs srcAssign.target) {
-                        Pair(srcExpr.operator+'=', srcExpr.right)
+                    if(srcExpr.left isSameAs srcAssign.target) {
+                        val oper = if(srcExpr.operator in ComparisonOperators) srcExpr.operator else srcExpr.operator+'='
+                        Pair(oper, srcExpr.right)
                     } else if(srcExpr.right isSameAs srcAssign.target) {
-                        Pair(srcExpr.operator+'=', srcExpr.left)
+                        val oper = if(srcExpr.operator in ComparisonOperators) srcExpr.operator else srcExpr.operator+'='
+                        Pair(oper, srcExpr.left)
                     } else {
                         // either left or right is same as target, other combinations are not supported here
                         Pair("", null)
@@ -172,6 +168,7 @@ class IntermediateAstMaker(private val program: Program, private val options: Co
                     "align_word" -> alignment = PtBlock.BlockAlignment.WORD
                     "align_page" -> alignment = PtBlock.BlockAlignment.PAGE
                     "force_output" -> forceOutput=true
+                    "merge" -> { /* ignore this one */ }
                     else -> throw FatalAstException("weird directive option: ${arg.name}")
                 }
             }
@@ -325,6 +322,16 @@ class IntermediateAstMaker(private val program: Program, private val options: Co
         return repeat
     }
 
+    private fun transform(srcUnroll: UnrollLoop): PtNodeGroup {
+        val result = PtNodeGroup()
+        repeat(srcUnroll.iterations) {
+            srcUnroll.body.statements.forEach {
+                result.add(transformStatement(it))
+            }
+        }
+        return result
+    }
+
     private fun transform(srcNode: Return): PtReturn {
         val ret = PtReturn(srcNode.position)
         if(srcNode.value!=null)
@@ -349,9 +356,9 @@ class IntermediateAstMaker(private val program: Program, private val options: Co
             for (asm in srcSub.statements) {
                 asm as InlineAssembly
                 if(asm.isIR)
-                    combinedIrAsm += asm.assembly + "\n"
+                    combinedIrAsm += asm.assembly.trimEnd() + "\n"
                 else
-                    combinedTrueAsm += asm.assembly + "\n"
+                    combinedTrueAsm += asm.assembly.trimEnd() + "\n"
             }
 
             if(combinedTrueAsm.isNotEmpty()) {

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

@@ -110,9 +110,6 @@ internal class NotExpressionAndIfComparisonExprChanger(val program: Program, val
             return noModifications
 
         // Simplify the conditional expression, introduce simple assignments if required.
-        // This is REQUIRED for correct code generation on 6502 because evaluating certain expressions
-        // clobber the handful of temporary variables in the zeropage and leaving everything in one
-        // expression then results in invalid values being compared. VM Codegen doesn't suffer from this.
         // NOTE: sometimes this increases code size because additional stores/loads are generated for the
         //       intermediate variables. We assume these are optimized away from the resulting assembly code later.
         val simplify = simplifyConditionalExpression(binExpr)

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

@@ -23,9 +23,19 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
             val valueDt = declValue.inferType(program)
             if(valueDt isnot decl.datatype) {
 
-                // don't add a typecast on an array initializer value
-                if(valueDt.isInteger && decl.datatype in ArrayDatatypes)
-                    return noModifications
+                // don't add a typecast on an array initializer value, unless booleans
+                if(valueDt.isInteger && decl.datatype in ArrayDatatypes) {
+                    if(decl.datatype == DataType.ARRAY_BOOL) {
+                        val integer = declValue.constValue(program)?.number
+                        if(integer!=null) {
+                            val num = NumericLiteral(DataType.UBYTE, if(integer==0.0) 0.0 else 1.0, declValue.position)
+                            num.parent = decl
+                            decl.value = num
+                        }
+                    } else {
+                        return noModifications
+                    }
+                }
 
                 // don't add a typecast if the initializer value is inherently not assignable
                 if(valueDt isNotAssignableTo decl.datatype)
@@ -60,15 +70,15 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
                     if (parent is Assignment) {
                         if (parent.target.inferType(program).isWords) {
                             modifications += IAstModification.ReplaceNode(expr.left, leftConstAsWord, expr)
-                            if(rightDt.isBytes)
-                                modifications += IAstModification.ReplaceNode(expr.right, TypecastExpression(expr.right, leftConstAsWord.type, true, expr.right.position), expr)
+//                            if(rightDt.isBytes)
+//                                modifications += IAstModification.ReplaceNode(expr.right, TypecastExpression(expr.right, leftConstAsWord.type, true, expr.right.position), expr)
                         }
                     } else if (parent is TypecastExpression && parent.type == DataType.UWORD && parent.parent is Assignment) {
                         val assign = parent.parent as Assignment
                         if (assign.target.inferType(program).isWords) {
                             modifications += IAstModification.ReplaceNode(expr.left, leftConstAsWord, expr)
-                            if(rightDt.isBytes)
-                                modifications += IAstModification.ReplaceNode(expr.right, TypecastExpression(expr.right, leftConstAsWord.type, true, expr.right.position), expr)
+//                            if(rightDt.isBytes)
+//                                modifications += IAstModification.ReplaceNode(expr.right, TypecastExpression(expr.right, leftConstAsWord.type, true, expr.right.position), expr)
                         }
                     }
                     if(modifications.isNotEmpty())
@@ -140,16 +150,18 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
                 }
 
 
-                // determine common datatype and add typecast as required to make left and right equal types
-                val (commonDt, toFix) = BinaryExpression.commonDatatype(leftDt.getOr(DataType.UNDEFINED), rightDt.getOr(DataType.UNDEFINED), expr.left, expr.right)
-                if(toFix!=null) {
-                    val modifications = mutableListOf<IAstModification>()
-                    when {
-                        toFix===expr.left -> addTypecastOrCastedValueModification(modifications, expr.left, commonDt, expr)
-                        toFix===expr.right -> addTypecastOrCastedValueModification(modifications, expr.right, commonDt, expr)
-                        else -> throw FatalAstException("confused binary expression side")
+                if((expr.operator!="<<" && expr.operator!=">>") || !leftDt.isWords || !rightDt.isBytes) {
+                    // determine common datatype and add typecast as required to make left and right equal types
+                    val (commonDt, toFix) = BinaryExpression.commonDatatype(leftDt.getOr(DataType.UNDEFINED), rightDt.getOr(DataType.UNDEFINED), expr.left, expr.right)
+                    if(toFix!=null) {
+                        val modifications = mutableListOf<IAstModification>()
+                        when {
+                            toFix===expr.left -> addTypecastOrCastedValueModification(modifications, expr.left, commonDt, expr)
+                            toFix===expr.right -> addTypecastOrCastedValueModification(modifications, expr.right, commonDt, expr)
+                            else -> throw FatalAstException("confused binary expression side")
+                        }
+                        return modifications
                     }
-                    return modifications
                 }
             }
         }
@@ -375,6 +387,21 @@ class TypecastsAdder(val program: Program, val options: CompilationOptions, val
         return noModifications
     }
 
+    override fun after(whenChoice: WhenChoice, parent: Node): Iterable<IAstModification> {
+        if((parent as When).condition.inferType(program).isWords) {
+            val values = whenChoice.values
+            values?.toTypedArray()?.withIndex()?.forEach { (index, value) ->
+                val num = value.constValue(program)
+                if(num!=null && num.type in ByteDatatypes) {
+                    val wordNum = NumericLiteral(if(num.type==DataType.UBYTE) DataType.UWORD else DataType.WORD, num.number, num.position)
+                    wordNum.parent = num.parent
+                    values[index] = wordNum
+                }
+            }
+        }
+        return noModifications
+    }
+
     private fun addTypecastOrCastedValueModification(
         modifications: MutableList<IAstModification>,
         expressionToCast: Expression,

compiler/test/ProjectConfig.kt

@@ -3,7 +3,7 @@ package prog8tests
 import io.kotest.core.config.AbstractProjectConfig
 
 object ProjectConfig : AbstractProjectConfig() {
-    override val parallelism = 2 // max(2, Runtime.getRuntime().availableProcessors() / 2)
+    override val parallelism = kotlin.math.max(1, Runtime.getRuntime().availableProcessors() / 2)
     // override fun listeners() = listOf(SystemOutToNullListener)
 }
 

compiler/test/TestAstChecks.kt

@@ -96,4 +96,53 @@ class TestAstChecks: FunSpec({
             """
         compileText(C64Target(), false, text, writeAssembly = false) shouldNotBe null
     }
+
+    test("const is not allowed on arrays") {
+        val text = """
+            main {
+                sub start() {
+                    const ubyte[5] a = 5
+                    a[2]=42
+                }
+            }
+        """
+        val errors = ErrorReporterForTests(keepMessagesAfterReporting = true)
+        compileText(C64Target(), true, text, writeAssembly = true, errors=errors)
+        errors.errors.size shouldBe 1
+        errors.warnings.size shouldBe 0
+        errors.errors[0] shouldContain "const modifier can only be used"
+    }
+
+    test("array indexing is not allowed on a memory mapped variable") {
+        val text = """
+            main {
+                sub start() {
+                    &ubyte a = 10000
+                    uword z = 500
+                    a[4] = (z % 3) as ubyte
+                }
+            }
+        """
+        val errors = ErrorReporterForTests(keepMessagesAfterReporting = true)
+        compileText(C64Target(), true, text, writeAssembly = true, errors=errors)
+        errors.errors.size shouldBe 1
+        errors.warnings.size shouldBe 0
+        errors.errors[0] shouldContain "indexing requires"
+    }
+
+    test("array decl with expression as size can be initialized with a single value") {
+        val text = """
+            main {
+                sub start() {
+                    const ubyte n = 40
+                    const ubyte half = n / 2
+                    ubyte[half] @shared a = 5
+                }
+            }
+        """
+        val errors = ErrorReporterForTests(keepMessagesAfterReporting = true)
+        compileText(C64Target(), true, text, writeAssembly = true, errors=errors)  shouldNotBe null
+        errors.errors.size shouldBe 0
+        errors.warnings.size shouldBe 0
+    }
 })

compiler/test/TestCompilerOnExamples.kt

@@ -33,6 +33,7 @@ private fun compileTheThing(filepath: Path, optimize: Boolean, target: ICompilat
         asmListfile = false,
         experimentalCodegen = false,
         varsHigh = false,
+        useNewExprCode = false,
         compilationTarget = target.name,
         evalStackBaseAddress = null,
         symbolDefs = emptyMap(),

compiler/test/TestCompilerOptionLibdirs.kt

@@ -50,6 +50,7 @@ class TestCompilerOptionSourcedirs: FunSpec({
             asmListfile = false,
             experimentalCodegen = false,
             varsHigh = false,
+            useNewExprCode = false,
             compilationTarget = Cx16Target.NAME,
             evalStackBaseAddress = null,
             symbolDefs = emptyMap(),

compiler/test/TestLaunchEmu.kt

@@ -33,7 +33,7 @@ class TestLaunchEmu: FunSpec({
 <INITGLOBALS>
 </INITGLOBALS>
 
-<BLOCK NAME="main" ADDRESS="null" ALIGN="NONE" POS="[unittest: line 42 col 1-9]">
+<BLOCK NAME="main" ADDRESS="" LIBRARY="false" FORCEOUTPUT="false" ALIGN="NONE" POS="[unittest: line 42 col 1-9]">
 </BLOCK>
 </PROGRAM>
 """)