sponsorship link.

error sorting.
version.

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+#github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+#patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: irmen
+#tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+#community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+#liberapay: # Replace with a single Liberapay username
+#issuehunt: # Replace with a single IssueHunt username
+#otechie: # Replace with a single Otechie username
+#lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+#custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/all-ci.yml

@@ -10,13 +10,18 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
-      - name: Install 64tass
-        run: sudo apt-get update -y && sudo apt-get install -y 64tass
+      - name: build and install recent 64tass
+        run: |
+          sudo apt-get install -y make build-essential
+          git clone --depth=1 https://github.com/irmen/64tass
+          cd 64tass
+          make -j4
+          sudo make install
 
       - name: Set up JDK 11
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           java-version: 11
           distribution: adopt

.gitignore

@@ -15,6 +15,7 @@ out/
 parser/**/*.interp
 parser/**/*.tokens
 parser/**/*.java
+compiler/src/prog8/buildversion/*
 *.py[cod]
 *.egg
 *.egg-info
@@ -29,6 +30,8 @@ parsetab.py
 compiler/lib/
 
 .gradle
+**/BuildVersion.kt
 /prog8compiler.jar
 sd*.img
 *.d64
+

.idea/kotlinc.xml

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

.idea/libraries/KotlinJavaRuntime.xml

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

.idea/libraries/antlr_antlr4.xml

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

.idea/libraries/io_kotest_assertions_core_jvm.xml

@@ -1,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.5.5" />
+    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.8.0" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.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.5.5/kotest-assertions-shared-jvm-5.5.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.8.0/kotest-assertions-core-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.8.10/kotlin-stdlib-jdk8-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.8.10/kotlin-stdlib-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.8.10/kotlin-stdlib-jdk7-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.8.0/kotest-assertions-shared-jvm-5.8.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/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$/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!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.8.10/kotlin-stdlib-common-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.7.0/kotlinx-coroutines-jdk8-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.8.10/kotlin-reflect-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.8.0/kotest-common-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.8.0/kotest-assertions-api-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.7.0/kotlinx-coroutines-core-jvm-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/23.0.0/annotations-23.0.0.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/io_kotest_property_jvm.xml

@@ -1,24 +0,0 @@
-<component name="libraryTable">
-  <library name="io.kotest.property.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-property-jvm:5.5.5" />
-    <CLASSES>
-      <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$/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.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 />
-  </library>
-</component>

.idea/libraries/io_kotest_runner_junit5_jvm.xml

@@ -1,55 +1,42 @@
 <component name="libraryTable">
   <library name="io.kotest.runner.junit5.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.5.5" />
+    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.8.0" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.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/kotest/kotest-runner-junit5-jvm/5.8.0/kotest-runner-junit5-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.8.0/kotest-framework-api-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.8.0/kotest-assertions-shared-jvm-5.8.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/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$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.7.0/kotlinx-coroutines-test-jvm-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.8.0/kotest-common-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.8.0/kotest-framework-engine-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.162/classgraph-4.8.162.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/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.4/kotlinx-coroutines-debug-1.6.4.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.7.0/kotlinx-coroutines-debug-1.7.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna/5.9.0/jna-5.9.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna-platform/5.9.0/jna-platform-5.9.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.10.9/byte-buddy-1.10.9.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.10.9/byte-buddy-agent-1.10.9.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.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$/io/kotest/kotest-framework-discovery-jvm/5.8.0/kotest-framework-discovery-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.8.0/kotest-assertions-core-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.7.0/kotlinx-coroutines-jdk8-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.8.0/kotest-assertions-api-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.8.0/kotest-extensions-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.8.0/kotest-framework-concurrency-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.7.0/kotlinx-coroutines-core-jvm-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/23.0.0/annotations-23.0.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.8.2/junit-platform-engine-1.8.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.8.2/junit-platform-commons-1.8.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-suite-api/1.8.2/junit-platform-suite-api-1.8.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-launcher/1.8.2/junit-platform-launcher-1.8.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.2/junit-jupiter-api-5.8.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.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$/org/jetbrains/kotlin/kotlin-reflect/1.6.21/kotlin-reflect-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.8.10/kotlin-stdlib-jdk8-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.8.10/kotlin-stdlib-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.8.10/kotlin-stdlib-jdk7-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.8.10/kotlin-stdlib-common-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.8.10/kotlin-reflect-1.8.10.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/jetbrains_kotlinx_cli_jvm.xml

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

.idea/libraries/michael_bull_kotlin_result_jvm.xml

@@ -1,13 +1,13 @@
 <component name="libraryTable">
   <library name="michael.bull.kotlin.result.jvm" type="repository">
-    <properties maven-id="com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16" />
+    <properties maven-id="com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/1.1.16/kotlin-result-jvm-1.1.16.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.20/kotlin-stdlib-common-1.6.20.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.20/kotlin-stdlib-jdk8-1.6.20.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.20/kotlin-stdlib-1.6.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/1.1.18/kotlin-result-jvm-1.1.18.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.8.10/kotlin-stdlib-jdk8-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.8.10/kotlin-stdlib-1.8.10.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.20/kotlin-stdlib-jdk7-1.6.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.8.10/kotlin-stdlib-jdk7-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.8.10/kotlin-stdlib-common-1.8.10.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/slf4j_simple.xml

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

.idea/misc.xml

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

README.md

@@ -1,3 +1,4 @@
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/H2H6S0FFF)
 [![Documentation](https://readthedocs.org/projects/prog8/badge/?version=latest)](https://prog8.readthedocs.io/)
 
 Prog8 - Structured Programming Language for 8-bit 6502/65c02 microprocessors
@@ -9,11 +10,33 @@ This is a structured programming language for the 8-bit 6502/6510/65c02 micropro
 as used in many home computers from that era. It is a medium to low level programming language,
 which aims to provide many conveniences over raw assembly code (even when using a macro assembler).
 
+**Want to buy me a coffee or a pizza perhaps?**
+
+This project was created over the last couple of years by dedicating thousands of hours of my free time to it, to make it the best I possibly can.
+If you like Prog8, and think it's worth a nice cup of hot coffee or a delicious pizza, 
+you can help me out a little bit over at [ko-fi.com/irmen](https://ko-fi.com/irmen). 
+
+
 Documentation
 -------------
 Full documentation (syntax reference, how to use the language and the compiler, etc.) can be found at:
 https://prog8.readthedocs.io/
 
+How to get it/build it
+----------------------
+
+- Download the latest [official release](https://github.com/irmen/prog8/releases) from github.
+- Or, if you want/need a bleeding edge development version, you can:
+  - download a build artifact zipfile from a recent [github action build](https://github.com/irmen/prog8/actions).
+  - you can also compile it yourself from source. [Instructions here](https://prog8.readthedocs.io/en/latest/compiling.html).
+
+Community
+---------
+Most of the development on Prog8 and the use of it is currently centered around 
+the [Commander X16](https://www.commanderx16.com/) retro computer. Their [discord server](https://discord.gg/nS2PqEC) contains a small channel
+dedicated to Prog8. Other than that, use the issue tracker on github.
+
+
 Software license
 ----------------
 GNU GPL 3.0 (see file LICENSE), with exception for generated code:
@@ -59,6 +82,8 @@ What does Prog8 provide?
 - "c64": Commodore-64  (6502 like CPU)
 - "c128": Commodore-128  (6502 like CPU - the Z80 cpu mode is not supported)
 - "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU)
+- "pet32": Commodore PET (experimental)
+- "atari": Atari 8 bit such as 800XL (experimental)
 - If you only use standard kernal and prog8 library routines, it is possible to compile the *exact same program* for different machines (just change the compiler target flag)
 
 

codeCore/build.gradle

@@ -26,16 +26,16 @@ compileTestKotlin {
 dependencies {
     // should have no dependencies to other modules
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
 }
 
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
 }

codeCore/src/prog8/code/SymbolTable.kt

@@ -80,6 +80,16 @@ class SymbolTable(astProgram: PtProgram) : StNode(astProgram.name, StNodeType.GL
     }
 
     override fun lookup(scopedName: String) = flat[scopedName]
+
+    fun getLength(name: String): Int? {
+        val node = flat[name]
+        return when(node) {
+            is StMemVar -> node.length
+            is StMemorySlab -> node.size.toInt()
+            is StStaticVariable -> node.length
+            else -> null
+        }
+    }
 }
 
 
@@ -186,13 +196,10 @@ class StStaticVariable(name: String,
         }
         if(onetimeInitializationNumericValue!=null) {
             require(dt in NumericDatatypes)
-            require(onetimeInitializationNumericValue!=0.0) { "zero as init value should just remain uninitialized"}
         }
         if(onetimeInitializationArrayValue!=null) {
             require(dt in ArrayDatatypes)
-            if(onetimeInitializationArrayValue.all { it.number!=null} ) {
-                require(onetimeInitializationArrayValue.any { it.number != 0.0 }) { "array of all zerors as init value should just remain uninitialized" }
-            }
+            require(length==onetimeInitializationArrayValue.size)
         }
         if(onetimeInitializationStringValue!=null) {
             require(dt == DataType.STR)
@@ -203,8 +210,7 @@ class StStaticVariable(name: String,
 
 
 class StConstant(name: String, val dt: DataType, val value: Double, astNode: PtNode) :
-    StNode(name, StNodeType.CONSTANT, astNode) {
-}
+    StNode(name, StNodeType.CONSTANT, astNode)
 
 
 class StMemVar(name: String,
@@ -226,12 +232,11 @@ class StMemorySlab(
     val align: UInt,
     astNode: PtNode
 ):
-    StNode(name, StNodeType.MEMORYSLAB, astNode) {
-}
+    StNode(name, StNodeType.MEMORYSLAB, astNode)
+
 
 class StSub(name: String, val parameters: List<StSubroutineParameter>, val returnType: DataType?, astNode: PtNode) :
-        StNode(name, StNodeType.SUBROUTINE, astNode) {
-}
+        StNode(name, StNodeType.SUBROUTINE, astNode)
 
 
 class StRomSub(name: String,

codeCore/src/prog8/code/SymbolTableMaker.kt

@@ -26,8 +26,6 @@ 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, 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, it.arraySize?.toInt(), it))
@@ -76,10 +74,9 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
                             numElements = value.value.length + 1   // include the terminating 0-byte
                         }
                         is PtArray -> {
-                            val array = makeInitialArray(value)
-                            initialArray = if(array.all { it.number==0.0 }) null else array            // all 0 as init value -> just uninitialized
+                            initialArray = makeInitialArray(value)
                             initialString = null
-                            numElements = array.size
+                            numElements = initialArray.size
                             require(node.arraySize?.toInt()==numElements)
                         }
                         else -> {
@@ -94,6 +91,9 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
                     initialString = null
                     numElements = node.arraySize?.toInt()
                 }
+//                if(node.type in SplitWordArrayTypes) {
+//                    ... split array also add _lsb and _msb to symboltable?
+//                }
                 StStaticVariable(node.name, node.type, initialNumeric, initialString, initialArray, numElements, node.zeropage, node)
             }
             is PtBuiltinFunctionCall -> {
@@ -125,7 +125,11 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
     private fun makeInitialArray(value: PtArray): List<StArrayElement> {
         return value.children.map {
             when(it) {
-                is PtAddressOf -> StArrayElement(null, it.identifier.name)
+                is PtAddressOf -> {
+                    if(it.isFromArrayElement)
+                        TODO("address-of array element $it in initial array value")
+                    StArrayElement(null, it.identifier.name)
+                }
                 is PtIdentifier -> StArrayElement(null, it.name)
                 is PtNumber -> StArrayElement(it.number, null)
                 else -> throw AssemblyError("invalid array element $it")
@@ -170,7 +174,7 @@ class SymbolTableMaker(private val program: PtProgram, private val options: Comp
 //                }
 //                VarDeclType.MEMORY -> {
 //                    val numElements =
-//                        if(decl.datatype in ArrayDatatypes)
+//                        if(decl.isArray)
 //                            decl.arraysize!!.constIndex()
 //                        else null
 //                    val astNode = PtVariable(decl.name, decl.datatype, null, null, decl.position)

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

@@ -31,15 +31,19 @@ sealed class PtNode(val position: Position) {
 }
 
 
-class PtNodeGroup : PtNode(Position.DUMMY)
+sealed interface IPtStatementContainer
+
+
+class PtNodeGroup : PtNode(Position.DUMMY), IPtStatementContainer
 
 
 sealed class PtNamedNode(var name: String, position: Position): PtNode(position) {
     // Note that as an exception, the 'name' is not read-only
     // but a var. This is to allow for cheap node renames.
-    val scopedName: String by lazy {
+    val scopedName: String
+        get() {
             var namedParent: PtNode = this.parent
-        if(namedParent is PtProgram)
+            return if(namedParent is PtProgram)
                 name
             else {
                 while (namedParent !is PtNamedNode)
@@ -63,23 +67,30 @@ class PtProgram(
         children.asSequence().filterIsInstance<PtBlock>()
 
     fun entrypoint(): PtSub? =
-        allBlocks().firstOrNull { it.name == "main" }?.children?.firstOrNull { it is PtSub && (it.name == "start" || it.name=="main.start") } as PtSub?
+        allBlocks().firstOrNull { it.name == "main" || it.name=="p8b_main" }
+            ?.children
+            ?.firstOrNull { it is PtSub && (it.name == "start" || it.name=="main.start" || it.name=="p8s_start" || it.name=="p8b_main.p8s_start") } as PtSub?
 }
 
 
 class PtBlock(name: String,
-              val address: UInt?,
               val library: Boolean,
-              val forceOutput: Boolean,
-              val alignment: BlockAlignment,
               val source: SourceCode,       // taken from the module the block is defined in.
+              val options: Options,
               position: Position
-) : PtNamedNode(name, position) {
+) : PtNamedNode(name, position), IPtStatementContainer {
     enum class BlockAlignment {
         NONE,
         WORD,
         PAGE
     }
+
+    class Options(val address: UInt? = null,
+                  val forceOutput: Boolean = false,
+                  val noSymbolPrefixing: Boolean = false,
+                  val veraFxMuls: Boolean = false,
+                  val ignoreUnused: Boolean = false,
+                  val alignment: BlockAlignment = BlockAlignment.NONE)
 }
 
 

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

@@ -1,12 +1,9 @@
 package prog8.code.ast
 
-import prog8.code.core.DataType
-import prog8.code.core.Encoding
-import prog8.code.core.NumericDatatypes
-import prog8.code.core.Position
+import prog8.code.core.*
 import java.util.*
 import kotlin.math.abs
-import kotlin.math.round
+import kotlin.math.truncate
 
 
 sealed class PtExpression(val type: DataType, position: Position) : PtNode(position) {
@@ -27,9 +24,26 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
 
     infix fun isSameAs(other: PtExpression): Boolean {
         return when(this) {
-            is PtAddressOf -> other is PtAddressOf && other.type==type && other.identifier isSameAs identifier
-            is PtArrayIndexer -> other is PtArrayIndexer && other.type==type && other.variable isSameAs variable && other.index isSameAs index
-            is PtBinaryExpression -> other is PtBinaryExpression && other.left isSameAs left && other.right isSameAs right
+            is PtAddressOf -> {
+                if(other !is PtAddressOf)
+                    return false
+                if (other.type!==type || !(other.identifier isSameAs identifier))
+                    return false
+                if(other.children.size!=children.size)
+                    return false
+                if(children.size==1)
+                    return true
+                return arrayIndexExpr!! isSameAs other.arrayIndexExpr!!
+            }
+            is PtArrayIndexer -> other is PtArrayIndexer && other.type==type && other.variable isSameAs variable && other.index isSameAs index && other.splitWords==splitWords
+            is PtBinaryExpression -> {
+                if(other !is PtBinaryExpression || other.operator!=operator)
+                    false
+                else if(operator in AssociativeOperators)
+                    (other.left isSameAs left && other.right isSameAs right) || (other.left isSameAs right && other.right isSameAs left)
+                else
+                    other.left isSameAs left && other.right isSameAs right
+            }
             is PtContainmentCheck -> other is PtContainmentCheck && other.type==type && other.element isSameAs element && other.iterable isSameAs iterable
             is PtIdentifier -> other is PtIdentifier && other.type==type && other.name==name
             is PtMachineRegister -> other is PtMachineRegister && other.type==type && other.register==register
@@ -51,7 +65,7 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
                 this.name == target.identifier!!.name
             }
             target.array != null && this is PtArrayIndexer -> {
-                this.variable.name == target.array!!.variable.name && this.index isSameAs target.array!!.index
+                this.variable.name == target.array!!.variable.name && this.index isSameAs target.array!!.index && this.splitWords==target.array!!.splitWords
             }
             else -> false
         }
@@ -65,7 +79,12 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
             is PtArray -> true
             is PtArrayIndexer -> index is PtNumber || index is PtIdentifier
             is PtBinaryExpression -> false
-            is PtBuiltinFunctionCall -> name in arrayOf("msb", "lsb", "peek", "peekw", "mkword", "set_carry", "set_irqd", "clear_carry", "clear_irqd")
+            is PtBuiltinFunctionCall -> {
+                when (name) {
+                    in arrayOf("msb", "lsb", "mkword", "set_carry", "set_irqd", "clear_carry", "clear_irqd") -> this.args.all { it.isSimple() }
+                    else -> false
+                }
+            }
             is PtContainmentCheck -> false
             is PtFunctionCall -> false
             is PtIdentifier -> true
@@ -108,7 +127,12 @@ sealed class PtExpression(val type: DataType, position: Position) : PtNode(posit
 
 class PtAddressOf(position: Position) : PtExpression(DataType.UWORD, position) {
     val identifier: PtIdentifier
-        get() = children.single() as PtIdentifier
+        get() = children[0] as PtIdentifier
+    val arrayIndexExpr: PtExpression?
+        get() = if(children.size==2) children[1] as PtExpression else null
+
+    val isFromArrayElement: Boolean
+        get() = children.size==2
 }
 
 
@@ -118,6 +142,12 @@ class PtArrayIndexer(elementType: DataType, position: Position): PtExpression(el
     val index: PtExpression
         get() = children[1] as PtExpression
 
+    val splitWords: Boolean
+        get() = variable.type in SplitWordArrayTypes
+
+    val usesPointerVariable: Boolean
+        get() = variable.type==DataType.UWORD
+
     init {
         require(elementType in NumericDatatypes)
     }
@@ -209,9 +239,9 @@ class PtNumber(type: DataType, val number: Double, position: Position) : PtExpre
         if(type==DataType.BOOL)
             throw IllegalArgumentException("bool should have become ubyte @$position")
         if(type!=DataType.FLOAT) {
-            val rounded = round(number)
-            if (rounded != number)
-                throw IllegalArgumentException("refused rounding of float to avoid loss of precision @$position")
+            val trunc = truncate(number)
+            if (trunc != number)
+                throw IllegalArgumentException("refused truncating of float to avoid loss of precision @$position")
         }
     }
 

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

@@ -17,7 +17,7 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
             is PtConditionalBranch -> "if_${node.condition.name.lowercase()}"
             is PtAddressOf -> "&"
             is PtArray -> "array len=${node.children.size} ${type(node.type)}"
-            is PtArrayIndexer -> "<arrayindexer> ${type(node.type)}"
+            is PtArrayIndexer -> "<arrayindexer> ${type(node.type)} ${if(node.splitWords) "[splitwords]" else ""}"
             is PtBinaryExpression -> "<expr> ${node.operator} ${type(node.type)}"
             is PtBuiltinFunctionCall -> {
                 val str = if(node.void) "void " else ""
@@ -53,15 +53,24 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                     "goto ${node.identifier.name}"
                 else if(node.address!=null)
                     "goto ${node.address.toHex()}"
-                else if(node.generatedLabel!=null)
-                    "goto ${node.generatedLabel}"
                 else
                     "???"
             }
             is PtAsmSub -> {
-                val params = if (node.parameters.isEmpty()) "" else "...TODO ${node.parameters.size} PARAMS..."
+                val params = node.parameters.map {
+                                val register = it.first.registerOrPair
+                                val statusflag = it.first.statusflag
+                                "${it.second.type} ${it.second.name} @${register ?: statusflag}"
+                            }.joinToString(", ")
                 val clobbers = if (node.clobbers.isEmpty()) "" else "clobbers ${node.clobbers}"
-                val returns = if (node.returns.isEmpty()) "" else (if (node.returns.size == 1) "-> ${node.returns[0].second.name.lowercase()}" else "-> ${node.returns.map { it.second.name.lowercase() }}")
+                val returns = if (node.returns.isEmpty()) "" else {
+                    "-> ${node.returns.map {
+                        val register = it.first.registerOrPair
+                        val statusflag = it.first.statusflag
+                        "${it.second} @${register ?: statusflag}"}
+                        .joinToString(", ")
+                    }"
+                }
                 val str = if (node.inline) "inline " else ""
                 if(node.address==null) {
                     str + "asmsub ${node.name}($params) $clobbers $returns"
@@ -70,8 +79,8 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                 }
             }
             is PtBlock -> {
-                val addr = if(node.address==null) "" else "@${node.address.toHex()}"
-                val align = if(node.alignment==PtBlock.BlockAlignment.NONE) "" else "align=${node.alignment}"
+                val addr = if(node.options.address==null) "" else "@${node.options.address.toHex()}"
+                val align = if(node.options.alignment==PtBlock.BlockAlignment.NONE) "" else "align=${node.options.alignment}"
                 "\nblock '${node.name}' $addr $align"
             }
             is PtConstant -> {
@@ -89,20 +98,21 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                 }
             }
             is PtSub -> {
-                val params = if (node.parameters.isEmpty()) "" else "...TODO ${node.parameters.size} PARAMS..."
+                val params = node.parameters.map { "${it.type} ${it.name}" }.joinToString(", ")
                 var str = "sub ${node.name}($params) "
                 if(node.returntype!=null)
                     str += "-> ${node.returntype.name.lowercase()}"
                 str
             }
             is PtVariable -> {
+                val split = if(node.type in SplitWordArrayTypes) "@split" else ""
                 val str = if(node.arraySize!=null) {
                     val eltType = ArrayToElementTypes.getValue(node.type)
-                    "${eltType.name.lowercase()}[${node.arraySize}] ${node.name}"
+                    "${eltType.name.lowercase()}[${node.arraySize}] $split ${node.name}"
                 }
                 else if(node.type in ArrayDatatypes) {
                     val eltType = ArrayToElementTypes.getValue(node.type)
-                    "${eltType.name.lowercase()}[] ${node.name}"
+                    "${eltType.name.lowercase()}[] $split ${node.name}"
                 }
                 else
                     "${node.type.name.lowercase()} ${node.name}"
@@ -125,7 +135,6 @@ fun printAst(root: PtNode, skipLibraries: Boolean, output: (text: String) -> Uni
                 else
                     "->"
             }
-            else -> throw InternalCompilerException("unrecognised ast node $node")
         }
     }
 

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

@@ -23,7 +23,7 @@ class PtSub(
     val parameters: List<PtSubroutineParameter>,
     val returntype: DataType?,
     position: Position
-) : PtNamedNode(name, position), IPtSubroutine {
+) : PtNamedNode(name, position), IPtSubroutine, IPtStatementContainer {
     init {
         // params and return value should not be str
         if(parameters.any{ it.type !in NumericDatatypes })
@@ -101,9 +101,8 @@ class PtIfElse(position: Position) : PtNode(position) {
 }
 
 
-class PtJump(val identifier: PtIdentifier?,
+class PtJump(val identifier: PtIdentifier?,     // note: even ad-hoc labels are wrapped as an Identifier to simplify code. Just use dummy type and position.
              val address: UInt?,
-             val generatedLabel: String?,
              position: Position) : PtNode(position) {
     init {
         identifier?.let {it.parent = this }

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

@@ -68,9 +68,10 @@ class FSignature(val pure: Boolean,      // does it have side effects?
     }
 }
 
-
 val BuiltinFunctions: Map<String, FSignature> = mapOf(
     // this set of function have no return value and operate in-place:
+    "setlsb"    to FSignature(false, listOf(FParam("variable", arrayOf(DataType.WORD, DataType.UWORD)), FParam("value", arrayOf(DataType.BYTE, DataType.UBYTE))), null),
+    "setmsb"    to FSignature(false, listOf(FParam("variable", arrayOf(DataType.WORD, DataType.UWORD)), FParam("value", arrayOf(DataType.BYTE, DataType.UBYTE))), null),
     "rol"       to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
     "ror"       to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
     "rol2"      to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
@@ -80,34 +81,55 @@ val BuiltinFunctions: Map<String, FSignature> = mapOf(
     // 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),
+    "prog8_lib_square_byte"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.BYTE, DataType.UBYTE))), DataType.UBYTE),
+    "prog8_lib_square_word"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.WORD, DataType.UWORD))), DataType.UWORD),
+    "abs"       to FSignature(true, listOf(FParam("value", NumericDatatypesNoBool)), null),
+    "abs__byte"  to FSignature(true, listOf(FParam("value", arrayOf(DataType.BYTE))), DataType.BYTE),
+    "abs__word"  to FSignature(true, listOf(FParam("value", arrayOf(DataType.WORD))), DataType.WORD),
+    "abs__float" to FSignature(true, listOf(FParam("value", arrayOf(DataType.FLOAT))), DataType.FLOAT),
     "len"       to FSignature(true, listOf(FParam("values", IterableDatatypes)), DataType.UWORD),
     // normal functions follow:
-    "sizeof"    to FSignature(true, listOf(FParam("object", DataType.values())), DataType.UBYTE),
+    "sizeof"    to FSignature(true, listOf(FParam("object", DataType.entries.toTypedArray())), 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),
+    "sqrt"        to FSignature(true, listOf(FParam("value", NumericDatatypesNoBool)), null),
+    "sqrt__ubyte" to FSignature(true, listOf(FParam("value", arrayOf(DataType.UBYTE))), DataType.UBYTE),
+    "sqrt__uword" to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD))), DataType.UBYTE),
+    "sqrt__float" to FSignature(true, listOf(FParam("value", arrayOf(DataType.FLOAT))), DataType.FLOAT),
+    "divmod"           to FSignature(false, listOf(FParam("number", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("divident", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("division", arrayOf(DataType.UBYTE, DataType.UWORD)), FParam("remainder", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
+    "divmod__ubyte"    to FSignature(false, listOf(FParam("number", arrayOf(DataType.UBYTE)), FParam("divident", arrayOf(DataType.UBYTE)), FParam("division", arrayOf(DataType.UBYTE)), FParam("remainder", arrayOf(DataType.UBYTE))), null),
+    "divmod__uword"    to FSignature(false, listOf(FParam("number", arrayOf(DataType.UWORD)), FParam("divident", arrayOf(DataType.UWORD)), FParam("division", arrayOf(DataType.UWORD)), FParam("remainder", arrayOf(DataType.UWORD))), null),
     "any"       to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.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),
     "msb"       to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE),
     "mkword"    to FSignature(true, listOf(FParam("msb", arrayOf(DataType.UBYTE)), FParam("lsb", arrayOf(DataType.UBYTE))), DataType.UWORD),
+    "clamp"     to FSignature(true, listOf(FParam("value", arrayOf(DataType.BYTE)), FParam("minimum", arrayOf(DataType.BYTE)), FParam("maximum", arrayOf(DataType.BYTE))), null),
+    "clamp__byte"  to FSignature(true, listOf(FParam("value", arrayOf(DataType.BYTE)), FParam("minimum", arrayOf(DataType.BYTE)), FParam("maximum", arrayOf(DataType.BYTE))), DataType.BYTE),
+    "clamp__ubyte" to FSignature(true, listOf(FParam("value", arrayOf(DataType.UBYTE)), FParam("minimum", arrayOf(DataType.UBYTE)), FParam("maximum", arrayOf(DataType.UBYTE))), DataType.UBYTE),
+    "clamp__word"  to FSignature(true, listOf(FParam("value", arrayOf(DataType.WORD)), FParam("minimum", arrayOf(DataType.WORD)), FParam("maximum", arrayOf(DataType.WORD))), DataType.WORD),
+    "clamp__uword" to FSignature(true, listOf(FParam("value", arrayOf(DataType.UWORD)), FParam("minimum", arrayOf(DataType.UWORD)), FParam("maximum", arrayOf(DataType.UWORD))), DataType.UWORD),
+    "min"        to FSignature(true, listOf(FParam("val1", arrayOf(DataType.BYTE)), FParam("val2", arrayOf(DataType.BYTE))), null),
+    "min__byte"  to FSignature(true, listOf(FParam("val1", arrayOf(DataType.BYTE)), FParam("val2", arrayOf(DataType.BYTE))), DataType.BYTE),
+    "min__ubyte" to FSignature(true, listOf(FParam("val1", arrayOf(DataType.UBYTE)), FParam("val2", arrayOf(DataType.UBYTE))), DataType.UBYTE),
+    "min__word"  to FSignature(true, listOf(FParam("val1", arrayOf(DataType.WORD)), FParam("val2", arrayOf(DataType.WORD))), DataType.WORD),
+    "min__uword" to FSignature(true, listOf(FParam("val1", arrayOf(DataType.UWORD)), FParam("val2", arrayOf(DataType.UWORD))), DataType.UWORD),
+    "max"        to FSignature(true, listOf(FParam("val1", arrayOf(DataType.BYTE)), FParam("val2", arrayOf(DataType.BYTE))), null),
+    "max__byte"  to FSignature(true, listOf(FParam("val1", arrayOf(DataType.BYTE)), FParam("val2", arrayOf(DataType.BYTE))), DataType.BYTE),
+    "max__ubyte" to FSignature(true, listOf(FParam("val1", arrayOf(DataType.UBYTE)), FParam("val2", arrayOf(DataType.UBYTE))), DataType.UBYTE),
+    "max__word"  to FSignature(true, listOf(FParam("val1", arrayOf(DataType.WORD)), FParam("val2", arrayOf(DataType.WORD))), DataType.WORD),
+    "max__uword" to FSignature(true, listOf(FParam("val1", arrayOf(DataType.UWORD)), FParam("val2", arrayOf(DataType.UWORD))), DataType.UWORD),
     "peek"      to FSignature(true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UBYTE),
     "peekw"     to FSignature(true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UWORD),
+    "peekf"     to FSignature(true, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.FLOAT),
     "poke"      to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), null),
-    "pokemon"   to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), null),
     "pokew"     to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UWORD))), null),
-    "pop"       to FSignature(false, listOf(FParam("target", ByteDatatypes)), null),
-    "popw"      to FSignature(false, listOf(FParam("target", WordDatatypes)), null),
-    "push"      to FSignature(false, listOf(FParam("value", ByteDatatypes)), null),
-    "pushw"     to FSignature(false, listOf(FParam("value", WordDatatypes)), null),
+    "pokef"     to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.FLOAT))), null),
+    "pokemon"   to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), DataType.UBYTE),
     "rsave"     to FSignature(false, emptyList(), null),
-    "rsavex"    to FSignature(false, emptyList(), null),
     "rrestore"  to FSignature(false, emptyList(), null),
-    "rrestorex" to FSignature(false, emptyList(), null),
     "memory"    to FSignature(true, listOf(FParam("name", arrayOf(DataType.STR)), FParam("size", arrayOf(DataType.UWORD)), FParam("alignment", arrayOf(DataType.UWORD))), DataType.UWORD),
     "callfar"   to FSignature(false, listOf(FParam("bank", arrayOf(DataType.UBYTE)), FParam("address", arrayOf(DataType.UWORD)), FParam("arg", arrayOf(DataType.UWORD))), DataType.UWORD),
+    "call"      to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD))), DataType.UWORD),
 )
 
-val InplaceModifyingBuiltinFunctions = setOf("rol", "ror", "rol2", "ror2", "sort", "reverse")
+val InplaceModifyingBuiltinFunctions = setOf("setlsb", "setmsb", "rol", "ror", "rol2", "ror2", "sort", "reverse")

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

@@ -8,24 +8,32 @@ class CompilationOptions(val output: OutputType,
                          val launcher: CbmPrgLauncherType,
                          val zeropage: ZeropageType,
                          val zpReserved: List<UIntRange>,
+                         val zpAllowed: List<UIntRange>,
                          val floats: Boolean,
                          val noSysInit: Boolean,
                          val compTarget: ICompilationTarget,
                          // these are set later, based on command line arguments or options in the source code:
                          var loadAddress: UInt,
-                         var slowCodegenWarnings: Boolean = false,
+                         var warnSymbolShadowing: Boolean = false,
                          var optimize: Boolean = false,
-                         var optimizeFloatExpressions: Boolean = false,
                          var asmQuiet: Boolean = false,
                          var asmListfile: Boolean = false,
+                         var includeSourcelines: Boolean = false,
                          var experimentalCodegen: Boolean = false,
-                         var varsHigh: Boolean = false,
-                         var useNewExprCode: Boolean = false,
-                         var evalStackBaseAddress: UInt? = null,
+                         var varsHighBank: Int? = null,
+                         var varsGolden: Boolean = false,
+                         var slabsHighBank: Int? = null,
+                         var slabsGolden: Boolean = false,
+                         var splitWordArrays: Boolean = false,
+                         var breakpointCpuInstruction: Boolean = false,
                          var outputDir: Path = Path(""),
                          var symbolDefs: Map<String, String> = emptyMap()
 ) {
     init {
         compTarget.machine.initializeMemoryAreas(this)
     }
+
+    companion object {
+        val AllZeropageAllowed: List<UIntRange> = listOf(0u..255u)
+    }
 }

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

@@ -1,17 +1,20 @@
 package prog8.code.core
 
 enum class DataType {
-    UBYTE,              // pass by value
-    BYTE,               // pass by value
-    UWORD,              // pass by value
-    WORD,               // pass by value
-    FLOAT,              // pass by value
-    BOOL,               // pass by value
+    UBYTE,              // pass by value            8 bits unsigned
+    BYTE,               // pass by value            8 bits signed
+    UWORD,              // pass by value            16 bits unsigned
+    WORD,               // pass by value            16 bits signed
+    LONG,               // pass by value            32 bits signed
+    FLOAT,              // pass by value            machine dependent
+    BOOL,               // pass by value            bit 0 of a 8 bit byte
     STR,                // pass by reference
     ARRAY_UB,           // pass by reference
     ARRAY_B,            // pass by reference
     ARRAY_UW,           // pass by reference
+    ARRAY_UW_SPLIT,     // pass by reference, lo/hi byte split
     ARRAY_W,            // pass by reference
+    ARRAY_W_SPLIT,      // pass by reference, lo/hi byte split
     ARRAY_F,            // pass by reference
     ARRAY_BOOL,         // pass by reference
     UNDEFINED;
@@ -21,11 +24,12 @@ enum class DataType {
      */
     infix fun isAssignableTo(targetType: DataType) =
         when(this) {
-            BOOL -> targetType.oneOf(BOOL, BYTE, UBYTE, WORD, UWORD, FLOAT)
-            UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT, BOOL)
-            BYTE -> targetType.oneOf(BYTE, WORD, FLOAT)
-            UWORD -> targetType.oneOf(UWORD, FLOAT)
-            WORD -> targetType.oneOf(WORD, FLOAT)
+            BOOL -> targetType.oneOf(BOOL, BYTE, UBYTE, WORD, UWORD, LONG, FLOAT)
+            UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, LONG, FLOAT, BOOL)
+            BYTE -> targetType.oneOf(BYTE, WORD, LONG, FLOAT)
+            UWORD -> targetType.oneOf(UWORD, LONG, FLOAT)
+            WORD -> targetType.oneOf(WORD, LONG, FLOAT)
+            LONG -> targetType.oneOf(LONG, FLOAT)
             FLOAT -> targetType.oneOf(FLOAT)
             STR -> targetType.oneOf(STR, UWORD)
             in ArrayDatatypes -> targetType == this
@@ -39,7 +43,8 @@ enum class DataType {
             this == other -> false
             this in ByteDatatypes -> false
             this in WordDatatypes -> other in ByteDatatypes
-            this== STR && other== UWORD || this== UWORD && other== STR -> false
+            this == LONG -> other in ByteDatatypes+WordDatatypes
+            this == STR && other == UWORD || this == UWORD && other == STR -> false
             else -> true
         }
 
@@ -74,6 +79,13 @@ enum class RegisterOrPair {
 
     companion object {
         val names by lazy { values().map { it.toString()} }
+        fun fromCpuRegister(cpu: CpuRegister): RegisterOrPair {
+            return when(cpu) {
+                CpuRegister.A -> A
+                CpuRegister.X -> X
+                CpuRegister.Y -> Y
+            }
+        }
     }
 
     fun asCpuRegister(): CpuRegister = when(this) {
@@ -108,23 +120,25 @@ enum class BranchCondition {
     PL,     // PL == POS
     POS,
     VS,
-    VC,
+    VC
 }
 
 
 val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.BOOL)
 val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD)
-val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.BOOL)
-val IntegerDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
-val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT, DataType.BOOL)
-val NumericDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
-val SignedDatatypes =  arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT)
-val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F, DataType.ARRAY_BOOL)
+val IntegerDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.LONG)
+val IntegerDatatypes = IntegerDatatypesNoBool + DataType.BOOL
+val NumericDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.LONG, DataType.FLOAT)
+val NumericDatatypes = NumericDatatypesNoBool + DataType.BOOL
+val SignedDatatypes =  arrayOf(DataType.BYTE, DataType.WORD, DataType.LONG, DataType.FLOAT)
+val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_UW_SPLIT, DataType.ARRAY_W, DataType.ARRAY_W_SPLIT, DataType.ARRAY_F, DataType.ARRAY_BOOL)
 val StringlyDatatypes = arrayOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD)
+val SplitWordArrayTypes = arrayOf(DataType.ARRAY_UW_SPLIT, DataType.ARRAY_W_SPLIT)
 val IterableDatatypes = arrayOf(
     DataType.STR,
     DataType.ARRAY_UB, DataType.ARRAY_B,
     DataType.ARRAY_UW, DataType.ARRAY_W,
+    DataType.ARRAY_UW_SPLIT, DataType.ARRAY_W_SPLIT,
     DataType.ARRAY_F, DataType.ARRAY_BOOL
 )
 val PassByValueDatatypes = NumericDatatypes
@@ -135,6 +149,8 @@ val ArrayToElementTypes = mapOf(
     DataType.ARRAY_UB to DataType.UBYTE,
     DataType.ARRAY_W to DataType.WORD,
     DataType.ARRAY_UW to DataType.UWORD,
+    DataType.ARRAY_W_SPLIT to DataType.WORD,
+    DataType.ARRAY_UW_SPLIT to DataType.UWORD,
     DataType.ARRAY_F to DataType.FLOAT,
     DataType.ARRAY_BOOL to DataType.BOOL
 )
@@ -144,8 +160,10 @@ val ElementToArrayTypes = mapOf(
     DataType.WORD to DataType.ARRAY_W,
     DataType.UWORD to DataType.ARRAY_UW,
     DataType.FLOAT to DataType.ARRAY_F,
-    DataType.BOOL to DataType.ARRAY_BOOL
+    DataType.BOOL to DataType.ARRAY_BOOL,
+    DataType.STR to DataType.ARRAY_UW          // array of str is just an array of pointers
 )
+
 val Cx16VirtualRegisters = arrayOf(
     RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3,
     RegisterOrPair.R4, RegisterOrPair.R5, RegisterOrPair.R6, RegisterOrPair.R7,
@@ -153,6 +171,10 @@ val Cx16VirtualRegisters = arrayOf(
     RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15
 )
 
+val CpuRegisters = setOf(
+    RegisterOrPair.A, RegisterOrPair.X, RegisterOrPair.Y,
+    RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY
+)
 
 
 enum class OutputType {

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

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

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

@@ -3,10 +3,12 @@ package prog8.code.core
 interface IErrorReporter {
     fun err(msg: String, position: Position)
     fun warn(msg: String, position: Position)
+    fun info(msg: String, position: Position)
+    fun undefined(symbol: List<String>, position: Position)
     fun noErrors(): Boolean
     fun report()
-    fun finalizeNumErrors(numErrors: Int, numWarnings: Int) {
+    fun finalizeNumErrors(numErrors: Int, numWarnings: Int, numInfos: Int) {
         if(numErrors>0)
-            throw ErrorsReportedException("There are $numErrors errors and $numWarnings warnings.")
+            throw ErrorsReportedException("There are $numErrors errors, $numWarnings warnings, and $numInfos infos.")
     }
 }

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

@@ -13,11 +13,11 @@ interface IMachineDefinition {
     val FLOAT_MAX_NEGATIVE: Double
     val FLOAT_MAX_POSITIVE: Double
     val FLOAT_MEM_SIZE: Int
-    var ESTACK_LO: UInt
-    var ESTACK_HI: UInt
     val PROGRAM_LOAD_ADDRESS : UInt
     val BSSHIGHRAM_START: UInt
     val BSSHIGHRAM_END: UInt
+    val BSSGOLDENRAM_START: UInt
+    val BSSGOLDENRAM_END: UInt
 
     val cpu: CpuType
     var zeropage: Zeropage
@@ -29,11 +29,4 @@ interface IMachineDefinition {
     fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String>
     fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path)
     fun isIOAddress(address: UInt): Boolean
-    fun overrideEvalStack(evalStackBaseAddress: UInt) {
-        require(evalStackBaseAddress and 255u == 0u)
-        ESTACK_LO = evalStackBaseAddress
-        ESTACK_HI = evalStackBaseAddress + 256u
-        require(ESTACK_LO !in golden.region && ESTACK_HI !in golden.region) { "user-set ESTACK can't be in GOLDEN ram" }
-    }
-
 }

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

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

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

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

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

@@ -1,12 +1,10 @@
 package prog8.code.core
 
-val AssociativeOperators = setOf("+", "*", "&", "|", "^", "==", "!=")
+val AssociativeOperators = setOf("+", "*", "&", "|", "^", "==", "!=", "and", "or", "xor")
 val ComparisonOperators = setOf("==", "!=", "<", ">", "<=", ">=")
 val LogicalOperators = setOf("and", "or", "xor", "not")
-val AugmentAssignmentOperators = setOf("+", "-", "/", "*", "&", "|", "^", "<<", ">>", "%", "and", "or", "xor")
 val BitwiseOperators = setOf("&", "|", "^", "~")
 val PrefixOperators = setOf("+", "-", "~", "not")
-// val InvalidOperatorsForBoolean = setOf("+", "-", "*", "/", "%", "<<", ">>") + BitwiseOperators
 
 fun invertedComparisonOperator(operator: String) =
     when (operator) {

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

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

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

@@ -3,6 +3,7 @@ package prog8.code.core
 import java.io.File
 import java.io.IOException
 import java.nio.file.Path
+import java.text.Normalizer
 import kotlin.io.path.Path
 import kotlin.io.path.readText
 
@@ -54,12 +55,14 @@ sealed class SourceCode {
         /**
          * filename prefix to designate library files that will be retreived from internal resources rather than disk
          */
-        const val libraryFilePrefix = "library:"
-        const val stringSourcePrefix = "string:"
+        const val LIBRARYFILEPREFIX = "library:"
+        const val STRINGSOURCEPREFIX = "string:"
         val curdir: Path = Path(".").toAbsolutePath()
         fun relative(path: Path): Path = curdir.relativize(path.toAbsolutePath())
         fun isRegularFilesystemPath(pathString: String) =
-            !(pathString.startsWith(libraryFilePrefix) || pathString.startsWith(stringSourcePrefix))
+            !(pathString.startsWith(LIBRARYFILEPREFIX) || pathString.startsWith(STRINGSOURCEPREFIX))
+
+        fun isLibraryResource(path: String) = path.startsWith(LIBRARYFILEPREFIX)
     }
 
     /**
@@ -69,7 +72,7 @@ sealed class SourceCode {
     class Text(override val text: String): SourceCode() {
         override val isFromResources = false
         override val isFromFilesystem = false
-        override val origin = "$stringSourcePrefix${System.identityHashCode(text).toString(16)}"
+        override val origin = "$STRINGSOURCEPREFIX${System.identityHashCode(text).toString(16)}"
         override val name = "<unnamed-text>"
     }
 
@@ -92,7 +95,7 @@ sealed class SourceCode {
             val normalized = path.normalize()
             origin = relative(normalized).toString()
             try {
-                text = normalized.readText()
+                text = Normalizer.normalize(normalized.readText(), Normalizer.Form.NFC)
                 name = normalized.toFile().nameWithoutExtension
             } catch (nfx: java.nio.file.NoSuchFileException) {
                 throw NoSuchFileException(normalized.toFile()).also { it.initCause(nfx) }
@@ -110,7 +113,7 @@ sealed class SourceCode {
 
         override val isFromResources = true
         override val isFromFilesystem = false
-        override val origin = "$libraryFilePrefix$normalized"
+        override val origin = "$LIBRARYFILEPREFIX$normalized"
         override val text: String
         override val name: String
 
@@ -124,7 +127,7 @@ sealed class SourceCode {
                 )
             }
             val stream = object {}.javaClass.getResourceAsStream(normalized)
-            text = stream!!.reader().use { it.readText() }
+            text = stream!!.reader().use { Normalizer.normalize(it.readText(), Normalizer.Form.NFC) }
             name = Path(pathString).toFile().nameWithoutExtension
         }
     }
@@ -139,3 +142,33 @@ sealed class SourceCode {
         override val text: String = "<generated code node, no text representation>"
     }
 }
+
+
+object SourceLineCache {
+    private val cache = mutableMapOf<String, List<String>>()
+
+    private fun getCachedFile(file: String): List<String> {
+        val existing = cache[file]
+        if(existing!=null)
+            return existing
+        if (SourceCode.isRegularFilesystemPath(file)) {
+            val source = SourceCode.File(Path(file))
+            cache[file] = source.text.split('\n', '\r').map { it.trim() }
+            return cache.getValue(file)
+        } else if(file.startsWith(SourceCode.LIBRARYFILEPREFIX)) {
+            val source = SourceCode.Resource(file.drop(SourceCode.LIBRARYFILEPREFIX.length))
+            cache[file] = source.text.split('\n', '\r').map { it.trim()}
+            return cache.getValue(file)
+        }
+        return emptyList()
+    }
+
+    fun retrieveLine(position: Position): String? {
+        if (position.line>0) {
+            val lines = getCachedFile(position.file)
+            if(lines.isNotEmpty())
+                return lines[position.line-1]
+        }
+        return null
+    }
+}

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

@@ -0,0 +1,127 @@
+package prog8.code.optimize
+
+import prog8.code.ast.*
+import prog8.code.core.*
+
+
+fun optimizeIntermediateAst(program: PtProgram, options: CompilationOptions, errors: IErrorReporter) {
+    if (!options.optimize)
+        return
+    while(errors.noErrors() && optimizeCommonSubExpressions(program, errors)>0) {
+        // keep rolling
+    }
+}
+
+
+private fun walkAst(root: PtNode, act: (node: PtNode, depth: Int) -> Boolean) {
+    fun recurse(node: PtNode, depth: Int) {
+        if(act(node, depth))
+            node.children.forEach { recurse(it, depth+1) }
+    }
+    recurse(root, 0)
+}
+
+
+private fun optimizeCommonSubExpressions(program: PtProgram, errors: IErrorReporter): Int {
+
+    fun extractableSubExpr(expr: PtExpression): Boolean {
+        val result = if(expr is PtBinaryExpression)
+            expr.type !in ByteDatatypes ||
+                    !expr.left.isSimple() ||
+                    !expr.right.isSimple() ||
+                    (expr.operator !in LogicalOperators && expr.operator !in BitwiseOperators)
+        else if (expr is PtArrayIndexer && expr.type !in ByteDatatypes)
+            true
+        else
+            !expr.isSimple()
+        return result
+    }
+
+    // for each Binaryexpression, recurse to find a common subexpression pair therein.
+    val commons = mutableMapOf<PtBinaryExpression, Pair<PtExpression, PtExpression>>()
+    walkAst(program) { node: PtNode, depth: Int ->
+        if(node is PtBinaryExpression) {
+            val subExpressions = mutableListOf<PtExpression>()
+            walkAst(node.left) { subNode: PtNode, subDepth: Int ->
+                if (subNode is PtExpression) {
+                    if(extractableSubExpr(subNode)) subExpressions.add(subNode)
+                    true
+                } else false
+            }
+            walkAst(node.right) { subNode: PtNode, subDepth: Int ->
+                if (subNode is PtExpression) {
+                    if(extractableSubExpr(subNode)) subExpressions.add(subNode)
+                    true
+                } else false
+            }
+
+            outer@for (first in subExpressions) {
+                for (second in subExpressions) {
+                    if (first!==second && first isSameAs second) {
+                        commons[node] = first to second
+                        break@outer     // do only 1 replacement at a time per binaryexpression
+                    }
+                }
+            }
+            false
+        } else true
+    }
+
+    // replace common subexpressions by a temp variable that is assigned only once.
+    // TODO: check for commonalities across multiple separate expressions in the current scope, not only inside a single line
+    commons.forEach { binexpr, (occurrence1, occurrence2) ->
+        val (stmtContainer, stmt) = findContainingStatements(binexpr)
+        val occurrence1idx = occurrence1.parent.children.indexOf(occurrence1)
+        val occurrence2idx = occurrence2.parent.children.indexOf(occurrence2)
+        val containerScopedName = findScopeName(stmtContainer)
+        val tempvarName = "subexprvar_line${binexpr.position.line}_${binexpr.hashCode().toUInt()}"
+        // TODO: some tempvars could be reused, if they are from different lines
+
+        val datatype = occurrence1.type
+        val singleReplacement1 = PtIdentifier("$containerScopedName.$tempvarName", datatype, occurrence1.position)
+        val singleReplacement2 = PtIdentifier("$containerScopedName.$tempvarName", datatype, occurrence2.position)
+        occurrence1.parent.children[occurrence1idx] = singleReplacement1
+        singleReplacement1.parent = occurrence1.parent
+        occurrence2.parent.children[occurrence2idx] = singleReplacement2
+        singleReplacement2.parent = occurrence2.parent
+
+        val tempassign = PtAssignment(binexpr.position).also { assign ->
+            assign.add(PtAssignTarget(binexpr.position).also { tgt->
+                tgt.add(PtIdentifier("$containerScopedName.$tempvarName", datatype, binexpr.position))
+            })
+            assign.add(occurrence1)
+            occurrence1.parent = assign
+        }
+        stmtContainer.children.add(stmtContainer.children.indexOf(stmt), tempassign)
+        tempassign.parent = stmtContainer
+
+        val tempvar = PtVariable(tempvarName, datatype, ZeropageWish.DONTCARE, null, null, binexpr.position)
+        stmtContainer.add(0, tempvar)
+        tempvar.parent = stmtContainer
+
+        // errors.info("common subexpressions replaced by a tempvar, maybe simplify the expression manually", binexpr.position)
+    }
+
+    return commons.size
+}
+
+
+internal fun findScopeName(node: PtNode): String {
+    var parent=node
+    while(parent !is PtNamedNode)
+        parent = parent.parent
+    return parent.scopedName
+}
+
+
+internal fun findContainingStatements(node: PtNode): Pair<PtNode, PtNode> {      // returns (parentstatementcontainer, childstatement)
+    var parent = node.parent
+    var child = node
+    while(true) {
+        if(parent is IPtStatementContainer) {
+            return parent to child
+        }
+        child=parent
+        parent=parent.parent
+    }
+}

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

@@ -7,7 +7,6 @@ import prog8.code.target.atari.AtariMachineDefinition
 class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
     override val name = NAME
     override val machine = AtariMachineDefinition()
-    override val supportedEncodings = setOf(Encoding.ATASCII)
     override val defaultEncoding = Encoding.ATASCII
 
     companion object {
@@ -19,7 +18,7 @@ class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
             in ByteDatatypes -> 1
             in WordDatatypes, in PassByReferenceDatatypes -> 2
             DataType.FLOAT -> machine.FLOAT_MEM_SIZE
-            else -> Int.MIN_VALUE
+            else -> throw IllegalArgumentException("invalid datatype")
         }
     }
 

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+package prog8.code.target
+
+import prog8.code.core.Encoding
+import prog8.code.core.ICompilationTarget
+import prog8.code.core.IMemSizer
+import prog8.code.core.IStringEncoding
+import prog8.code.target.cbm.CbmMemorySizer
+import prog8.code.target.pet.PETMachineDefinition
+
+
+class PETTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+    override val name = NAME
+    override val machine = PETMachineDefinition()
+    override val defaultEncoding = Encoding.PETSCII
+
+    companion object {
+        const val NAME = "pet32"
+    }
+}

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

@@ -6,7 +6,6 @@ import prog8.code.target.virtual.VirtualMachineDefinition
 class VMTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
     override val name = NAME
     override val machine = VirtualMachineDefinition()
-    override val supportedEncodings = setOf(Encoding.ISO)
     override val defaultEncoding = Encoding.ISO
 
     companion object {
@@ -18,7 +17,7 @@ class VMTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
             in ByteDatatypes -> 1
             in WordDatatypes, in PassByReferenceDatatypes -> 2
             DataType.FLOAT -> machine.FLOAT_MEM_SIZE
-            else -> Int.MIN_VALUE
+            else -> throw IllegalArgumentException("invalid datatype")
         }
     }
 

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

@@ -13,12 +13,10 @@ class AtariMachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = 6
     override val PROGRAM_LOAD_ADDRESS = 0x2000u
 
-    // the 2*128 byte evaluation stack (1 page, on which bytes, words, and even floats are stored during calculations)
-    override var ESTACK_LO = 0x1b00u     //  $1b00-$1b7f inclusive      // TODO
-    override var ESTACK_HI = 0x1b80u     //  $1b80-$1bff inclusive      // TODO
-
     override val BSSHIGHRAM_START = 0u    // TODO
     override val BSSHIGHRAM_END = 0u      // TODO
+    override val BSSGOLDENRAM_START = 0u  // TODO
+    override val BSSGOLDENRAM_END = 0u    // TODO
 
     override lateinit var zeropage: Zeropage
     override lateinit var golden: GoldenRam

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

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

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

@@ -15,12 +15,10 @@ class C128MachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
     override val PROGRAM_LOAD_ADDRESS = 0x1c01u
 
-    // the 2*128 byte evaluation stack (1 page, on which bytes, words, and even floats are stored during calculations)
-    override var ESTACK_LO = 0x1b00u     //  $1b00-$1b7f inclusive
-    override var ESTACK_HI = 0x1b80u     //  $1b80-$1bff inclusive
-
     override val BSSHIGHRAM_START = 0u    // TODO
     override val BSSHIGHRAM_END = 0u      // TODO
+    override val BSSGOLDENRAM_START = 0u  // TODO
+    override val BSSGOLDENRAM_END = 0u    // TODO
 
     override lateinit var zeropage: Zeropage
     override lateinit var golden: GoldenRam

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

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

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

@@ -16,12 +16,10 @@ class C64MachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
 
-    // the 2*128 byte evaluation stack (1 page, on which bytes, words, and even floats are stored during calculations)
-    override var ESTACK_LO = 0xcf00u     //  $cf00-$cf7f inclusive
-    override var ESTACK_HI = 0xcf80u     //  $cf80-$cfff inclusive
-
     override val BSSHIGHRAM_START = 0xc000u
-    override val BSSHIGHRAM_END = ESTACK_LO
+    override val BSSHIGHRAM_END = 0xcfffu
+    override val BSSGOLDENRAM_START = 0u
+    override val BSSGOLDENRAM_END = 0u
 
     override lateinit var zeropage: Zeropage
     override lateinit var golden: GoldenRam
@@ -62,7 +60,7 @@ class C64MachineDefinition: IMachineDefinition {
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = C64Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, 0xc000u until ESTACK_LO)
+        golden = GoldenRam(compilerOptions, 0xc000u until 0xd000u)
     }
 
 }

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

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

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

@@ -9,7 +9,7 @@ internal object CbmMemorySizer: IMemSizer {
             in ByteDatatypes -> 1
             in WordDatatypes, in PassByReferenceDatatypes -> 2
             DataType.FLOAT -> Mflpt5.FLOAT_MEM_SIZE
-            else -> Int.MIN_VALUE
+            else -> throw IllegalArgumentException("invalid datatype")
         }
     }
 

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

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

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

@@ -15,12 +15,10 @@ class CX16MachineDefinition: IMachineDefinition {
     override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
     override val PROGRAM_LOAD_ADDRESS = 0x0801u
 
-    // the 2*128 byte evaluation stack (1 page, on which bytes, words, and even floats are stored during calculations)
-    override var ESTACK_LO = 0x0700u        //  $0700-$077f inclusive
-    override var ESTACK_HI = 0x0780u        //  $0780-$07ff inclusive
-
     override val BSSHIGHRAM_START = 0xa000u     // hiram bank 1, 8Kb, assumed to be active
-    override val BSSHIGHRAM_END = 0xc000u       // rom starts here.
+    override val BSSHIGHRAM_END = 0xbfffu       // Rom starts at $c000
+    override val BSSGOLDENRAM_START = 0x0400u
+    override val BSSGOLDENRAM_END = 0x07ffu
 
     override lateinit var zeropage: Zeropage
     override lateinit var golden: GoldenRam
@@ -40,7 +38,7 @@ class CX16MachineDefinition: IMachineDefinition {
         when(selectedEmulator) {
             1 -> {
                 emulator = "x16emu"
-                extraArgs = emptyList()
+                extraArgs = listOf("-debug")
             }
             2 -> {
                 emulator = "box16"
@@ -53,7 +51,7 @@ class CX16MachineDefinition: IMachineDefinition {
         }
 
         println("\nStarting Commander X16 emulator $emulator...")
-        val cmdline = listOf(emulator, "-scale", "2", "-run", "-prg", "${programNameWithPath}.prg") + extraArgs
+        val cmdline = listOf(emulator, "-scale", "2", "-rtc", "-run", "-prg", "${programNameWithPath}.prg") + extraArgs
         val processb = ProcessBuilder(cmdline).inheritIO()
         processb.environment()["PULSE_LATENCY_MSEC"] = "10"
         val process: Process = processb.start()
@@ -64,7 +62,7 @@ class CX16MachineDefinition: IMachineDefinition {
 
     override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
         zeropage = CX16Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, 0x0400u until ESTACK_LO)
+        golden = GoldenRam(compilerOptions, 0x0400u until 0x0800u)
     }
 
 }

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

@@ -40,7 +40,6 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
                 ZeropageType.DONTUSE -> {
                     free.clear() // don't use zeropage at all
                 }
-                else -> throw InternalCompilerException("for this machine target, zero page type 'floatsafe' is not available. ${options.zeropage}")
             }
 
             val distinctFree = free.distinct()
@@ -48,8 +47,8 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
             free.addAll(distinctFree)
 
             removeReservedFromFreePool()
-
             allocateCx16VirtualRegisters()
+            retainAllowed()
         }
     }
 

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

@@ -0,0 +1,57 @@
+package prog8.code.target.pet
+
+import prog8.code.core.*
+import prog8.code.target.C64Target
+import prog8.code.target.cbm.Mflpt5
+import java.nio.file.Path
+
+
+class PETMachineDefinition: IMachineDefinition {
+
+    override val cpu = CpuType.CPU6502
+
+    override val FLOAT_MAX_POSITIVE = Mflpt5.FLOAT_MAX_POSITIVE
+    override val FLOAT_MAX_NEGATIVE = Mflpt5.FLOAT_MAX_NEGATIVE
+    override val FLOAT_MEM_SIZE = Mflpt5.FLOAT_MEM_SIZE
+    override val PROGRAM_LOAD_ADDRESS = 0x0401u
+
+    override val BSSHIGHRAM_START = 0u
+    override val BSSHIGHRAM_END = 0u
+    override val BSSGOLDENRAM_START = 0u
+    override val BSSGOLDENRAM_END = 0u
+
+    override lateinit var zeropage: Zeropage
+    override lateinit var golden: GoldenRam
+
+    override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
+
+    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
+        return if (compilerOptions.launcher == CbmPrgLauncherType.BASIC || compilerOptions.output == OutputType.PRG)
+            listOf("syslib")
+        else
+            emptyList()
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
+        if(selectedEmulator!=1) {
+            System.err.println("The pet target only supports the main emulator (Vice).")
+            return
+        }
+
+        println("\nStarting PET emulator...")
+        val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
+        val cmdline = listOf("xpet", "-model", "4032", "-ramsize", "32", "-videosize", "40", "-silent", "-moncommands", viceMonlist,
+                "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
+        val processb = ProcessBuilder(cmdline).inheritIO()
+        val process=processb.start()
+        process.waitFor()
+    }
+
+    override fun isIOAddress(address: UInt): Boolean = address in 0xe800u..0xe8ffu
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = PETZeropage(compilerOptions)
+        // there's no golden ram.
+    }
+
+}

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

@@ -0,0 +1,59 @@
+package prog8.code.target.pet
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.InternalCompilerException
+import prog8.code.core.Zeropage
+import prog8.code.core.ZeropageType
+
+
+// reference: http://www.zimmers.net/cbmpics/cbm/PETx/petmem.txt
+
+class PETZeropage(options: CompilationOptions) : Zeropage(options) {
+
+    override val SCRATCH_B1 = 0xb3u      // temp storage for a single byte
+    override val SCRATCH_REG = 0xb4u     // temp storage for a register, must be B1+1
+    override val SCRATCH_W1 = 0xb6u      // temp storage 1 for a word
+    override val SCRATCH_W2 = 0xb8u      // temp storage 2 for a word
+
+    init {
+        if (options.floats) {
+            throw InternalCompilerException("PET target doesn't yet support floating point routines")
+        }
+
+        if (options.floats && options.zeropage !in arrayOf(
+                ZeropageType.FLOATSAFE,
+                ZeropageType.BASICSAFE,
+                ZeropageType.DONTUSE
+            ))
+            throw InternalCompilerException("when floats are enabled, zero page type should be 'floatsafe' or 'basicsafe' or 'dontuse'")
+
+        when (options.zeropage) {
+            ZeropageType.FULL -> {
+                free.addAll(0x00u..0xffu)
+                free.removeAll(listOf(0x8du, 0x8eu, 0x8fu, 0x97u, 0x98u, 0x99u, 0x9au, 0x9bu, 0x9eu, 0xa7u, 0xa8u, 0xa9u, 0xaau))        // these are updated/used by IRQ
+            }
+            ZeropageType.KERNALSAFE -> {
+                free.addAll(0x00u..0xffu)
+                free.removeAll(listOf(0x8du, 0x8eu, 0x8fu, 0x97u, 0x98u, 0x99u, 0x9au, 0x9bu, 0x9eu, 0xa7u, 0xa8u, 0xa9u, 0xaau))        // these are updated/used by IRQ
+            }
+            ZeropageType.FLOATSAFE,
+            ZeropageType.BASICSAFE -> {
+                free.addAll(0xb3u..0xbau)       // TODO more?
+            }
+            ZeropageType.DONTUSE -> {
+                free.clear()  // don't use zeropage at all
+            }
+        }
+
+        val distinctFree = free.distinct()
+        free.clear()
+        free.addAll(distinctFree)
+
+        removeReservedFromFreePool()
+        retainAllowed()
+    }
+
+    override fun allocateCx16VirtualRegisters() {
+        TODO("Not known if PET can put the virtual regs in ZP")
+    }
+}

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

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

codeGenCpu6502/build.gradle

@@ -28,18 +28,18 @@ dependencies {
     implementation project(':codeCore')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.5.5'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
 }
 
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
     test {

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

@@ -1,8 +1,10 @@
 package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
+import prog8.code.StNode
 import prog8.code.StNodeType
 import prog8.code.SymbolTable
+import prog8.code.SymbolTableMaker
 import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
@@ -14,18 +16,201 @@ import kotlin.io.path.writeLines
 internal const val subroutineFloatEvalResultVar1 = "prog8_float_eval_result1"
 internal const val subroutineFloatEvalResultVar2 = "prog8_float_eval_result2"
 
-class AsmGen6502: ICodeGeneratorBackend {
+class AsmGen6502(val prefixSymbols: Boolean): ICodeGeneratorBackend {
     override fun generate(
         program: PtProgram,
         symbolTable: SymbolTable,
         options: CompilationOptions,
         errors: IErrorReporter
     ): IAssemblyProgram? {
-        val asmgen = AsmGen6502Internal(program, symbolTable, options, errors)
+        val st = if(prefixSymbols) prefixSymbols(program, options, symbolTable) else symbolTable
+        val asmgen = AsmGen6502Internal(program, st, options, errors)
         return asmgen.compileToAssembly()
     }
+
+    private fun prefixSymbols(program: PtProgram, options: CompilationOptions, st: SymbolTable): SymbolTable {
+        val nodesToPrefix = mutableListOf<Pair<PtNode, Int>>()              // parent + index
+        val functionCallsToPrefix = mutableListOf<Pair<PtNode, Int>>()      // parent + index
+
+        fun prefixNamedNode(node: PtNamedNode) {
+            when(node) {
+                is PtAsmSub, is PtSub -> node.name = "p8s_${node.name}"
+                is PtBlock -> node.name = "p8b_${node.name}"
+                is PtLabel -> node.name = "p8l_${node.name}"
+                is PtConstant -> node.name = "p8c_${node.name}"
+                is PtVariable, is PtMemMapped, is PtSubroutineParameter -> node.name = "p8v_${node.name}"
+                else -> node.name = "p8_${node.name}"
+            }
+        }
+
+        fun prefixSymbols(node: PtNode) {
+            when(node) {
+                is PtAsmSub -> {
+                    prefixNamedNode(node)
+                    node.parameters.forEach { (_, param) -> prefixNamedNode(param) }
+                }
+                is PtSub -> {
+                    prefixNamedNode(node)
+                    node.parameters.forEach { prefixNamedNode(it) }
+                }
+                is PtFunctionCall -> {
+                    val stNode = st.lookup(node.name)!!
+                    if(stNode.astNode.definingBlock()?.options?.noSymbolPrefixing!=true) {
+                        val index = node.parent.children.indexOf(node)
+                        functionCallsToPrefix += node.parent to index
+                    }
+                }
+                is PtIdentifier -> {
+                    var lookupName = node.name
+                    if(node.type in SplitWordArrayTypes && (lookupName.endsWith("_lsb") || lookupName.endsWith("_msb"))) {
+                        lookupName = lookupName.dropLast(4)
+                    }
+                    val stNode = st.lookup(lookupName)!!
+                    if(stNode.astNode.definingBlock()?.options?.noSymbolPrefixing!=true) {
+                        val index = node.parent.children.indexOf(node)
+                        nodesToPrefix += node.parent to index
+                    }
+                }
+                is PtJump -> {
+                    val stNode = st.lookup(node.identifier!!.name) ?: throw AssemblyError("name not found ${node.identifier}")
+                    if(stNode.astNode.definingBlock()?.options?.noSymbolPrefixing!=true) {
+                        val index = node.parent.children.indexOf(node)
+                        nodesToPrefix += node.parent to index
+                    }
+                }
+                is PtBlock -> prefixNamedNode(node)
+                is PtConstant -> prefixNamedNode(node)
+                is PtLabel -> prefixNamedNode(node)
+                is PtMemMapped -> prefixNamedNode(node)
+                is PtSubroutineParameter -> prefixNamedNode(node)
+                is PtVariable -> {
+                    val index = node.parent.children.indexOf(node)
+                    nodesToPrefix += node.parent to index
+                }
+                else -> { }
+            }
+            node.children.forEach { prefixSymbols(it) }
+        }
+
+        program.allBlocks().forEach { block ->
+            if (!block.options.noSymbolPrefixing) {
+                prefixSymbols(block)
+            }
+        }
+
+        nodesToPrefix.forEach { (parent, index) ->
+            val node = parent.children[index]
+            when(node) {
+                is PtIdentifier -> parent.children[index] = node.prefix(parent, st)
+                is PtFunctionCall ->  throw AssemblyError("PtFunctionCall should be processed in their own list, last")
+                is PtJump -> parent.children[index] = node.prefix(parent, st)
+                is PtVariable -> parent.children[index] = node.prefix(st)
+                else -> throw AssemblyError("weird node to prefix $node")
+            }
+        }
+
+        // reversed so inner calls (such as arguments to a function call) get processed before the actual function call itself
+        functionCallsToPrefix.reversed().forEach { (parent, index) ->
+            val node = parent.children[index]
+            if(node is PtFunctionCall) {
+                parent.children[index] = node.prefix(parent)
+            } else {
+                throw AssemblyError("expected PtFunctionCall")
+            }
+        }
+
+        return SymbolTableMaker(program, options).make()
+    }
 }
 
+private fun prefixScopedName(name: String, type: Char): String {
+    if('.' !in name)
+        return "p8${type}_$name"
+    val parts = name.split('.')
+    val firstPrefixed = "p8b_${parts[0]}"
+    val lastPrefixed = "p8${type}_${parts.last()}"
+    // the parts in between are assumed to be subroutine scopes.
+    val inbetweenPrefixed = parts.drop(1).dropLast(1).map{ "p8s_$it" }
+    val prefixed = listOf(firstPrefixed) + inbetweenPrefixed + listOf(lastPrefixed)
+    return prefixed.joinToString(".")
+}
+
+private fun PtVariable.prefix(st: SymbolTable): PtVariable {
+    name = prefixScopedName(name, 'v')
+    if(value==null)
+        return this
+
+    val arrayValue = value as? PtArray
+    return if(arrayValue!=null && arrayValue.children.any { it !is PtNumber} ) {
+        val newValue = PtArray(arrayValue.type, arrayValue.position)
+        arrayValue.children.forEach { elt ->
+            when(elt) {
+                is PtIdentifier -> newValue.add(elt.prefix(arrayValue, st))
+                is PtNumber -> newValue.add(elt)
+                is PtAddressOf -> {
+                    if(elt.definingBlock()?.options?.noSymbolPrefixing==true)
+                        newValue.add(elt)
+                    else {
+                        val newAddr = PtAddressOf(elt.position)
+                        newAddr.children.add(elt.identifier.prefix(newAddr, st))
+                        newAddr.parent = arrayValue
+                        newValue.add(newAddr)
+                    }
+                }
+                else -> throw AssemblyError("weird array value element $elt")
+            }
+        }
+        PtVariable(name, type, zeropage, newValue, arraySize, position)
+    }
+    else this
+}
+
+private fun PtJump.prefix(parent: PtNode, st: SymbolTable): PtJump {
+    val prefixedIdent = identifier!!.prefix(this, st)
+    val jump = PtJump(prefixedIdent, address, position)
+    jump.parent = parent
+    return jump
+}
+
+private fun PtFunctionCall.prefix(parent: PtNode): PtFunctionCall {
+    val newName = prefixScopedName(name, 's')
+    val call = PtFunctionCall(newName, void, type, position)
+    call.children.addAll(children)
+    call.children.forEach { it.parent = call }
+    call.parent = parent
+    return call
+}
+
+private fun PtIdentifier.prefix(parent: PtNode, st: SymbolTable): PtIdentifier {
+    var target = st.lookup(name)
+    if(target?.astNode?.definingBlock()?.options?.noSymbolPrefixing==true)
+        return this
+
+    if(target==null) {
+        if(name.endsWith("_lsb") || name.endsWith("_msb")) {
+            target = st.lookup(name.dropLast(4))
+            if(target?.astNode?.definingBlock()?.options?.noSymbolPrefixing==true)
+                return this
+        }
+    }
+
+    val prefixType = when(target!!.type) {
+        StNodeType.BLOCK -> 'b'
+        StNodeType.SUBROUTINE, StNodeType.ROMSUB -> 's'
+        StNodeType.LABEL -> 'l'
+        StNodeType.STATICVAR, StNodeType.MEMVAR -> 'v'
+        StNodeType.CONSTANT -> 'c'
+        StNodeType.BUILTINFUNC -> 's'
+        StNodeType.MEMORYSLAB -> 'v'
+        else -> '?'
+    }
+    val newName = prefixScopedName(name, prefixType)
+    val node = PtIdentifier(newName, type, position)
+    node.parent = parent
+    return node
+}
+
+
 class AsmGen6502Internal (
     val program: PtProgram,
     internal val symbolTable: SymbolTable,
@@ -40,12 +225,12 @@ class AsmGen6502Internal (
     private val allocator = VariableAllocator(symbolTable, options, errors)
     private val assemblyLines = mutableListOf<String>()
     private val breakpointLabels = mutableListOf<String>()
-    private val forloopsAsmGen = ForLoopsAsmGen(program, this, zeropage)
+    private val forloopsAsmGen = ForLoopsAsmGen(this, zeropage)
     private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
     private val functioncallAsmGen = FunctionCallAsmGen(program, this)
     private val programGen = ProgramAndVarsGen(program, options, errors, symbolTable, functioncallAsmGen, this, allocator, zeropage)
-    private val assignmentAsmGen = AssignmentAsmGen(program, symbolTable, this, allocator)
-    private val expressionsAsmGen = ExpressionsAsmGen(program, this, allocator)
+    private val anyExprGen = AnyExprAsmGen(this)
+    private val assignmentAsmGen = AssignmentAsmGen(program, this, anyExprGen, allocator)
     private val builtinFunctionsAsmGen = BuiltinFunctionsAsmGen(program, this, assignmentAsmGen)
 
     fun compileToAssembly(): IAssemblyProgram? {
@@ -77,8 +262,19 @@ class AsmGen6502Internal (
 
     internal fun isTargetCpu(cpu: CpuType) = options.compTarget.machine.cpu == cpu
 
+    private var lastSourceLineNumber: Int = -1
+
     internal fun outputSourceLine(node: PtNode) {
-        out(" ;\tsrc line: ${node.position.file}:${node.position.line}")
+        if(!options.includeSourcelines || node.position===Position.DUMMY || node.position.line==lastSourceLineNumber)
+            return
+
+        lastSourceLineNumber = node.position.line
+        val srcComment = "\t; source: ${node.position.file}:${node.position.line}"
+        val line = SourceLineCache.retrieveLine(node.position)
+        if(line==null)
+            out(srcComment, false)
+        else
+            out("$srcComment   $line", false)
     }
 
     internal fun out(str: String, splitlines: Boolean = true) {
@@ -124,6 +320,18 @@ class AsmGen6502Internal (
             name
     }
 
+    fun asmVariableName(st: StNode, scope: PtSub?): String {
+        val name = asmVariableName(st.scopedName)
+        if(scope==null)
+            return name
+        // remove the whole prefix and just make the variable name locally scoped (64tass scopes it to the proper .proc block)
+        val subName = scope.scopedName
+        return if (name.length>subName.length && name.startsWith(subName) && name[subName.length] == '.')
+            name.drop(subName.length+1)
+        else
+            name
+    }
+
     internal fun getTempVarName(dt: DataType): String {
         return when(dt) {
             DataType.UBYTE -> "cx16.r9L"
@@ -131,7 +339,7 @@ class AsmGen6502Internal (
             DataType.UWORD -> "cx16.r9"
             DataType.WORD -> "cx16.r9s"
             DataType.FLOAT -> "floats.floats_temp_var"
-            else -> throw AssemblyError("invalid dt $dt")
+            else -> throw AssemblyError("invalid dt")
         }
     }
 
@@ -231,32 +439,6 @@ class AsmGen6502Internal (
         return name2.replace("prog8_lib.P8ZP_SCRATCH_", "P8ZP_SCRATCH_")    // take care of the 'hooks' to the temp vars -> reference zp symbols directly
     }
 
-    internal fun saveRegisterLocal(register: CpuRegister, scope: IPtSubroutine) {
-        if (isTargetCpu(CpuType.CPU65c02)) {
-            // just use the cpu's stack for all registers, shorter code
-            when (register) {
-                CpuRegister.A -> out("  pha")
-                CpuRegister.X -> out("  phx")
-                CpuRegister.Y -> out("  phy")
-            }
-        } else {
-            when (register) {
-                CpuRegister.A -> {
-                    // just use the stack, only for A
-                    out("  pha")
-                }
-                CpuRegister.X -> {
-                    out("  stx  prog8_regsaveX")
-                    subroutineExtra(scope).usedRegsaveX = true
-                }
-                CpuRegister.Y -> {
-                    out("  sty  prog8_regsaveY")
-                    subroutineExtra(scope).usedRegsaveY = true
-                }
-            }
-        }
-    }
-
     internal fun saveRegisterStack(register: CpuRegister, keepA: Boolean) {
         when (register) {
             CpuRegister.A -> out("  pha")
@@ -281,24 +463,6 @@ class AsmGen6502Internal (
         }
     }
 
-    internal fun restoreRegisterLocal(register: CpuRegister) {
-        if (isTargetCpu(CpuType.CPU65c02)) {
-            when (register) {
-                // this just used the stack, for all registers. Shorter code.
-                CpuRegister.A -> out("  pla")
-                CpuRegister.X -> out("  plx")
-                CpuRegister.Y -> out("  ply")
-            }
-
-        } else {
-            when (register) {
-                CpuRegister.A -> out("  pla")   // this just used the stack but only for A
-                CpuRegister.X -> out("  ldx  prog8_regsaveX")
-                CpuRegister.Y -> out("  ldy  prog8_regsaveY")
-            }
-        }
-    }
-
     internal fun restoreRegisterStack(register: CpuRegister, keepA: Boolean) {
         when (register) {
             CpuRegister.A -> {
@@ -359,89 +523,48 @@ class AsmGen6502Internal (
         }
     }
 
-    internal fun loadScaledArrayIndexIntoRegister(
-        expr: PtArrayIndexer,
-        elementDt: DataType,
-        register: CpuRegister,
-        addOneExtra: Boolean = false
-    ) {
+    internal fun loadScaledArrayIndexIntoRegister(expr: PtArrayIndexer, register: CpuRegister) {
         val reg = register.toString().lowercase()
         val indexnum = expr.index.asConstInteger()
         if (indexnum != null) {
-            val indexValue = indexnum * options.compTarget.memorySize(elementDt) + if (addOneExtra) 1 else 0
+            val indexValue = if(expr.splitWords)
+                indexnum
+            else
+                indexnum * options.compTarget.memorySize(expr.type)
             out("  ld$reg  #$indexValue")
             return
         }
 
-        val indexVar = expr.index as? PtIdentifier
-            ?: throw AssemblyError("array indexer should have been replaced with a temp var @ ${expr.index.position}")
+        if(expr.splitWords) {
+            assignExpressionToRegister(expr.index, RegisterOrPair.fromCpuRegister(register), false)
+            return
+        }
 
-        val indexName = asmVariableName(indexVar)
-        if (addOneExtra) {
-            // add 1 to the result
-            when (elementDt) {
+        when (expr.type) {
             in ByteDatatypes -> {
-                    out("  ldy  $indexName |  iny")
-                    when (register) {
-                        CpuRegister.A -> out(" tya")
-                        CpuRegister.X -> out(" tyx")
-                        CpuRegister.Y -> {
-                        }
-                    }
+                assignExpressionToRegister(expr.index, RegisterOrPair.fromCpuRegister(register), false)
             }
             in WordDatatypes -> {
-                    out("  lda  $indexName |  sec |  rol  a")
+                assignExpressionToRegister(expr.index, RegisterOrPair.A, false)
+                out("  asl  a")
                 when (register) {
-                        CpuRegister.A -> {
-                        }
+                    CpuRegister.A -> {}
                     CpuRegister.X -> out(" tax")
                     CpuRegister.Y -> out(" tay")
                 }
             }
             DataType.FLOAT -> {
                 require(options.compTarget.memorySize(DataType.FLOAT) == 5) {"invalid float size ${expr.position}"}
-                    out(
-                        """
-                                lda  $indexName
-                                asl  a
-                                asl  a
-                                sec
-                                adc  $indexName"""
-                    )
-                    when (register) {
-                        CpuRegister.A -> {
-                        }
-                        CpuRegister.X -> out(" tax")
-                        CpuRegister.Y -> out(" tay")
-                    }
-                }
-                else -> throw AssemblyError("weird dt")
-            }
-        } else {
-            when (elementDt) {
-                in ByteDatatypes -> out("  ld$reg  $indexName")
-                in WordDatatypes -> {
-                    out("  lda  $indexName |  asl  a")
-                    when (register) {
-                        CpuRegister.A -> {
-                        }
-                        CpuRegister.X -> out(" tax")
-                        CpuRegister.Y -> out(" tay")
-                    }
-                }
-                DataType.FLOAT -> {
-                    require(options.compTarget.memorySize(DataType.FLOAT) == 5) {"invalid float size ${expr.position}"}
-                    out(
-                        """
-                                lda  $indexName
+                assignExpressionToRegister(expr.index, RegisterOrPair.A, false)
+                out("""
+                    sta  P8ZP_SCRATCH_REG
                     asl  a
                     asl  a
                     clc
-                                adc  $indexName"""
+                    adc  P8ZP_SCRATCH_REG"""
                 )
                 when (register) {
-                        CpuRegister.A -> {
-                        }
+                    CpuRegister.A -> {}
                     CpuRegister.X -> out(" tax")
                     CpuRegister.Y -> out(" tay")
                 }
@@ -449,24 +572,13 @@ class AsmGen6502Internal (
             else -> throw AssemblyError("weird dt")
         }
     }
-    }
 
-    @Deprecated("avoid calling this as it generates slow evalstack based code")
-    internal fun translateExpression(expression: PtExpression) =
-            expressionsAsmGen.translateExpression(expression)
-
-    internal fun translateBuiltinFunctionCallExpression(bfc: PtBuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?): DataType? =
-            builtinFunctionsAsmGen.translateFunctioncallExpression(bfc, resultToStack, resultRegister)
+    internal fun translateBuiltinFunctionCallExpression(bfc: PtBuiltinFunctionCall, resultRegister: RegisterOrPair?): DataType? =
+            builtinFunctionsAsmGen.translateFunctioncallExpression(bfc, resultRegister)
 
     internal fun translateFunctionCall(functionCallExpr: PtFunctionCall) =
             functioncallAsmGen.translateFunctionCall(functionCallExpr)
 
-    internal fun saveXbeforeCall(functionCall: PtFunctionCall)  =
-            functioncallAsmGen.saveXbeforeCall(functionCall)
-
-    internal fun restoreXafterCall(functionCall: PtFunctionCall) =
-            functioncallAsmGen.restoreXafterCall(functionCall)
-
     internal fun translateNormalAssignment(assign: AsmAssignment, scope: IPtSubroutine?) =
             assignmentAsmGen.translateNormalAssignment(assign, scope)
 
@@ -483,7 +595,7 @@ class AsmGen6502Internal (
         when(reg) {
             RegisterOrPair.A,
             RegisterOrPair.X,
-            RegisterOrPair.Y -> assignmentAsmGen.assignRegisterByte(target, reg.asCpuRegister(), target.datatype in SignedDatatypes)
+            RegisterOrPair.Y -> assignmentAsmGen.assignRegisterByte(target, reg.asCpuRegister(), target.datatype in SignedDatatypes, true)
             RegisterOrPair.AX,
             RegisterOrPair.AY,
             RegisterOrPair.XY,
@@ -495,9 +607,36 @@ class AsmGen6502Internal (
     }
 
     internal fun assignExpressionTo(value: PtExpression, target: AsmAssignTarget) {
-        // don't use translateExpression() to avoid evalstack
         when (target.datatype) {
             in ByteDatatypes -> {
+                if (value.asConstInteger()==0) {
+                    when(target.kind) {
+                        TargetStorageKind.VARIABLE -> {
+                            if (isTargetCpu(CpuType.CPU6502))
+                                out("lda  #0 |  sta  ${target.asmVarname}")
+                            else
+                                out("stz  ${target.asmVarname}")
+                        }
+                        TargetStorageKind.MEMORY -> {
+                            val address = target.memory!!.address.asConstInteger()
+                            if(address!=null) {
+                                if (isTargetCpu(CpuType.CPU6502))
+                                    out("lda  #0 |  sta  ${address.toHex()}")
+                                else
+                                    out("  stz  ${address.toHex()}")
+                                return
+                            }
+                        }
+                        TargetStorageKind.REGISTER -> {
+                            val zero = PtNumber(DataType.UBYTE, 0.0, value.position)
+                            zero.parent = value
+                            assignExpressionToRegister(zero, target.register!!, false)
+                            return
+                        }
+                        else -> { }
+                    }
+                }
+
                 assignExpressionToRegister(value, RegisterOrPair.A)
                 assignRegister(RegisterOrPair.A, target)
             }
@@ -546,7 +685,6 @@ class AsmGen6502Internal (
     private fun translate(stmt: PtIfElse) {
         val condition = stmt.condition as? PtBinaryExpression
         if(condition!=null) {
-            require(!options.useNewExprCode)
             requireComparisonExpression(condition)  // IfStatement: condition must be of form  'x <comparison> <value>'
             if (stmt.elseScope.children.isEmpty()) {
                 val jump = stmt.ifScope.children.singleOrNull()
@@ -578,7 +716,6 @@ class AsmGen6502Internal (
                 if (jump is PtJump) {
                     // jump somewhere if X!=0
                     val label = when {
-                        jump.generatedLabel!=null -> jump.generatedLabel!!
                         jump.identifier!=null -> asmSymbolName(jump.identifier!!)
                         jump.address!=null -> jump.address!!.toHex()
                         else -> throw AssemblyError("weird jump")
@@ -674,65 +811,48 @@ class AsmGen6502Internal (
     private fun repeatWordCount(count: Int, stmt: PtRepeatLoop) {
         require(count in 257..65535) { "invalid repeat count ${stmt.position}" }
         val repeatLabel = makeLabel("repeat")
-        if(isTargetCpu(CpuType.CPU65c02)) {
-            val counterVar = createRepeatCounterVar(DataType.UWORD, true, stmt)
+        val counterVar = createRepeatCounterVar(DataType.UWORD, isTargetCpu(CpuType.CPU65c02), stmt)
+        // the iny + double dec is microoptimization of the 16 bit loop
         out("""
-                lda  #<$count
             ldy  #>$count
-                sta  $counterVar
+            lda  #<$count
+            beq  +
+            iny
++           sta  $counterVar
             sty  $counterVar+1
 $repeatLabel""")
         translate(stmt.statements)
         out("""
-                lda  $counterVar
-                bne  +
+            dec  $counterVar
+            bne  $repeatLabel
             dec  $counterVar+1
-+               dec  $counterVar
-                lda  $counterVar
-                ora  $counterVar+1
             bne  $repeatLabel""")
-        } else {
-            val counterVar = createRepeatCounterVar(DataType.UWORD, false, stmt)
-            out("""
-                lda  #<$count
-                ldy  #>$count
-                sta  $counterVar
-                sty  $counterVar+1
-$repeatLabel""")
-            translate(stmt.statements)
-            out("""
-                lda  $counterVar
-                bne  +
-                dec  $counterVar+1
-+               dec  $counterVar
-                lda  $counterVar
-                ora  $counterVar+1
-                bne  $repeatLabel""")
-        }
     }
 
     private fun repeatWordCountInAY(endLabel: String, stmt: PtRepeatLoop) {
         // note: A/Y must have been loaded with the number of iterations!
-        // no need to explicitly test for 0 iterations as this is done in the countdown logic below
+        // the iny + double dec is microoptimization of the 16 bit loop
         val repeatLabel = makeLabel("repeat")
         val counterVar = createRepeatCounterVar(DataType.UWORD, false, stmt)
         out("""
-                sta  $counterVar
+            cmp  #0
+            beq  +
+            iny
++           sta  $counterVar
             sty  $counterVar+1
-$repeatLabel    lda  $counterVar
-                bne  +
-                lda  $counterVar+1
+            ora  $counterVar+1
             beq  $endLabel
-                lda  $counterVar
-                bne  +
-                dec  $counterVar+1
-+               dec  $counterVar
-""")
+$repeatLabel""")
         translate(stmt.statements)
-        jmp(repeatLabel)
+        out("""
+            dec  $counterVar
+            bne  $repeatLabel
+            dec  $counterVar+1
+            bne  $repeatLabel""")
         out(endLabel)
     }
 
+
     private fun repeatByteCount(count: Int, stmt: PtRepeatLoop) {
         require(count in 2..256) { "invalid repeat count ${stmt.position}" }
         val repeatLabel = makeLabel("repeat")
@@ -795,7 +915,7 @@ $repeatLabel    lda  $counterVar
             DataType.UBYTE, DataType.UWORD -> {
                 val result = zeropage.allocate(counterVar, dt, null, stmt.position, errors)
                 result.fold(
-                    success = { (address, _) -> asmInfo.extraVars.add(Triple(dt, counterVar, address)) },
+                    success = { (address, _, _) -> asmInfo.extraVars.add(Triple(dt, counterVar, address)) },
                     failure = { asmInfo.extraVars.add(Triple(dt, counterVar, null)) }  // allocate normally
                 )
                 return counterVar
@@ -895,7 +1015,6 @@ $repeatLabel    lda  $counterVar
 
     private fun getJumpTarget(jump: PtJump): Pair<String, Boolean> {
         val ident = jump.identifier
-        val label = jump.generatedLabel
         val addr = jump.address
         return when {
             ident!=null -> {
@@ -906,7 +1025,6 @@ $repeatLabel    lda  $counterVar
                 else
                     Pair(asmSymbolName(ident), false)
             }
-            label!=null -> Pair(label, false)
             addr!=null -> Pair(addr.toHex(), false)
             else -> Pair("????", false)
         }
@@ -935,6 +1053,9 @@ $repeatLabel    lda  $counterVar
     }
 
     private fun translate(asm: PtInlineAssembly) {
+        if(asm.isIR)
+            throw AssemblyError("%asm containing IR code cannot be translated to 6502 assembly")
+        else
             assemblyLines.add(asm.assembly.trimEnd().trimStart('\r', '\n'))
     }
 
@@ -957,6 +1078,15 @@ $repeatLabel    lda  $counterVar
         val label = "_prog8_breakpoint_${breakpointLabels.size+1}"
         breakpointLabels.add(label)
         out(label)
+        if(options.breakpointCpuInstruction) {
+            val instruction =
+                when(options.compTarget.machine.cpu) {
+                    CpuType.CPU6502 -> "brk"
+                    CpuType.CPU65c02 -> "stp"
+                    else -> throw AssemblyError("invalid cpu type")
+                }
+            out("  $instruction")
+        }
     }
 
     internal fun signExtendAYlsb(valueDt: DataType) {
@@ -974,20 +1104,6 @@ $repeatLabel    lda  $counterVar
         }
     }
 
-    internal fun signExtendStackLsb(valueDt: DataType) {
-        // sign extend signed byte on stack to signed word on stack
-        when(valueDt) {
-            DataType.UBYTE -> {
-                if(isTargetCpu(CpuType.CPU65c02))
-                    out("  stz  P8ESTACK_HI+1,x")
-                else
-                    out("  lda  #0 |  sta  P8ESTACK_HI+1,x")
-            }
-            DataType.BYTE -> out("  jsr  prog8_lib.sign_extend_stack_byte")
-            else -> throw AssemblyError("need byte type")
-        }
-    }
-
     internal fun signExtendVariableLsb(asmvar: String, valueDt: DataType) {
         // sign extend signed byte in a var to a full word in that variable
         when(valueDt) {
@@ -1023,18 +1139,10 @@ $repeatLabel    lda  $counterVar
     }
 
     internal fun pointerViaIndexRegisterPossible(pointerOffsetExpr: PtExpression): Pair<PtExpression, PtExpression>? {
-        val left: PtExpression
-        val right: PtExpression
-        val operator: String
-
-        if (pointerOffsetExpr is PtBinaryExpression) {
-            require(!options.useNewExprCode)
-            operator = pointerOffsetExpr.operator
-            left = pointerOffsetExpr.left
-            right = pointerOffsetExpr.right
-        }
-        else return null
-
+        if (pointerOffsetExpr !is PtBinaryExpression) return null
+        val operator = pointerOffsetExpr.operator
+        val left = pointerOffsetExpr.left
+        val right = pointerOffsetExpr.right
         if (operator != "+") return null
         val leftDt = left.type
         val rightDt = right.type
@@ -1146,10 +1254,7 @@ $repeatLabel    lda  $counterVar
     }
 
     internal fun findSubroutineParameter(name: String, asmgen: AsmGen6502Internal): PtSubroutineParameter? {
-        val stScope = asmgen.symbolTable.lookup(name)
-        require(stScope!=null) {
-            "invalid name lookup $name"
-        }
+        val stScope = asmgen.symbolTable.lookup(name) ?: return null
         val node = stScope.astNode
         if(node is PtSubroutineParameter)
             return node
@@ -1169,7 +1274,6 @@ $repeatLabel    lda  $counterVar
         val rightConstVal = right as? PtNumber
 
         val label = when {
-            jump.generatedLabel!=null -> jump.generatedLabel!!
             jump.identifier!=null -> asmSymbolName(jump.identifier!!)
             jump.address!=null -> jump.address!!.toHex()
             else -> throw AssemblyError("weird jump")
@@ -1627,7 +1731,7 @@ $repeatLabel    lda  $counterVar
                 }
                 else if (left is PtMemoryByte) {
                     return if(rightConstVal.number.toInt()!=0) {
-                        translateDirectMemReadExpressionToRegAorStack(left, false)
+                        translateDirectMemReadExpressionToRegA(left)
                         code("#${rightConstVal.number.toInt()}")
                     }
                     else
@@ -1774,7 +1878,7 @@ $repeatLabel    lda  $counterVar
                         out("  beq $jumpIfFalseLabel")
                 }
                 else if (left is PtMemoryByte) {
-                    translateDirectMemReadExpressionToRegAorStack(left, false)
+                    translateDirectMemReadExpressionToRegA(left)
                     return if(rightConstVal.number.toInt()!=0)
                         code("#${rightConstVal.number.toInt()}")
                     else
@@ -1935,7 +2039,7 @@ $repeatLabel    lda  $counterVar
                         out("  bne  $jumpIfFalseLabel")
                 }
                 else if (left is PtMemoryByte) {
-                    translateDirectMemReadExpressionToRegAorStack(left, false)
+                    translateDirectMemReadExpressionToRegA(left)
                     return if(rightConstVal.number.toInt()!=0)
                         code("#${rightConstVal.number.toInt()}")
                     else
@@ -2099,7 +2203,7 @@ $repeatLabel    lda  $counterVar
                 }
                 else if (left is PtMemoryByte) {
                     if(rightConstVal.number.toInt()!=0) {
-                        translateDirectMemReadExpressionToRegAorStack(left, false)
+                        translateDirectMemReadExpressionToRegA(left)
                         code("#${rightConstVal.number.toInt()}")
                     }
                     return
@@ -2262,7 +2366,7 @@ $repeatLabel    lda  $counterVar
                         out("  bne  $jumpIfFalseLabel")
                 }
                 else if (left is PtMemoryByte) {
-                    translateDirectMemReadExpressionToRegAorStack(left, false)
+                    translateDirectMemReadExpressionToRegA(left)
                     return if(rightConstVal.number.toInt()!=0)
                         code("#${rightConstVal.number.toInt()}")
                     else
@@ -2308,7 +2412,7 @@ $repeatLabel    lda  $counterVar
                         out("  beq  $jumpIfFalseLabel")
                 }
                 else if (left is PtMemoryByte) {
-                    translateDirectMemReadExpressionToRegAorStack(left, false)
+                    translateDirectMemReadExpressionToRegA(left)
                     return if(rightConstVal.number.toInt()!=0)
                         code("#${rightConstVal.number.toInt()}")
                     else
@@ -2373,8 +2477,7 @@ $repeatLabel    lda  $counterVar
                     cmp  #<$number
                     bne  $jumpIfFalseLabel
                     cpy  #>$number
-                    bne  $jumpIfFalseLabel
-                    """)
+                    bne  $jumpIfFalseLabel""")
             }
             is PtIdentifier -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
@@ -2382,18 +2485,21 @@ $repeatLabel    lda  $counterVar
                     cmp  ${asmVariableName(right)}
                     bne  $jumpIfFalseLabel
                     cpy  ${asmVariableName(right)}+1
-                    bne  $jumpIfFalseLabel
-                    """)
+                    bne  $jumpIfFalseLabel""")
             }
             is PtAddressOf -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
                 val name = asmSymbolName(right.identifier)
+                if(right.isFromArrayElement) {
+                    TODO("address-of array element $name at ${right.position}")
+                    // assignmentAsmGen.assignAddressOf(target, name, right.arrayIndexExpr)
+                } else {
                     out("""
                         cmp  #<$name
                         bne  $jumpIfFalseLabel
                         cpy  #>$name
-                    bne  $jumpIfFalseLabel
-                    """)
+                        bne  $jumpIfFalseLabel""")
+                }
             }
             else -> {
                 if(left.isSimple()) {
@@ -2474,12 +2580,16 @@ $repeatLabel    lda  $counterVar
             is PtAddressOf -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
                 val name = asmSymbolName(right.identifier)
+                if(right.isFromArrayElement) {
+                    TODO("address-of array element $name at ${right.position}")
+                } else {
                     out("""
                         cmp  #<$name
                         bne  +
                         cpy  #>$name
                         beq  $jumpIfFalseLabel
-+""")
+    +""")
+                }
             }
             else -> {
                 if(left.isSimple()) {
@@ -2764,45 +2874,29 @@ $repeatLabel    lda  $counterVar
 +""")
     }
 
-    internal fun translateDirectMemReadExpressionToRegAorStack(expr: PtMemoryByte, pushResultOnEstack: Boolean) {
+    internal fun translateDirectMemReadExpressionToRegA(expr: PtMemoryByte) {
 
         fun assignViaExprEval() {
             assignExpressionToVariable(expr.address, "P8ZP_SCRATCH_W2", DataType.UWORD)
             if (isTargetCpu(CpuType.CPU65c02)) {
-                if (pushResultOnEstack) {
-                    out("  lda  (P8ZP_SCRATCH_W2) |  dex |  sta  P8ESTACK_LO+1,x")
-                } else {
                 out("  lda  (P8ZP_SCRATCH_W2)")
-                }
-            } else {
-                if (pushResultOnEstack) {
-                    out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y |  dex |  sta  P8ESTACK_LO+1,x")
             } else {
                 out("  ldy  #0 |  lda  (P8ZP_SCRATCH_W2),y")
             }
         }
-        }
 
         when(expr.address) {
             is PtNumber -> {
                 val address = (expr.address as PtNumber).number.toInt()
                 out("  lda  ${address.toHex()}")
-                if(pushResultOnEstack)
-                    out("  sta  P8ESTACK_LO,x |  dex")
             }
             is PtIdentifier -> {
                 // the identifier is a pointer variable, so read the value from the address in it
                 loadByteFromPointerIntoA(expr.address as PtIdentifier)
-                if(pushResultOnEstack)
-                    out("  sta  P8ESTACK_LO,x |  dex")
             }
             is PtBinaryExpression -> {
-                require(!options.useNewExprCode)
                 val addrExpr = expr.address as PtBinaryExpression
-                if(tryOptimizedPointerAccessWithA(addrExpr, addrExpr.operator, false)) {
-                    if(pushResultOnEstack)
-                        out("  sta  P8ESTACK_LO,x |  dex")
-                } else {
+                if(!tryOptimizedPointerAccessWithA(addrExpr, addrExpr.operator, false)) {
                     assignViaExprEval()
                 }
             }
@@ -2821,9 +2915,13 @@ $repeatLabel    lda  $counterVar
             is PtAddressOf -> {
                 assignExpressionToRegister(right, RegisterOrPair.AY)
                 val name = asmSymbolName(left.identifier)
+                if(left.isFromArrayElement) {
+                    TODO("address-of array element $name at ${left.position}")
+                } else {
                     code("#>$name", "#<$name")
                     return true
                 }
+            }
             is PtIdentifier -> {
                 assignExpressionToRegister(right, RegisterOrPair.AY)
                 val varname = asmVariableName(left)
@@ -2870,9 +2968,13 @@ $repeatLabel    lda  $counterVar
             is PtAddressOf -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
                 val name = asmSymbolName(right.identifier)
+                if(right.isFromArrayElement) {
+                    TODO("address-of array element $name at ${right.position}")
+                } else {
                     code("#>$name", "#<$name")
                     return true
                 }
+            }
             is PtIdentifier -> {
                 assignExpressionToRegister(left, RegisterOrPair.AY)
                 val varname = asmVariableName(right)
@@ -2955,30 +3057,16 @@ $repeatLabel    lda  $counterVar
         }
     }
 
-    internal fun popCpuStack(dt: DataType, target: IPtVariable, scope: IPtSubroutine?) {
-        // note: because A is pushed first so popped last, saving A is often not required here.
-        val targetAsmSub = (target as PtNode).definingAsmSub()
-        if(targetAsmSub != null) {
-            val parameter = targetAsmSub.parameters.first { it.second.name==target.name }
-            popCpuStack(targetAsmSub, parameter.second, parameter.first)
-            return
-        }
-        val scopedName = when(target) {
-            is PtConstant -> target.scopedName
-            is PtMemMapped -> target.scopedName
-            is PtVariable -> target.scopedName
-            else -> throw AssemblyError("weird target var")
-        }
-        val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, this, target.type, scope, target.position, variableAsmName = asmVariableName(scopedName))
+    internal fun popCpuStack(dt: DataType) {
         if (dt in ByteDatatypes) {
             out("  pla")
-            assignRegister(RegisterOrPair.A, tgt)
-        } else {
+        } else if (dt in WordDatatypes) {
             if (isTargetCpu(CpuType.CPU65c02))
                 out("  ply |  pla")
             else
                 out("  pla |  tay |  pla")
-            assignRegister(RegisterOrPair.AY, tgt)
+        } else {
+            throw AssemblyError("can't pop type $dt")
         }
     }
 
@@ -2998,6 +3086,18 @@ $repeatLabel    lda  $counterVar
         }
     }
 
+    internal fun pushFAC1() {
+        out("  jsr  floats.pushFAC1")
+    }
+
+    internal fun popFAC1() {
+        out("  clc |  jsr  floats.popFAC")
+    }
+
+    internal fun popFAC2() {
+        out("  sec |  jsr  floats.popFAC")
+    }
+
     internal fun needAsaveForExpr(arg: PtExpression): Boolean =
         arg !is PtNumber && arg !is PtIdentifier && (arg !is PtMemoryByte || !arg.isSimple())
 
@@ -3018,9 +3118,20 @@ $repeatLabel    lda  $counterVar
 
     internal fun makeLabel(postfix: String): String {
         generatedLabelSequenceNumber++
-        return "prog8_label_asm_${generatedLabelSequenceNumber}_$postfix"
+        return "label_asm_${generatedLabelSequenceNumber}_$postfix"
     }
 
+    fun assignConstFloatToPointerAY(number: PtNumber) {
+        val floatConst = allocator.getFloatAsmConst(number.number)
+        out("""
+            pha
+            lda  #<$floatConst
+            sta  P8ZP_SCRATCH_W1
+            lda  #>$floatConst
+            sta  P8ZP_SCRATCH_W1+1
+            pla
+            jsr  floats.copy_float""")
+    }
 }
 
 /**
@@ -3030,9 +3141,6 @@ $repeatLabel    lda  $counterVar
  * it's more consistent to only define these attributes on a Subroutine node.
  */
 internal class SubroutineExtraAsmInfo {
-    var usedRegsaveA = false
-    var usedRegsaveX = false
-    var usedRegsaveY = false
     var usedFloatEvalResultVar1 = false
     var usedFloatEvalResultVar2 = false
 

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

@@ -15,21 +15,7 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
 
     var linesByFour = getLinesBy(lines, 4)
 
-    var mods = optimizeUselessStackByteWrites(linesByFour)
-    if(mods.isNotEmpty()) {
-        apply(mods, lines)
-        linesByFour = getLinesBy(lines, 4)
-        numberOfOptimizations++
-    }
-
-    mods = optimizeIncDec(linesByFour)
-    if(mods.isNotEmpty()) {
-        apply(mods, lines)
-        linesByFour = getLinesBy(lines, 4)
-        numberOfOptimizations++
-    }
-
-    mods = optimizeCmpSequence(linesByFour)
+    var mods = optimizeIncDec(linesByFour)
     if(mods.isNotEmpty()) {
         apply(mods, lines)
         linesByFour = getLinesBy(lines, 4)
@@ -43,7 +29,21 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
         numberOfOptimizations++
     }
 
-    mods= optimizeJsrRtsAndOtherCombinations(linesByFour)
+    mods = optimizeJsrRtsAndOtherCombinations(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
+        linesByFour = getLinesBy(lines, 4)
+        numberOfOptimizations++
+    }
+
+    mods = optimizeUselessPushPopStack(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
+        linesByFour = getLinesBy(lines, 4)
+        numberOfOptimizations++
+    }
+
+    mods = optimizeUnneededTempvarInAdd(linesByFour)
     if(mods.isNotEmpty()) {
         apply(mods, lines)
         linesByFour = getLinesBy(lines, 4)
@@ -90,44 +90,6 @@ private fun getLinesBy(lines: MutableList<String>, windowSize: Int) =
 // all lines (that aren't empty or comments) in sliding windows of certain size
         lines.withIndex().filter { it.value.isNotBlank() && !it.value.trimStart().startsWith(';') }.windowed(windowSize, partialWindows = false)
 
-private fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
-    // when statement (on bytes) generates a sequence of:
-    //	 lda  $ce01,x
-    //	 cmp  #$20
-    //	 beq  check_prog8_s72choice_32
-    //	 lda  $ce01,x
-    //	 cmp  #$21
-    //	 beq  check_prog8_s73choice_33
-    // the repeated lda can be removed
-    val mods = mutableListOf<Modification>()
-    for(lines in linesByFour) {
-        if(lines[0].value.trim()=="lda  P8ESTACK_LO+1,x" &&
-                lines[1].value.trim().startsWith("cmp ") &&
-                lines[2].value.trim().startsWith("beq ") &&
-                lines[3].value.trim()=="lda  P8ESTACK_LO+1,x") {
-            mods.add(Modification(lines[3].index, true, null)) // remove the second lda
-        }
-    }
-    return mods
-}
-
-private fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
-    // sta on stack, dex, inx, lda from stack -> eliminate this useless stack byte write
-    // this is a lot harder for word values because the instruction sequence varies.
-    val mods = mutableListOf<Modification>()
-    for(lines in linesByFour) {
-        if(lines[0].value.trim()=="sta  P8ESTACK_LO,x" &&
-                lines[1].value.trim()=="dex" &&
-                lines[2].value.trim()=="inx" &&
-                lines[3].value.trim()=="lda  P8ESTACK_LO,x") {
-            mods.add(Modification(lines[1].index, true, null))
-            mods.add(Modification(lines[2].index, true, null))
-            mods.add(Modification(lines[3].index, true, null))
-        }
-    }
-    return mods
-}
-
 private fun optimizeSameAssignments(
     linesByFourteen: List<List<IndexedValue<String>>>,
     machine: IMachineDefinition,
@@ -419,15 +381,9 @@ private fun optimizeStoreLoadSame(
         } else if(first=="phx" && second=="pla") {
             mods.add(Modification(lines[1].index, true, null))
             mods.add(Modification(lines[2].index, false, "  txa"))
-        } else if(first=="phx" && second=="ply") {
-            mods.add(Modification(lines[1].index, true, null))
-            mods.add(Modification(lines[2].index, false, "  txy"))
         } else if(first=="phy" && second=="pla") {
             mods.add(Modification(lines[1].index, true, null))
             mods.add(Modification(lines[2].index, false, "  tya"))
-        } else if(first=="phy" && second=="plx") {
-            mods.add(Modification(lines[1].index, true, null))
-            mods.add(Modification(lines[2].index, false, "  tyx"))
         }
     }
     return mods
@@ -517,3 +473,63 @@ private fun optimizeJsrRtsAndOtherCombinations(linesByFour: List<List<IndexedVal
     }
     return mods
 }
+
+private fun optimizeUselessPushPopStack(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
+    val mods = mutableListOf<Modification>()
+
+    fun optimize(register: Char, lines: List<IndexedValue<String>>) {
+        if(lines[0].value.trimStart().startsWith("ph$register")) {
+            if(lines[2].value.trimStart().startsWith("pl$register")) {
+                val second = lines[1].value.trimStart().take(6).lowercase()
+                if(register!in second
+                    && !second.startsWith("jsr")
+                    && !second.startsWith("pl")
+                    && !second.startsWith("ph")) {
+                    mods.add(Modification(lines[0].index, true, null))
+                    mods.add(Modification(lines[2].index, true, null))
+                }
+            }
+            else if (lines[3].value.trimStart().startsWith("pl$register")) {
+                val second = lines[1].value.trimStart().take(6).lowercase()
+                val third = lines[2].value.trimStart().take(6).lowercase()
+                if(register !in second && register !in third
+                    && !second.startsWith("jsr") && !third.startsWith("jsr")
+                    && !second.startsWith("pl") && !third.startsWith("pl")
+                    && !second.startsWith("ph") && !third.startsWith("ph")) {
+                    mods.add(Modification(lines[0].index, true, null))
+                    mods.add(Modification(lines[3].index, true, null))
+                }
+            }
+        }
+    }
+
+    for (lines in linesByFour) {
+        optimize('a', lines)
+        optimize('x', lines)
+        optimize('y', lines)
+    }
+    return mods
+}
+
+private fun optimizeUnneededTempvarInAdd(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
+    // sequence:  sta  P8ZP_SCRATCH_XX  / lda  something / clc / adc  P8ZP_SCRATCH_XX
+    // this can be performed without the scratch variable:  clc  /  adc  something
+    val mods = mutableListOf<Modification>()
+
+    for(lines in linesByFour) {
+        val first = lines[0].value.trimStart()
+        val second = lines[1].value.trimStart()
+        val third = lines[2].value.trimStart()
+        val fourth = lines[3].value.trimStart()
+        if(first.startsWith("sta  P8ZP_SCRATCH_") && second.startsWith("lda") && third.startsWith("clc") && fourth.startsWith("adc  P8ZP_SCRATCH_") ) {
+            if(fourth.substring(4)==first.substring(4)) {
+                mods.add(Modification(lines[0].index, false, "    clc"))
+                mods.add(Modification(lines[1].index, false, "    adc  ${second.substring(3).trimStart()}"))
+                mods.add(Modification(lines[2].index, true, null))
+                mods.add(Modification(lines[3].index, true, null))
+            }
+        }
+    }
+
+    return mods
+}

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

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

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

@@ -1,14 +1,8 @@
 package prog8.codegen.cpu6502
 
-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
-import kotlin.io.path.isRegularFile
 
 
 internal class AssemblyProgram(
@@ -28,15 +22,20 @@ internal class AssemblyProgram(
         val assemblerCommand: List<String>
 
         when (compTarget.name) {
-            in setOf("c64", "c128", "cx16") -> {
+            in setOf("c64", "c128", "cx16", "pet32") -> {
                 // CBM machines .prg generation.
 
                 // add "-Wlong-branch"  to see warnings about conversion of branch instructions to jumps (default = do this silently)
                 val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
-                    "-Wall", "-Wno-strict-bool", "-Wno-shadow", // "-Werror",
+                    "-Wall", // "-Wno-strict-bool", "-Werror",
                     "--dump-labels", "--vice-labels", "--labels=$viceMonListFile", "--no-monitor"
                 )
 
+                if(options.warnSymbolShadowing)
+                    command.add("-Wshadow")
+                else
+                    command.add("-Wno-shadow")
+
                 if(options.asmQuiet)
                     command.add("--quiet")
 
@@ -65,10 +64,15 @@ internal class AssemblyProgram(
 
                 // TODO are these options okay for atari?
                 val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
-                    "-Wall", "-Wno-strict-bool", "-Wno-shadow", // "-Werror",
+                    "-Wall", // "-Werror", "-Wno-strict-bool"
                     "--no-monitor"
                 )
 
+                if(options.warnSymbolShadowing)
+                    command.add("-Wshadow")
+                else
+                    command.add("-Wno-shadow")
+
                 if(options.asmQuiet)
                     command.add("--quiet")
 
@@ -130,18 +134,3 @@ internal class AssemblyProgram(
         viceMonListFile.toFile().appendText(breakpoints.joinToString("\n") + "\n")
     }
 }
-
-
-internal fun loadAsmIncludeFile(filename: String, source: SourceCode): Result<String, NoSuchFileException> {
-    return if (filename.startsWith(SourceCode.libraryFilePrefix)) {
-        return com.github.michaelbull.result.runCatching {
-            SourceCode.Resource("/prog8lib/${filename.substring(SourceCode.libraryFilePrefix.length)}").text
-        }.mapError { NoSuchFileException(File(filename)) }
-    } else {
-        val sib = Path(source.origin).resolveSibling(filename)
-        if (sib.isRegularFile())
-            Ok(SourceCode.File(sib).text)
-        else
-            Ok(SourceCode.File(Path(filename)).text)
-    }
-}

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

@@ -1,929 +0,0 @@
-package prog8.codegen.cpu6502
-
-import prog8.code.ast.*
-import prog8.code.core.*
-import kotlin.math.absoluteValue
-
-internal class ExpressionsAsmGen(private val program: PtProgram,
-                                 private val asmgen: AsmGen6502Internal,
-                                 private val allocator: VariableAllocator) {
-
-    @Deprecated("avoid calling this as it generates slow evalstack based code")
-    internal fun translateExpression(expression: PtExpression) {
-        if (this.asmgen.options.slowCodegenWarnings) {
-            asmgen.errors.warn("slow stack evaluation used for expression", expression.position)
-        }
-        translateExpressionInternal(expression)
-    }
-
-
-    // the rest of the methods are all PRIVATE
-
-
-    private fun translateExpressionInternal(expression: PtExpression) {
-
-        when(expression) {
-            is PtPrefix -> translateExpression(expression)
-            is PtBinaryExpression -> translateExpression(expression)
-            is PtArrayIndexer -> translateExpression(expression)
-            is PtTypeCast -> translateExpression(expression)
-            is PtAddressOf -> translateExpression(expression)
-            is PtMemoryByte -> asmgen.translateDirectMemReadExpressionToRegAorStack(expression, true)
-            is PtNumber -> translateExpression(expression)
-            is PtIdentifier -> translateExpression(expression)
-            is PtFunctionCall -> translateFunctionCallResultOntoStack(expression)
-            is PtBuiltinFunctionCall -> asmgen.translateBuiltinFunctionCallExpression(expression, true, null)
-            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
-
-        val symbol = asmgen.symbolTable.lookup(call.name)
-        val sub = symbol!!.astNode as IPtSubroutine
-        asmgen.saveXbeforeCall(call)
-        asmgen.translateFunctionCall(call)
-        if(sub.regXasResult()) {
-            // store the return value in X somewhere that we can access again below
-            asmgen.out("  stx  P8ZP_SCRATCH_REG")
-        }
-        asmgen.restoreXafterCall(call)
-
-        val returns: List<Pair<RegisterOrStatusflag, DataType>> = sub.returnsWhatWhere()
-        for ((reg, _) in returns) {
-            // result value is in cpu or status registers, put it on the stack instead (as we're evaluating an expression tree)
-            if (reg.registerOrPair != null) {
-                when (reg.registerOrPair!!) {
-                    RegisterOrPair.A -> asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-                    RegisterOrPair.Y -> asmgen.out("  tya |  sta  P8ESTACK_LO,x |  dex")
-                    RegisterOrPair.AY -> asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
-                    RegisterOrPair.X -> asmgen.out("  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_LO,x |  dex")
-                    RegisterOrPair.AX -> asmgen.out("  sta  P8ESTACK_LO,x |  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_HI,x |  dex")
-                    RegisterOrPair.XY -> asmgen.out("  tya |  sta  P8ESTACK_HI,x |  lda  P8ZP_SCRATCH_REG |  sta  P8ESTACK_LO,x |  dex")
-                    RegisterOrPair.FAC1 -> asmgen.out("  jsr  floats.push_fac1")
-                    RegisterOrPair.FAC2 -> asmgen.out("  jsr  floats.push_fac2")
-                    RegisterOrPair.R0,
-                    RegisterOrPair.R1,
-                    RegisterOrPair.R2,
-                    RegisterOrPair.R3,
-                    RegisterOrPair.R4,
-                    RegisterOrPair.R5,
-                    RegisterOrPair.R6,
-                    RegisterOrPair.R7,
-                    RegisterOrPair.R8,
-                    RegisterOrPair.R9,
-                    RegisterOrPair.R10,
-                    RegisterOrPair.R11,
-                    RegisterOrPair.R12,
-                    RegisterOrPair.R13,
-                    RegisterOrPair.R14,
-                    RegisterOrPair.R15 -> {
-                        asmgen.out(
-                            """
-                            lda  cx16.${reg.registerOrPair.toString().lowercase()}
-                            sta  P8ESTACK_LO,x
-                            lda  cx16.${reg.registerOrPair.toString().lowercase()}+1
-                            sta  P8ESTACK_HI,x
-                            dex
-                        """)
-                    }
-                }
-            } else when(reg.statusflag) {
-                Statusflag.Pc -> {
-                    asmgen.out("""
-                        lda  #0
-                        rol  a
-                        sta  P8ESTACK_LO,x
-                        dex""")
-                }
-                Statusflag.Pz -> {
-                    asmgen.out("""
-                        beq  +
-                        lda  #0
-                        beq  ++
-+                           lda  #1
-+                           sta  P8ESTACK_LO,x
-                        dex""")
-                }
-                Statusflag.Pv -> {
-                    asmgen.out("""
-                        bvs  +
-                        lda  #0
-                        beq  ++
-+                           lda  #1
-+                           sta  P8ESTACK_LO,x
-                        dex""")
-                }
-                Statusflag.Pn -> {
-                    asmgen.out("""
-                        bmi  +
-                        lda  #0
-                        beq  ++
-+                           lda  #1
-+                           sta  P8ESTACK_LO,x
-                        dex""")
-                }
-                null -> {}
-            }
-        }
-    }
-
-    private fun translateExpression(typecast: PtTypeCast) {
-        translateExpressionInternal(typecast.value)
-        when(typecast.value.type) {
-            DataType.UBYTE, DataType.BOOL -> {
-                when(typecast.type) {
-                    DataType.UBYTE, DataType.BYTE -> {}
-                    DataType.UWORD, DataType.WORD -> {
-                        if(asmgen.isTargetCpu(CpuType.CPU65c02))
-                            asmgen.out("  stz  P8ESTACK_HI+1,x")
-                        else
-                            asmgen.out("  lda  #0  |  sta  P8ESTACK_HI+1,x")
-                    }
-                    DataType.FLOAT -> asmgen.out(" jsr  floats.stack_ub2float")
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.BYTE -> {
-                when(typecast.type) {
-                    DataType.UBYTE, DataType.BYTE -> {}
-                    DataType.UWORD, DataType.WORD -> asmgen.signExtendStackLsb(DataType.BYTE)
-                    DataType.FLOAT -> asmgen.out(" jsr  floats.stack_b2float")
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.UWORD -> {
-                when(typecast.type) {
-                    DataType.BYTE, DataType.UBYTE -> {}
-                    DataType.WORD, DataType.UWORD -> {}
-                    DataType.FLOAT -> asmgen.out(" jsr  floats.stack_uw2float")
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.WORD -> {
-                when(typecast.type) {
-                    DataType.BYTE, DataType.UBYTE -> {}
-                    DataType.WORD, DataType.UWORD -> {}
-                    DataType.FLOAT -> asmgen.out(" jsr  floats.stack_w2float")
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.FLOAT -> {
-                when(typecast.type) {
-                    DataType.UBYTE -> asmgen.out(" jsr  floats.stack_float2uw")
-                    DataType.BYTE -> asmgen.out(" jsr  floats.stack_float2w")
-                    DataType.UWORD -> asmgen.out(" jsr  floats.stack_float2uw")
-                    DataType.WORD -> asmgen.out(" jsr  floats.stack_float2w")
-                    DataType.FLOAT -> {}
-                    in PassByReferenceDatatypes -> throw AssemblyError("cannot cast to a pass-by-reference datatype")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            DataType.STR -> {
-                if (typecast.type != DataType.UWORD && typecast.type == DataType.STR)
-                    throw AssemblyError("cannot typecast a string into another incompatitble type")
-            }
-            in PassByReferenceDatatypes -> throw AssemblyError("cannot cast pass-by-reference value into another type")
-            else -> throw AssemblyError("weird type")
-        }
-    }
-
-    private fun translateExpression(expr: PtAddressOf) {
-        val name = asmgen.asmVariableName(expr.identifier)
-        asmgen.out("  lda  #<$name |  sta  P8ESTACK_LO,x |  lda  #>$name  |  sta  P8ESTACK_HI,x  | dex")
-    }
-
-    private fun translateExpression(expr: PtNumber) {
-        when(expr.type) {
-            DataType.UBYTE, DataType.BYTE -> asmgen.out(" lda  #${expr.number.toHex()}  | sta  P8ESTACK_LO,x  | dex")
-            DataType.UWORD, DataType.WORD -> asmgen.out("""
-                lda  #<${expr.number.toHex()}
-                sta  P8ESTACK_LO,x
-                lda  #>${expr.number.toHex()}
-                sta  P8ESTACK_HI,x
-                dex
-            """)
-            DataType.FLOAT -> {
-                val floatConst = allocator.getFloatAsmConst(expr.number)
-                asmgen.out(" lda  #<$floatConst |  ldy  #>$floatConst |  jsr  floats.push_float")
-            }
-            else -> throw AssemblyError("weird type")
-        }
-    }
-
-    private fun translateExpression(expr: PtIdentifier) {
-        val varname = asmgen.asmVariableName(expr)
-        when(expr.type) {
-            DataType.UBYTE, DataType.BYTE -> {
-                asmgen.out("  lda  $varname  |  sta  P8ESTACK_LO,x  |  dex")
-            }
-            DataType.UWORD, DataType.WORD -> {
-                asmgen.out("  lda  $varname  |  sta  P8ESTACK_LO,x  |  lda  $varname+1 |  sta  P8ESTACK_HI,x |  dex")
-            }
-            DataType.FLOAT -> {
-                asmgen.out(" lda  #<$varname |  ldy  #>$varname|  jsr  floats.push_float")
-            }
-            in IterableDatatypes -> {
-                asmgen.out("  lda  #<$varname  |  sta  P8ESTACK_LO,x  |  lda  #>$varname |  sta  P8ESTACK_HI,x |  dex")
-            }
-            else -> throw AssemblyError("stack push weird variable type $expr")
-        }
-    }
-
-    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
-
-        // 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 = left.asConstInteger()
-                    val rightVal = right.asConstInteger()
-                    if (leftVal!=null && leftVal in -4..4) {
-                        translateExpressionInternal(right)
-                        if(rightDt in ByteDatatypes) {
-                            val incdec = if(leftVal<0) "dec" else "inc"
-                            repeat(leftVal.absoluteValue) {
-                                asmgen.out("  $incdec  P8ESTACK_LO+1,x")
-                            }
-                        } else {
-                            // word
-                            if(leftVal<0) {
-                                repeat(leftVal.absoluteValue) {
-                                    asmgen.out("""
-                                        lda  P8ESTACK_LO+1,x
-                                        bne  +
-                                        dec  P8ESTACK_HI+1,x
-+                                       dec  P8ESTACK_LO+1,x""")
-                                }
-                            } else {
-                                repeat(leftVal) {
-                                    asmgen.out("""
-                                        inc  P8ESTACK_LO+1,x
-                                        bne  +
-                                        inc  P8ESTACK_HI+1,x
-+""")
-                                }
-                            }
-                        }
-                        return true
-                    }
-                    else if (rightVal!=null && rightVal in -4..4)
-                    {
-                        translateExpressionInternal(left)
-                        if(leftDt in ByteDatatypes) {
-                            val incdec = if(rightVal<0) "dec" else "inc"
-                            repeat(rightVal.absoluteValue) {
-                                asmgen.out("  $incdec  P8ESTACK_LO+1,x")
-                            }
-                        } else {
-                            // word
-                            if(rightVal<0) {
-                                repeat(rightVal.absoluteValue) {
-                                    asmgen.out("""
-                                        lda  P8ESTACK_LO+1,x
-                                        bne  +
-                                        dec  P8ESTACK_HI+1,x
-+                                       dec  P8ESTACK_LO+1,x""")
-                                }
-                            } else {
-                                repeat(rightVal) {
-                                    asmgen.out("""
-                                        inc  P8ESTACK_LO+1,x
-                                        bne  +
-                                        inc  P8ESTACK_HI+1,x
-+""")
-                                }
-                            }
-                        }
-                        return true
-                    }
-                }
-            }
-            "-" -> {
-                if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val rightVal = right.asConstInteger()
-                    if (rightVal!=null && rightVal in -4..4)
-                    {
-                        translateExpressionInternal(left)
-                        if(leftDt in ByteDatatypes) {
-                            val incdec = if(rightVal<0) "inc" else "dec"
-                            repeat(rightVal.absoluteValue) {
-                                asmgen.out("  $incdec  P8ESTACK_LO+1,x")
-                            }
-                        } else {
-                            // word
-                            if(rightVal>0) {
-                                repeat(rightVal.absoluteValue) {
-                                    asmgen.out("""
-                                        lda  P8ESTACK_LO+1,x
-                                        bne  +
-                                        dec  P8ESTACK_HI+1,x
-+                                       dec  P8ESTACK_LO+1,x""")
-                                }
-                            } else {
-                                repeat(rightVal) {
-                                    asmgen.out("""
-                                        inc  P8ESTACK_LO+1,x
-                                        bne  +
-                                        inc  P8ESTACK_HI+1,x
-+""")
-                                }
-                            }
-                        }
-                        return true
-                    }
-                }
-            }
-            ">>" -> {
-                val amount = right.asConstInteger()
-                if(amount!=null) {
-                    translateExpressionInternal(left)
-                    when (leftDt) {
-                        DataType.UBYTE -> {
-                            if (amount <= 2)
-                                repeat(amount) { asmgen.out(" lsr  P8ESTACK_LO+1,x") }
-                            else {
-                                asmgen.out(" lda  P8ESTACK_LO+1,x")
-                                repeat(amount) { asmgen.out(" lsr  a") }
-                                asmgen.out(" sta  P8ESTACK_LO+1,x")
-                            }
-                        }
-                        DataType.BYTE -> {
-                            if (amount <= 2)
-                                repeat(amount) { asmgen.out(" lda  P8ESTACK_LO+1,x |  asl  a |  ror  P8ESTACK_LO+1,x") }
-                            else {
-                                asmgen.out(" lda  P8ESTACK_LO+1,x |  sta  P8ZP_SCRATCH_B1")
-                                repeat(amount) { asmgen.out(" asl  a |  ror  P8ZP_SCRATCH_B1 |  lda  P8ZP_SCRATCH_B1") }
-                                asmgen.out(" sta  P8ESTACK_LO+1,x")
-                            }
-                        }
-                        DataType.UWORD -> {
-                            if(amount>=16) {
-                                if(asmgen.isTargetCpu(CpuType.CPU65c02))
-                                    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 true
-                            }
-                            var amountLeft = amount
-                            while (amountLeft >= 7) {
-                                asmgen.out(" jsr  math.shift_right_uw_7")
-                                amountLeft -= 7
-                            }
-                            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_$amountLeft")
-                        }
-                        DataType.WORD -> {
-                            if(amount>=16) {
-                                asmgen.out("""
-                                    lda  P8ESTACK_HI+1,x
-                                    bmi  +
-                                    lda  #0
-                                    sta  P8ESTACK_LO+1,x
-                                    sta  P8ESTACK_HI+1,x
-                                    beq  ++
-+                                   lda  #255
-                                    sta  P8ESTACK_LO+1,x
-                                    sta  P8ESTACK_HI+1,x
-+""")
-                                return true
-                            }
-                            var amountLeft = amount
-                            while (amountLeft >= 7) {
-                                asmgen.out(" jsr  math.shift_right_w_7")
-                                amountLeft -= 7
-                            }
-                            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_$amountLeft")
-                        }
-                        else -> throw AssemblyError("weird type")
-                    }
-                    return true
-                }
-            }
-            "<<" -> {
-                val amount = right.asConstInteger()
-                if(amount!=null) {
-                    translateExpressionInternal(left)
-                    if (leftDt in ByteDatatypes) {
-                        if (amount <= 2)
-                            repeat(amount) { asmgen.out("  asl  P8ESTACK_LO+1,x") }
-                        else {
-                            asmgen.out("  lda  P8ESTACK_LO+1,x")
-                            repeat(amount) { asmgen.out("  asl  a") }
-                            asmgen.out("  sta  P8ESTACK_LO+1,x")
-                        }
-                    } else {
-                        var amountLeft = amount
-                        while (amountLeft >= 7) {
-                            asmgen.out(" jsr  math.shift_left_w_7")
-                            amountLeft -= 7
-                        }
-                        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_$amountLeft")
-                    }
-                    return true
-                }
-            }
-            "*" -> {
-                if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val leftVar = left as? PtIdentifier
-                    val rightVar = right as? PtIdentifier
-                    if(leftVar!=null && rightVar!=null && leftVar==rightVar) {
-                        translateSquared(leftVar, leftDt)
-                        return true
-                    }
-                }
-
-                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(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 true
-                        }
-                        when(rightDt) {
-                            DataType.UBYTE -> {
-                                if(amount in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  math.stack_mul_byte_$amount")
-                                    return true
-                                }
-                            }
-                            DataType.BYTE -> {
-                                if(amount in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  math.stack_mul_byte_$amount")
-                                    return true
-                                }
-                                if(amount.absoluteValue in asmgen.optimizedByteMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  prog8_lib.neg_b |  jsr  math.stack_mul_byte_${amount.absoluteValue}")
-                                    return true
-                                }
-                            }
-                            DataType.UWORD -> {
-                                if(amount in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  math.stack_mul_word_$amount")
-                                    return true
-                                }
-                            }
-                            DataType.WORD -> {
-                                if(amount in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  math.stack_mul_word_$amount")
-                                    return true
-                                }
-                                if(amount.absoluteValue in asmgen.optimizedWordMultiplications) {
-                                    translateExpressionInternal(left)
-                                    asmgen.out(" jsr  prog8_lib.neg_w |  jsr  math.stack_mul_word_${amount.absoluteValue}")
-                                    return true
-                                }
-                            }
-                            else -> {}
-                        }
-                    }
-                }
-            }
-            "/" -> {
-                if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                    val rightVal = right.asConstInteger()
-                    if(rightVal!=null && rightVal==2) {
-                        translateExpressionInternal(left)
-                        when (leftDt) {
-                            DataType.UBYTE -> {
-                                asmgen.out("  lsr  P8ESTACK_LO+1,x")
-                            }
-                            DataType.UWORD -> {
-                                asmgen.out("  lsr  P8ESTACK_HI+1,x |  ror  P8ESTACK_LO+1,x")
-                            }
-                            DataType.BYTE -> {
-                                // signed divide using shift needs adjusting of negative value to get correct rounding towards zero
-                                asmgen.out("""
-                                    lda  P8ESTACK_LO+1,x
-                                    bpl  +
-                                    inc  P8ESTACK_LO+1,x
-                                    lda  P8ESTACK_LO+1,x
-+                                   asl  a
-                                    ror  P8ESTACK_LO+1,x""")
-                            }
-                            DataType.WORD -> {
-                                // signed divide using shift needs adjusting of negative value to get correct rounding towards zero
-                                asmgen.out("""
-                                    lda  P8ESTACK_HI+1,x
-                                    bpl  ++
-                                    inc  P8ESTACK_LO+1,x
-                                    bne  +
-                                    inc  P8ESTACK_HI+1,x
-+                                   lda  P8ESTACK_HI+1,x
-+                                   asl  a
-                                    ror  P8ESTACK_HI+1,x
-                                    ror  P8ESTACK_LO+1,x""")
-                            }
-                            else -> throw AssemblyError("weird dt")
-                        }
-                        return true
-                    }
-                }
-            }
-        }
-
-        return false
-    }
-
-    private fun translateComparisonWithZero(expr: PtExpression, dt: DataType, operator: String) {
-        if(expr.isSimple()) {
-            if(operator=="!=") {
-                when (dt) {
-                    in ByteDatatypes -> {
-                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.A, dt == DataType.BYTE)
-                        asmgen.out("""
-                            beq  +
-                            lda  #1
-+                           sta  P8ESTACK_LO,x
-                            dex""")
-                        return
-                    }
-                    in WordDatatypes -> {
-                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY, dt == DataType.WORD)
-                        asmgen.out("""
-                            sty  P8ZP_SCRATCH_B1 
-                            ora  P8ZP_SCRATCH_B1
-                            beq  +
-                            lda  #1
-+                           sta  P8ESTACK_LO,x
-                            dex""")
-                        return
-                    }
-                    DataType.FLOAT -> {
-                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.FAC1, true)
-                        asmgen.out("""
-                            jsr  floats.SIGN
-                            sta  P8ESTACK_LO,x
-                            dex""")
-                        return
-                    }
-                    else -> {}
-                }
-            }
-            /* operator == is not worth it to special case, the code is mostly larger */
-        }
-        translateExpressionInternal(expr)
-        when(operator) {
-            "==" -> {
-                when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> asmgen.out("  jsr  prog8_lib.equalzero_b")
-                    DataType.UWORD, DataType.WORD -> asmgen.out("  jsr  prog8_lib.equalzero_w")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.equal_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            "!=" -> {
-                when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> asmgen.out("  jsr  prog8_lib.notequalzero_b")
-                    DataType.UWORD, DataType.WORD -> asmgen.out("  jsr  prog8_lib.notequalzero_w")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.notequal_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            "<" -> {
-                if(dt==DataType.UBYTE || dt==DataType.UWORD)
-                    return translateExpressionInternal(PtNumber.fromBoolean(false, expr.position))
-                when(dt) {
-                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.lesszero_b")
-                    DataType.WORD -> asmgen.out("  jsr  prog8_lib.lesszero_w")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.less_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            ">" -> {
-                when(dt) {
-                    DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.greaterzero_ub")
-                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.greaterzero_sb")
-                    DataType.UWORD -> asmgen.out("  jsr  prog8_lib.greaterzero_uw")
-                    DataType.WORD -> asmgen.out("  jsr  prog8_lib.greaterzero_sw")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.greater_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            "<=" -> {
-                when(dt) {
-                    DataType.UBYTE -> asmgen.out("  jsr  prog8_lib.equalzero_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")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            ">=" -> {
-                if(dt==DataType.UBYTE || dt==DataType.UWORD)
-                    return translateExpressionInternal(PtNumber.fromBoolean(true, expr.position))
-                when(dt) {
-                    DataType.BYTE -> asmgen.out("  jsr  prog8_lib.greaterequalzero_sb")
-                    DataType.WORD -> asmgen.out("  jsr  prog8_lib.greaterequalzero_sw")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.greaterequal_zero")
-                    else -> throw AssemblyError("wrong dt")
-                }
-            }
-            else -> throw AssemblyError("invalid comparison operator")
-        }
-    }
-
-    private fun translateSquared(variable: PtIdentifier, dt: DataType) {
-        val asmVar = asmgen.asmVariableName(variable)
-        when(dt) {
-            DataType.BYTE, DataType.UBYTE -> {
-                asmgen.out("  lda  $asmVar")
-                asmgen.signExtendAYlsb(dt)
-                asmgen.out("  jsr  math.square")
-            }
-            DataType.UWORD, DataType.WORD -> {
-                asmgen.out("  lda  $asmVar |  ldy  $asmVar+1 |  jsr  math.square")
-            }
-            else -> throw AssemblyError("require integer dt for square")
-        }
-        asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
-    }
-
-    private fun translateExpression(expr: PtPrefix) {
-        translateExpressionInternal(expr.value)
-        when(expr.operator) {
-            "+" -> {}
-            "-" -> {
-                when(expr.type) {
-                    in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.neg_b")
-                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.neg_w")
-                    DataType.FLOAT -> asmgen.out("  jsr  floats.neg_f")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            "~" -> {
-                when(expr.type) {
-                    in ByteDatatypes ->
-                        asmgen.out("""
-                            lda  P8ESTACK_LO+1,x
-                            eor  #255
-                            sta  P8ESTACK_LO+1,x
-                            """)
-                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.inv_word")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
-            else -> throw AssemblyError("invalid prefix operator ${expr.operator}")
-        }
-    }
-
-    private fun translateExpression(arrayExpr: PtArrayIndexer) {
-        val elementDt = arrayExpr.type
-        val arrayVarName = asmgen.asmVariableName(arrayExpr.variable)
-
-        if(arrayExpr.variable.type==DataType.UWORD) {
-            // indexing a pointer var instead of a real array or string
-            if(elementDt !in ByteDatatypes)
-                throw AssemblyError("non-array var indexing requires bytes dt")
-            if(arrayExpr.index.type != DataType.UBYTE)
-                throw AssemblyError("non-array var indexing requires bytes index")
-            asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.Y)
-            if(asmgen.isZpVar(arrayExpr.variable)) {
-                asmgen.out("  lda  ($arrayVarName),y")
-            } else {
-                asmgen.out("  lda  $arrayVarName |  sta  P8ZP_SCRATCH_W1 |  lda  $arrayVarName+1 |  sta  P8ZP_SCRATCH_W1+1")
-                asmgen.out("  lda  (P8ZP_SCRATCH_W1),y")
-            }
-            asmgen.out("  sta  P8ESTACK_LO,x |  dex")
-            return
-        }
-
-        val constIndexNum = arrayExpr.index.asConstInteger()
-        if(constIndexNum!=null) {
-            val indexValue = constIndexNum * program.memsizer.memorySize(elementDt)
-            when(elementDt) {
-                in ByteDatatypes -> {
-                    asmgen.out("  lda  $arrayVarName+$indexValue |  sta  P8ESTACK_LO,x |  dex")
-                }
-                in WordDatatypes -> {
-                    asmgen.out("  lda  $arrayVarName+$indexValue |  sta  P8ESTACK_LO,x |  lda  $arrayVarName+$indexValue+1 |  sta  P8ESTACK_HI,x |  dex")
-                }
-                DataType.FLOAT -> {
-                    asmgen.out("  lda  #<($arrayVarName+$indexValue) |  ldy  #>($arrayVarName+$indexValue) |  jsr  floats.push_float")
-                }
-                else -> throw AssemblyError("weird element type")
-            }
-        } else {
-            when(elementDt) {
-                in ByteDatatypes -> {
-                    asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.Y)
-                    asmgen.out(" lda  $arrayVarName,y |  sta  P8ESTACK_LO,x |  dex")
-                }
-                in WordDatatypes -> {
-                    asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.Y)
-                    asmgen.out(" lda  $arrayVarName,y |  sta  P8ESTACK_LO,x |  lda  $arrayVarName+1,y |  sta  P8ESTACK_HI,x |  dex")
-                }
-                DataType.FLOAT -> {
-                    asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.A)
-                    asmgen.out("""
-                        ldy  #>$arrayVarName
-                        clc
-                        adc  #<$arrayVarName
-                        bcc  +
-                        iny
-+                       jsr  floats.push_float""")
-                }
-                else -> throw AssemblyError("weird dt")
-            }
-
-        }
-    }
-
-    private fun translateBinaryOperatorBytes(operator: String, types: DataType) {
-        when(operator) {
-            "*" -> asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
-            "/" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
-            "%" -> {
-                if(types==DataType.BYTE)
-                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
-                asmgen.out("  jsr prog8_lib.remainder_ub")
-            }
-            "+" -> asmgen.out("""
-                lda  P8ESTACK_LO+2,x
-                clc
-                adc  P8ESTACK_LO+1,x
-                inx
-                sta  P8ESTACK_LO+1,x
-                """)
-            "-" -> asmgen.out("""
-                lda  P8ESTACK_LO+2,x
-                sec
-                sbc  P8ESTACK_LO+1,x
-                inx
-                sta  P8ESTACK_LO+1,x
-                """)
-            "<<" -> asmgen.out("  jsr  prog8_lib.shiftleft_b")
-            ">>" -> asmgen.out("  jsr  prog8_lib.shiftright_b")
-            "<" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.less_ub" else "  jsr  prog8_lib.less_b")
-            ">" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.greater_ub" else "  jsr  prog8_lib.greater_b")
-            "<=" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.lesseq_ub" else "  jsr  prog8_lib.lesseq_b")
-            ">=" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.greatereq_ub" else "  jsr  prog8_lib.greatereq_b")
-            "==" -> asmgen.out("  jsr  prog8_lib.equal_b")
-            "!=" -> asmgen.out("  jsr  prog8_lib.notequal_b")
-            "&" -> asmgen.out("  jsr  prog8_lib.bitand_b")
-            "^" -> asmgen.out("  jsr  prog8_lib.bitxor_b")
-            "|" -> asmgen.out("  jsr  prog8_lib.bitor_b")
-            else -> throw AssemblyError("invalid operator $operator")
-        }
-    }
-
-    private fun translateBinaryOperatorWords(operator: String, dt: DataType) {
-        when(operator) {
-            "*" -> asmgen.out("  jsr  prog8_lib.mul_word")
-            "/" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.idiv_uw" else "  jsr  prog8_lib.idiv_w")
-            "%" -> {
-                if(dt==DataType.WORD)
-                    throw AssemblyError("remainder of signed integers is not properly defined/implemented, use unsigned instead")
-                asmgen.out("  jsr prog8_lib.remainder_uw")
-            }
-            "+" -> asmgen.out("  jsr  prog8_lib.add_w")
-            "-" -> asmgen.out("  jsr  prog8_lib.sub_w")
-            "<<" -> asmgen.out("  jsr  math.shift_left_w")
-            ">>" -> {
-                if(dt==DataType.UWORD)
-                    asmgen.out("  jsr  math.shift_right_uw")
-                else
-                    asmgen.out("  jsr  math.shift_right_w")
-            }
-            "<" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.less_uw" else "  jsr  prog8_lib.less_w")
-            ">" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.greater_uw" else "  jsr  prog8_lib.greater_w")
-            "<=" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.lesseq_uw" else "  jsr  prog8_lib.lesseq_w")
-            ">=" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.greatereq_uw" else "  jsr  prog8_lib.greatereq_w")
-            "==" -> asmgen.out("  jsr  prog8_lib.equal_w")
-            "!=" -> asmgen.out("  jsr  prog8_lib.notequal_w")
-            "&" -> asmgen.out("  jsr  prog8_lib.bitand_w")
-            "^" -> asmgen.out("  jsr  prog8_lib.bitxor_w")
-            "|" -> asmgen.out("  jsr  prog8_lib.bitor_w")
-            else -> throw AssemblyError("invalid operator $operator")
-        }
-    }
-
-    private fun translateBinaryOperatorFloats(operator: String) {
-        when(operator) {
-            "*" -> asmgen.out("  jsr  floats.mul_f")
-            "/" -> asmgen.out("  jsr  floats.div_f")
-            "+" -> asmgen.out("  jsr  floats.add_f")
-            "-" -> asmgen.out("  jsr  floats.sub_f")
-            "<" -> asmgen.out("  jsr  floats.less_f")
-            ">" -> asmgen.out("  jsr  floats.greater_f")
-            "<=" -> asmgen.out("  jsr  floats.lesseq_f")
-            ">=" -> asmgen.out("  jsr  floats.greatereq_f")
-            "==" -> asmgen.out("  jsr  floats.equal_f")
-            "!=" -> asmgen.out("  jsr  floats.notequal_f")
-            "%", "<<", ">>", "&", "^", "|" -> throw AssemblyError("requires integer datatype")
-            else -> throw AssemblyError("invalid operator $operator")
-        }
-    }
-
-    private fun translateCompareStrings(s1: PtExpression, operator: String, s2: PtExpression) {
-        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")
-            "<=" -> asmgen.out("""
-                bpl  +
-                lda  #1
-                bne  ++
-+               lda  #0
-+               sta  P8ESTACK_LO,x""")
-            ">=" -> asmgen.out("""
-                bmi  +
-                lda  #1
-                bne  ++
-+               lda  #0
-+               sta  P8ESTACK_LO,x""")
-            "<" -> asmgen.out("""
-                bmi  +
-                lda  #0
-                beq  ++
-+               lda  #1
-+               sta  P8ESTACK_LO,x""")
-            ">" -> asmgen.out("""
-                bpl  +
-                lda  #0
-                beq  ++
-+               lda  #1
-+               sta  P8ESTACK_LO,x""")
-        }
-        asmgen.out("  dex")
-    }
-}

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

@@ -6,26 +6,6 @@ import prog8.code.ast.PtSub
 import prog8.code.core.*
 
 
-internal fun IPtSubroutine.regXasResult(): Boolean =
-    (this is PtAsmSub) && this.returns.any { it.first.registerOrPair in arrayOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
-
-internal fun IPtSubroutine.shouldSaveX(): Boolean =
-    this.regXasResult() || (this is PtAsmSub && (CpuRegister.X in this.clobbers || regXasParam()))
-
-internal fun PtAsmSub.regXasParam(): Boolean =
-    parameters.any { it.first.registerOrPair in arrayOf(RegisterOrPair.X, RegisterOrPair.AX, RegisterOrPair.XY) }
-
-internal class KeepAresult(val saveOnEntry: Boolean, val saveOnReturn: Boolean)
-
-internal fun PtAsmSub.shouldKeepA(): KeepAresult {
-    // determine if A's value should be kept when preparing for calling the subroutine, and when returning from it
-
-    // it seems that we never have to save A when calling? will be loaded correctly after setup.
-    // but on return it depends on wether the routine returns something in A.
-    val saveAonReturn = returns.any { it.first.registerOrPair==RegisterOrPair.A || it.first.registerOrPair==RegisterOrPair.AY || it.first.registerOrPair==RegisterOrPair.AX }
-    return KeepAresult(false, saveAonReturn)
-}
-
 internal fun IPtSubroutine.returnsWhatWhere(): List<Pair<RegisterOrStatusflag, DataType>> {
     when(this) {
         is PtAsmSub -> {

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

@@ -1,13 +1,18 @@
 package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
-import prog8.code.ast.*
+import prog8.code.StMemVar
+import prog8.code.StStaticVariable
+import prog8.code.ast.PtForLoop
+import prog8.code.ast.PtIdentifier
+import prog8.code.ast.PtRange
 import prog8.code.core.*
 import kotlin.math.absoluteValue
 
-internal class ForLoopsAsmGen(private val program: PtProgram,
+internal class ForLoopsAsmGen(
     private val asmgen: AsmGen6502Internal,
-                              private val zeropage: Zeropage) {
+    private val zeropage: Zeropage
+) {
 
     internal fun translate(stmt: PtForLoop) {
         val iterableDt = stmt.iterable.type
@@ -51,7 +56,35 @@ internal class ForLoopsAsmGen(private val program: PtProgram,
                     // loop over byte range via loopvar
                     val varname = asmgen.asmVariableName(stmt.variable)
                     asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt))
-                    asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayToElementTypes.getValue(iterableDt))
+                    asmgen.assignExpressionToRegister(range.to, RegisterOrPair.A, false)
+                    // pre-check for end already reached
+                    if(iterableDt==DataType.ARRAY_B) {
+                        asmgen.out("  sta  $modifiedLabel+1")
+                        if(stepsize<0)
+                            asmgen.out("""
+                                clc
+                                sbc  $varname
+                                bvc  +
+                                eor  #${'$'}80
++                               bpl  $endLabel""")
+                        else
+                            asmgen.out("""
+                                sec
+                                sbc  $varname
+                                bvc  +
+                                eor  #${'$'}80
++                               bmi  $endLabel""")
+                    } else {
+                        if(stepsize<0)
+                            asmgen.out("""
+                                cmp  $varname
+                                beq  +
+                                bcs  $endLabel
++""")
+                        else
+                            asmgen.out("  cmp  $varname  |  bcc  $endLabel")
+                        asmgen.out("  sta  $modifiedLabel+1")
+                    }
                     asmgen.out(loopLabel)
                     asmgen.translate(stmt.statements)
                     asmgen.out("""
@@ -69,7 +102,35 @@ $modifiedLabel          cmp  #0         ; modified
                     // loop over byte range via loopvar
                     val varname = asmgen.asmVariableName(stmt.variable)
                     asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt))
-                    asmgen.assignExpressionToVariable(range.to, "$modifiedLabel+1", ArrayToElementTypes.getValue(iterableDt))
+                    asmgen.assignExpressionToRegister(range.to, RegisterOrPair.A, false)
+                    // pre-check for end already reached
+                    if(iterableDt==DataType.ARRAY_B) {
+                        asmgen.out("  sta  $modifiedLabel+1")
+                        if(stepsize<0)
+                            asmgen.out("""
+                                clc
+                                sbc  $varname
+                                bvc  +
+                                eor  #${'$'}80
++                               bpl  $endLabel""")
+                        else
+                            asmgen.out("""
+                                sec
+                                sbc  $varname
+                                bvc  +
+                                eor  #${'$'}80
++                               bmi  $endLabel""")
+                    } else {
+                        if(stepsize<0)
+                            asmgen.out("""
+                                cmp  $varname
+                                beq  +
+                                bcs  $endLabel
++""")
+                        else
+                            asmgen.out("  cmp  $varname  |  bcc  $endLabel")
+                        asmgen.out("  sta  $modifiedLabel+1")
+                    }
                     asmgen.out(loopLabel)
                     asmgen.translate(stmt.statements)
                     if(stepsize>0) {
@@ -100,8 +161,9 @@ $modifiedLabel              cmp  #0     ; modified
 
                     stepsize == 1 || stepsize == -1 -> {
                         val varname = asmgen.asmVariableName(stmt.variable)
-                        assignLoopvar(stmt, range)
+                        assignLoopvarWord(stmt, range)
                         asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
+                        precheckFromToWord(iterableDt, stepsize, varname, endLabel)
                         asmgen.out("""
                             sty  $modifiedLabel+1
                             sta  $modifiedLabel2+1
@@ -134,8 +196,9 @@ $modifiedLabel2 cmp  #0    ; modified
 
                         // (u)words, step >= 2
                         val varname = asmgen.asmVariableName(stmt.variable)
-                        assignLoopvar(stmt, range)
+                        assignLoopvarWord(stmt, range)
                         asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
+                        precheckFromToWord(iterableDt, stepsize, varname, endLabel)
                         asmgen.out("""
                             sty  $modifiedLabel+1
                             sta  $modifiedLabel2+1
@@ -182,41 +245,25 @@ $endLabel""")
 
                         // (u)words, step <= -2
                         val varname = asmgen.asmVariableName(stmt.variable)
-                        assignLoopvar(stmt, range)
+                        assignLoopvarWord(stmt, range)
                         asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
+                        precheckFromToWord(iterableDt, stepsize, varname, endLabel)
                         asmgen.out("""
                             sty  $modifiedLabel+1
                             sta  $modifiedLabel2+1
 $loopLabel""")
                         asmgen.translate(stmt.statements)
 
-                        if(iterableDt==DataType.ARRAY_UW) {
                             asmgen.out("""
                 lda  $varname
                 sec
                 sbc  #<${stepsize.absoluteValue}
                 sta  $varname
+                tax
                 lda  $varname+1
                 sbc  #>${stepsize.absoluteValue}
                 sta  $varname+1
-$modifiedLabel  cmp  #0    ; modified                
-                bcc  $endLabel
-                bne  $loopLabel
-                lda  $varname
-$modifiedLabel2 cmp  #0    ; modified 
-                bcs  $loopLabel
-$endLabel""")
-                        } else {
-                            asmgen.out("""
-                lda  $varname
-                sec
-                sbc  #<${stepsize.absoluteValue}
-                sta  $varname
-                pha
-                lda  $varname+1
-                sbc  #>${stepsize.absoluteValue}
-                sta  $varname+1
-                pla
+                txa
 $modifiedLabel2 cmp  #0    ; modified 
                 lda  $varname+1
 $modifiedLabel  sbc  #0    ; modified
@@ -227,24 +274,72 @@ $endLabel""")
                     }
                 }
             }
-            }
             else -> throw AssemblyError("range expression can only be byte or word")
         }
 
         asmgen.loopEndLabels.pop()
     }
 
+    private fun precheckFromToWord(iterableDt: DataType, stepsize: Int, fromVar: String, endLabel: String) {
+        // pre-check for end already reached.
+        // 'to' is in AY, do NOT clobber this!
+        if(iterableDt==DataType.ARRAY_W) {
+            if(stepsize<0)
+                asmgen.out("""
+                    sta  P8ZP_SCRATCH_W2        ; to
+                    sty  P8ZP_SCRATCH_W2+1      ; to
+                    lda  $fromVar
+	                cmp  P8ZP_SCRATCH_W2
+                    lda  $fromVar+1
+	                sbc  P8ZP_SCRATCH_W2+1
+	                bvc  +
+	                eor  #${'$'}80
++           		bmi  $endLabel
+                    lda  P8ZP_SCRATCH_W2
+                    ldy  P8ZP_SCRATCH_W2+1""")
+            else
+                asmgen.out("""
+                    sta  P8ZP_SCRATCH_REG
+	                cmp  $fromVar
+	                tya
+	                sbc  $fromVar+1
+	                bvc  +
+	                eor  #${'$'}80
++           		bmi  $endLabel
+                    lda  P8ZP_SCRATCH_REG""")
+        } else {
+            if(stepsize<0)
+                asmgen.out("""
+                    cpy  $fromVar+1
+                    beq  +
+                    bcc  ++
+                    bcs  $endLabel
++                   cmp  $fromVar
+                    bcc  +
+                    beq  +
+                    bne  $endLabel
++""")
+            else
+                asmgen.out("""
+                	cpy  $fromVar+1
+	                bcc  $endLabel
+	                bne  +
+	                cmp  $fromVar
+	                bcc  $endLabel
++""")
+        }
+    }
+
     private fun translateForOverIterableVar(stmt: PtForLoop, iterableDt: DataType, ident: PtIdentifier) {
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
         asmgen.loopEndLabels.push(endLabel)
         val iterableName = asmgen.asmVariableName(ident)
         val symbol = asmgen.symbolTable.lookup(ident.name)
-        val decl = symbol!!.astNode as IPtVariable
-        val numElements = when(decl) {
-            is PtConstant -> throw AssemblyError("length of non-array requested")
-            is PtMemMapped -> decl.arraySize
-            is PtVariable -> decl.arraySize
+        val numElements = when(symbol) {
+            is StStaticVariable -> symbol.length!!
+            is StMemVar -> symbol.length!!
+            else -> 0
         }
         when(iterableDt) {
             DataType.STR -> {
@@ -272,7 +367,7 @@ $loopLabel          sty  $indexVar
                     lda  $iterableName,y
                     sta  ${asmgen.asmVariableName(stmt.variable)}""")
                 asmgen.translate(stmt.statements)
-                if(numElements!!<=255u) {
+                if(numElements<=255) {
                     asmgen.out("""
                         ldy  $indexVar
                         iny
@@ -287,11 +382,11 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
-                if(numElements>=16u) {
+                if(numElements>=16) {
                     // allocate index var on ZP if possible
                     val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
                     result.fold(
-                        success = { (address,_)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
+                        success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
                         failure = { asmgen.out("$indexVar    .byte  0") }
                     )
                 } else {
@@ -300,7 +395,7 @@ $loopLabel          sty  $indexVar
                 asmgen.out(endLabel)
             }
             DataType.ARRAY_W, DataType.ARRAY_UW -> {
-                val length = numElements!! * 2u
+                val length = numElements * 2
                 val indexVar = asmgen.makeLabel("for_index")
                 val loopvarName = asmgen.asmVariableName(stmt.variable)
                 asmgen.out("""
@@ -311,7 +406,7 @@ $loopLabel          sty  $indexVar
                     lda  $iterableName+1,y
                     sta  $loopvarName+1""")
                 asmgen.translate(stmt.statements)
-                if(length<=127u) {
+                if(length<=127) {
                     asmgen.out("""
                         ldy  $indexVar
                         iny
@@ -328,11 +423,49 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
-                if(length>=16u) {
+                if(length>=16) {
                     // allocate index var on ZP if possible
                     val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
                     result.fold(
-                        success = { (address,_)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
+                        success = { (address,_,_)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
+                        failure = { asmgen.out("$indexVar    .byte  0") }
+                    )
+                } else {
+                    asmgen.out("$indexVar    .byte  0")
+                }
+                asmgen.out(endLabel)
+            }
+            DataType.ARRAY_UW_SPLIT, DataType.ARRAY_W_SPLIT -> {
+                val indexVar = asmgen.makeLabel("for_index")
+                val loopvarName = asmgen.asmVariableName(stmt.variable)
+                asmgen.out("""
+                    ldy  #0
+$loopLabel          sty  $indexVar
+                    lda  ${iterableName}_lsb,y
+                    sta  $loopvarName
+                    lda  ${iterableName}_msb,y
+                    sta  $loopvarName+1""")
+                asmgen.translate(stmt.statements)
+                if(numElements<=255) {
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        cpy  #$numElements
+                        beq  $endLabel
+                        bne  $loopLabel""")
+                } else {
+                    // length is 256
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        bne  $loopLabel
+                        beq  $endLabel""")
+                }
+                if(numElements>=16) {
+                    // allocate index var on ZP if possible
+                    val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
+                    result.fold(
+                        success = { (address,_,_)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
                         failure = { asmgen.out("$indexVar    .byte  0") }
                     )
                 } else {
@@ -590,7 +723,7 @@ $loopLabel""")
         asmgen.loopEndLabels.pop()
     }
 
-    private fun assignLoopvar(stmt: PtForLoop, range: PtRange) =
+    private fun assignLoopvarWord(stmt: PtForLoop, range: PtRange) =
         asmgen.assignExpressionToVariable(
             range.from,
             asmgen.asmVariableName(stmt.variable),

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

@@ -11,42 +11,10 @@ import prog8.codegen.cpu6502.assignment.TargetStorageKind
 internal class FunctionCallAsmGen(private val program: PtProgram, private val asmgen: AsmGen6502Internal) {
 
     internal fun translateFunctionCallStatement(stmt: PtFunctionCall) {
-        saveXbeforeCall(stmt)
         translateFunctionCall(stmt)
-        restoreXafterCall(stmt)
         // just ignore any result values from the function call.
     }
 
-    internal fun saveXbeforeCall(stmt: PtFunctionCall) {
-        val symbol = asmgen.symbolTable.lookup(stmt.name)
-        val sub = symbol!!.astNode as IPtSubroutine
-        if(sub.shouldSaveX()) {
-            if(sub is PtAsmSub) {
-                val regSaveOnStack = sub.address == null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
-                if (regSaveOnStack)
-                    asmgen.saveRegisterStack(CpuRegister.X, sub.shouldKeepA().saveOnEntry)
-                else
-                    asmgen.saveRegisterLocal(CpuRegister.X, stmt.definingISub()!!)
-            } else
-                asmgen.saveRegisterLocal(CpuRegister.X, stmt.definingISub()!!)
-        }
-    }
-
-    internal fun restoreXafterCall(stmt: PtFunctionCall) {
-        val symbol = asmgen.symbolTable.lookup(stmt.name)
-        val sub = symbol!!.astNode as IPtSubroutine
-        if(sub.shouldSaveX()) {
-            if(sub is PtAsmSub) {
-                val regSaveOnStack = sub.address == null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
-                if (regSaveOnStack)
-                    asmgen.restoreRegisterStack(CpuRegister.X, sub.shouldKeepA().saveOnReturn)
-                else
-                    asmgen.restoreRegisterLocal(CpuRegister.X)
-            } else
-                asmgen.restoreRegisterLocal(CpuRegister.X)
-        }
-    }
-
     internal fun optimizeIntArgsViaRegisters(sub: PtSub) =
         (sub.parameters.size==1 && sub.parameters[0].type in IntegerDatatypes)
                 || (sub.parameters.size==2 && sub.parameters[0].type in ByteDatatypes && sub.parameters[1].type in ByteDatatypes)
@@ -58,13 +26,13 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         //       (you can use subroutine.shouldSaveX() and saveX()/restoreX() routines as a help for this)
 
         val symbol = asmgen.symbolTable.lookup(call.name)
-        val sub = symbol!!.astNode as IPtSubroutine
+        val sub = symbol?.astNode as IPtSubroutine
         val subAsmName = asmgen.asmSymbolName(call.name)
 
         if(sub is PtAsmSub) {
             argumentsViaRegisters(sub, call)
-            if (sub.inline && asmgen.options.optimize) {
-                // inline the subroutine.
+            if (sub.inline) {
+                // inline the subroutine. (regardless of optimization settings!)
                 // we do this by copying the subroutine's statements at the call site.
                 // NOTE: *if* there is a return statement, it will be the only one, and the very last statement of the subroutine
                 // (this condition has been enforced by an ast check earlier)
@@ -101,40 +69,62 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         // remember: dealing with the X register and/or dealing with return values is the responsibility of the caller
     }
 
+
+    private fun usesOtherRegistersWhileEvaluating(arg: PtExpression): Boolean {
+        return when(arg) {
+            is PtBuiltinFunctionCall -> {
+                if (arg.name == "lsb" || arg.name == "msb")
+                    return usesOtherRegistersWhileEvaluating(arg.args[0])
+                if (arg.name == "mkword")
+                    return usesOtherRegistersWhileEvaluating(arg.args[0]) || usesOtherRegistersWhileEvaluating(arg.args[1])
+                return !arg.isSimple()
+            }
+            is PtAddressOf -> false
+            is PtIdentifier -> false
+            is PtMachineRegister -> false
+            is PtMemoryByte -> false
+            is PtNumber -> false
+            else -> true
+        }
+    }
+
     private fun argumentsViaRegisters(sub: PtAsmSub, call: PtFunctionCall) {
+        val registersUsed = mutableListOf<RegisterOrStatusflag>();
+
+        fun usedA() = registersUsed.any {it.registerOrPair==RegisterOrPair.A || it.registerOrPair==RegisterOrPair.AX || it.registerOrPair==RegisterOrPair.AY}
+        fun usedX() = registersUsed.any {it.registerOrPair==RegisterOrPair.X || it.registerOrPair==RegisterOrPair.AX || it.registerOrPair==RegisterOrPair.XY}
+        fun usedY() = registersUsed.any {it.registerOrPair==RegisterOrPair.Y || it.registerOrPair==RegisterOrPair.AY || it.registerOrPair==RegisterOrPair.XY}
+
         if(sub.parameters.size==1) {
             argumentViaRegister(sub, IndexedValue(0, sub.parameters.single().second), call.args[0])
         } else {
-            if(asmsub6502ArgsHaveRegisterClobberRisk(call.args, sub.parameters)) {
-                registerArgsViaCpuStackEvaluation(call, sub)
-            } else {
-                asmsub6502ArgsEvalOrder(sub).forEach {
+            val optimalEvalOrder = asmsub6502ArgsEvalOrder(sub)
+            optimalEvalOrder.forEach {
                 val param = sub.parameters[it]
                 val arg = call.args[it]
+                registersUsed += if(usesOtherRegistersWhileEvaluating(arg)) {
+                    if(!registersUsed.any{it.statusflag!=null || it.registerOrPair in CpuRegisters})
+                        argumentViaRegister(sub, IndexedValue(it, param.second), arg)
+                    else if(registersUsed.any {it.statusflag!=null}) {
+                        throw AssemblyError("call argument evaluation problem: can't save cpu statusregister parameter ${call.position}")
+                    }
+                    else {
+                        if(usedX()) asmgen.saveRegisterStack(CpuRegister.X, false)
+                        if(usedY()) asmgen.saveRegisterStack(CpuRegister.Y, false)
+                        if(usedA()) asmgen.saveRegisterStack(CpuRegister.A, false)
+                        val used = argumentViaRegister(sub, IndexedValue(it, param.second), arg)
+                        if(usedA()) asmgen.restoreRegisterStack(CpuRegister.A, false)
+                        if(usedY()) asmgen.restoreRegisterStack(CpuRegister.Y, true)
+                        if(usedX()) asmgen.restoreRegisterStack(CpuRegister.X, true)
+                        used
+                    }
+                } else {
                     argumentViaRegister(sub, IndexedValue(it, param.second), arg)
                 }
             }
         }
     }
 
-    private fun registerArgsViaCpuStackEvaluation(call: PtFunctionCall, callee: PtAsmSub) {
-        // this is called when one or more of the arguments are 'complex' and
-        // cannot be assigned to a register easily or risk clobbering other registers.
-
-        if(callee.parameters.isEmpty())
-            return
-
-        // use the cpu hardware stack as intermediate storage for the arguments.
-        val argOrder = asmsub6502ArgsEvalOrder(callee)
-        argOrder.reversed().forEach {
-            asmgen.pushCpuStack(callee.parameters[it].second.type, call.args[it])
-        }
-        argOrder.forEach {
-            val param = callee.parameters[it]
-            asmgen.popCpuStack(callee, param.second, param.first)
-        }
-    }
-
     private fun argumentViaVariable(sub: PtSub, parameter: PtSubroutineParameter, value: PtExpression) {
         // pass parameter via a regular variable (not via registers)
         if(!isArgumentTypeCompatible(value.type, parameter.type))
@@ -144,7 +134,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         asmgen.assignExpressionToVariable(value, varName, parameter.type)
     }
 
-    private fun argumentViaRegister(sub: IPtSubroutine, parameter: IndexedValue<PtSubroutineParameter>, value: PtExpression, registerOverride: RegisterOrPair? = null) {
+    private fun argumentViaRegister(sub: IPtSubroutine, parameter: IndexedValue<PtSubroutineParameter>, value: PtExpression, registerOverride: RegisterOrPair? = null): RegisterOrStatusflag {
         // pass argument via a register parameter
         if(!isArgumentTypeCompatible(value.type, parameter.value.type))
             throw AssemblyError("argument type incompatible")
@@ -164,7 +154,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
             if(requiredDt!=value.type)
                 throw AssemblyError("for statusflag, byte value is required")
             if (statusflag == Statusflag.Pc) {
-                // this param needs to be set last, right before the jsr
+                // this boolean param needs to be set last, right before the jsr
                 // for now, this is already enforced on the subroutine definition by the Ast Checker
                 when(value) {
                     is PtNumber -> {
@@ -173,6 +163,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                     }
                     is PtIdentifier -> {
                         val sourceName = asmgen.asmVariableName(value)
+                        // note: cannot use X register here to store A because it might be used for other arguments
                         asmgen.out("""
                             pha
                             clc
@@ -183,15 +174,11 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                     }
                     else -> {
                         asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
-                        asmgen.out("""
-                            beq  +
-                            sec
-                            bcs  ++
-+                           clc
-+""")
+                        asmgen.out("  ror  a")
                     }
                 }
             } else throw AssemblyError("can only use Carry as status flag parameter")
+            return RegisterOrStatusflag(null, statusflag)
         }
         else {
             // via register or register pair
@@ -224,6 +211,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                 }
                 asmgen.translateNormalAssignment(AsmAssignment(src, target, program.memsizer, Position.DUMMY), scope)
             }
+            return RegisterOrStatusflag(register, null)
         }
     }
 
@@ -245,3 +233,5 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         return false
     }
 }
+
+

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

@@ -13,7 +13,6 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
         val targetIdent = stmt.target.identifier
         val targetMemory = stmt.target.memory
         val targetArrayIdx = stmt.target.array
-        val scope = stmt.definingISub()
         when {
             targetIdent!=null -> {
                 val what = asmgen.asmVariableName(targetIdent)
@@ -65,10 +64,50 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
                 val asmArrayvarname = asmgen.asmVariableName(targetArrayIdx.variable)
                 val elementDt = targetArrayIdx.type
                 val constIndex = targetArrayIdx.index.asConstInteger()
+                if(targetArrayIdx.splitWords) {
+                    if(constIndex!=null) {
+                        if(incr)
+                            asmgen.out(" inc  ${asmArrayvarname}_lsb+$constIndex |  bne  + |  inc  ${asmArrayvarname}_msb+$constIndex |+")
+                        else
+                            asmgen.out("""
+        lda  ${asmArrayvarname}_lsb+$constIndex
+        bne  +
+        dec  ${asmArrayvarname}_msb+$constIndex
++       dec  ${asmArrayvarname}_lsb+$constIndex""")
+                    } else {
+                        asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, CpuRegister.X)
+                        if(incr)
+                            asmgen.out(" inc  ${asmArrayvarname}_lsb,x |  bne  + |  inc  ${asmArrayvarname}_msb,x |+")
+                        else
+                            asmgen.out("""
+        lda  ${asmArrayvarname}_lsb,x
+        bne  +
+        dec  ${asmArrayvarname}_msb,x
++       dec  ${asmArrayvarname}_lsb,x""")
+                    }
+                    return
+                }
                 if(constIndex!=null) {
                     val indexValue = constIndex * program.memsizer.memorySize(elementDt)
                     when(elementDt) {
-                        in ByteDatatypes -> asmgen.out(if (incr) "  inc  $asmArrayvarname+$indexValue" else "  dec  $asmArrayvarname+$indexValue")
+                        in ByteDatatypes -> {
+                            if(targetArrayIdx.usesPointerVariable) {
+                                asmgen.out("""
+                                    lda  $asmArrayvarname
+                                    clc
+                                    adc  #$indexValue
+                                    sta  (+) +1
+                                    lda  $asmArrayvarname+1
+                                    adc  #0
+                                    sta  (+) +2""")
+                                if(incr)
+                                    asmgen.out("+\tinc  ${'$'}ffff\t; modified")
+                                else
+                                    asmgen.out("+\tdec  ${'$'}ffff\t; modified")
+                            } else {
+                                asmgen.out(if (incr) "  inc  $asmArrayvarname+$indexValue" else "  dec  $asmArrayvarname+$indexValue")
+                            }
+                        }
                         in WordDatatypes -> {
                             if(incr)
                                 asmgen.out(" inc  $asmArrayvarname+$indexValue |  bne  + |  inc  $asmArrayvarname+$indexValue+1 |+")
@@ -77,8 +116,7 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
         lda  $asmArrayvarname+$indexValue
         bne  +
         dec  $asmArrayvarname+$indexValue+1
-+       dec  $asmArrayvarname+$indexValue 
-""")
++       dec  $asmArrayvarname+$indexValue""")
                         }
                         DataType.FLOAT -> {
                             asmgen.out("  lda  #<($asmArrayvarname+$indexValue) |  ldy  #>($asmArrayvarname+$indexValue)")
@@ -89,12 +127,25 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
                 }
                 else
                 {
-                    asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, elementDt, CpuRegister.A)
-                    asmgen.saveRegisterLocal(CpuRegister.X, scope!!)
-                    asmgen.out("  tax")
+                    asmgen.loadScaledArrayIndexIntoRegister(targetArrayIdx, CpuRegister.X)
                     when(elementDt) {
                         in ByteDatatypes -> {
-                            asmgen.out(if(incr) "  inc  $asmArrayvarname,x" else "  dec  $asmArrayvarname,x")
+                            if(targetArrayIdx.usesPointerVariable) {
+                                asmgen.out("""
+                                    txa
+                                    clc
+                                    adc  $asmArrayvarname
+                                    sta  (+) +1
+                                    lda  $asmArrayvarname+1
+                                    adc  #0
+                                    sta  (+) +2""")
+                                if(incr)
+                                    asmgen.out("+\tinc  ${'$'}ffff\t; modified")
+                                else
+                                    asmgen.out("+\tdec  ${'$'}ffff\t; modified")
+                            } else {
+                                asmgen.out(if (incr) "  inc  $asmArrayvarname,x" else "  dec  $asmArrayvarname,x")
+                            }
                         }
                         in WordDatatypes -> {
                             if(incr)
@@ -104,8 +155,7 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
         lda  $asmArrayvarname,x
         bne  +
         dec  $asmArrayvarname+1,x
-+       dec  $asmArrayvarname,x 
-""")
++       dec  $asmArrayvarname,x""")
                         }
                         DataType.FLOAT -> {
                             asmgen.out("""
@@ -118,7 +168,6 @@ internal class PostIncrDecrAsmGen(private val program: PtProgram, private val as
                         }
                         else -> throw AssemblyError("weird array elt dt")
                     }
-                    asmgen.restoreRegisterLocal(CpuRegister.X)
                 }
             }
         }

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

@@ -33,8 +33,9 @@ internal class ProgramAndVarsGen(
     internal fun generate() {
         header()
         val allBlocks = program.allBlocks()
-        if(allBlocks.first().name != "main")
-            throw AssemblyError("first block should be 'main'")
+
+        if(allBlocks.first().name != "p8b_main" && allBlocks.first().name != "main")
+            throw AssemblyError("first block should be 'main' or 'p8b_main'")
 
         if(errors.noErrors())  {
             program.allBlocks().forEach { block2asm(it) }
@@ -74,8 +75,6 @@ internal class ProgramAndVarsGen(
         asmgen.out("P8ZP_SCRATCH_W1 = ${zp.SCRATCH_W1}    ; word")
         asmgen.out("P8ZP_SCRATCH_W2 = ${zp.SCRATCH_W2}    ; word")
         asmgen.out(".weak")   // hack to allow user to override the following two with command line redefinition (however, just use '-esa' command line option instead!)
-        asmgen.out("P8ESTACK_LO = ${compTarget.machine.ESTACK_LO.toHex()}")
-        asmgen.out("P8ESTACK_HI = ${compTarget.machine.ESTACK_HI.toHex()}")
         asmgen.out(".endweak")
 
         if(options.symbolDefs.isNotEmpty()) {
@@ -104,15 +103,15 @@ internal class ProgramAndVarsGen(
                         asmgen.out("+\t.word  0")
                         asmgen.out("prog8_entrypoint\t; assembly code starts here")
                         if(!options.noSysInit)
-                            asmgen.out("  jsr  ${compTarget.name}.init_system")
-                        asmgen.out("  jsr  ${compTarget.name}.init_system_phase2")
+                            asmgen.out("  jsr  sys.init_system")
+                        asmgen.out("  jsr  sys.init_system_phase2")
                     }
                     CbmPrgLauncherType.NONE -> {
                         asmgen.out("; ---- program without basic sys call ----")
                         asmgen.out("* = ${options.loadAddress.toHex()}")
                         if(!options.noSysInit)
-                            asmgen.out("  jsr  ${compTarget.name}.init_system")
-                        asmgen.out("  jsr  ${compTarget.name}.init_system_phase2")
+                            asmgen.out("  jsr  sys.init_system")
+                        asmgen.out("  jsr  sys.init_system_phase2")
                     }
                 }
             }
@@ -120,8 +119,8 @@ internal class ProgramAndVarsGen(
                 asmgen.out("; ---- atari xex program ----")
                 asmgen.out("* = ${options.loadAddress.toHex()}")
                 if(!options.noSysInit)
-                    asmgen.out("  jsr  ${compTarget.name}.init_system")
-                asmgen.out("  jsr  ${compTarget.name}.init_system_phase2")
+                    asmgen.out("  jsr  sys.init_system")
+                asmgen.out("  jsr  sys.init_system_phase2")
             }
         }
 
@@ -134,29 +133,22 @@ internal class ProgramAndVarsGen(
                 pha""")
         }
 
-        // make sure that on the cx16 and c64, basic rom is banked in again when we exit the program
         when(compTarget.name) {
             "cx16" -> {
                 if(options.floats)
                     asmgen.out("  lda  #4 |  sta  $01")    // to use floats, make sure Basic rom is banked in
-                asmgen.out("  jsr  main.start")
-                asmgen.out("  jmp  ${compTarget.name}.cleanup_at_exit")
+                asmgen.out("  jsr  p8b_main.p8s_start")
+                asmgen.out("  jmp  sys.cleanup_at_exit")
             }
             "c64" -> {
-                asmgen.out("  jsr  main.start |  lda  #31 |  sta  $01")
-                if(!options.noSysInit)
-                    asmgen.out("  jmp  ${compTarget.name}.cleanup_at_exit")
-                else
-                    asmgen.out("  rts")
+                asmgen.out("  jsr  p8b_main.p8s_start |  lda  #31 |  sta  $01")
+                asmgen.out("  jmp  sys.cleanup_at_exit")
             }
             "c128" -> {
-                asmgen.out("  jsr  main.start |  lda  #0 |  sta ${"$"}ff00")
-                if(!options.noSysInit)
-                    asmgen.out("  jmp  ${compTarget.name}.cleanup_at_exit")
-                else
-                    asmgen.out("  rts")
+                asmgen.out("  jsr  p8b_main.p8s_start |  lda  #0 |  sta ${"$"}ff00")
+                asmgen.out("  jmp  sys.cleanup_at_exit")
             }
-            else -> asmgen.jmp("main.start")
+            else -> asmgen.jmp("p8b_main.p8s_start")
         }
     }
 
@@ -174,46 +166,98 @@ internal class ProgramAndVarsGen(
     }
 
     private fun footer() {
+        var relocateBssVars = false
+        var relocateBssSlabs = false
+        var relocatedBssStart = 0u
+        var relocatedBssEnd = 0u
+
+        if(options.varsGolden) {
+            if(options.compTarget.machine.BSSGOLDENRAM_START == 0u ||
+                options.compTarget.machine.BSSGOLDENRAM_END == 0u ||
+                options.compTarget.machine.BSSGOLDENRAM_END <= options.compTarget.machine.BSSGOLDENRAM_START) {
+                throw AssemblyError("current compilation target hasn't got the golden ram area properly defined or it is simply not available")
+            }
+            relocateBssVars = true
+            relocatedBssStart = options.compTarget.machine.BSSGOLDENRAM_START
+            relocatedBssEnd = options.compTarget.machine.BSSGOLDENRAM_END
+        }
+        else if(options.varsHighBank!=null) {
+            if(options.compTarget.machine.BSSHIGHRAM_START == 0u ||
+                options.compTarget.machine.BSSHIGHRAM_END == 0u ||
+                options.compTarget.machine.BSSHIGHRAM_END <= options.compTarget.machine.BSSHIGHRAM_START) {
+                throw AssemblyError("current compilation target hasn't got the high ram area properly defined or it is simply not available")
+            }
+            if(options.slabsHighBank!=null && options.varsHighBank!=options.slabsHighBank)
+                throw AssemblyError("slabs and vars high bank must be the same")
+            relocateBssVars = true
+            relocatedBssStart = options.compTarget.machine.BSSHIGHRAM_START
+            relocatedBssEnd = options.compTarget.machine.BSSHIGHRAM_END
+        }
+
+        if(options.slabsGolden) {
+            if(options.compTarget.machine.BSSGOLDENRAM_START == 0u ||
+                options.compTarget.machine.BSSGOLDENRAM_END == 0u ||
+                options.compTarget.machine.BSSGOLDENRAM_END <= options.compTarget.machine.BSSGOLDENRAM_START) {
+                throw AssemblyError("current compilation target hasn't got the golden ram area properly defined or it is simply not available")
+            }
+            relocateBssSlabs = true
+            relocatedBssStart = options.compTarget.machine.BSSGOLDENRAM_START
+            relocatedBssEnd = options.compTarget.machine.BSSGOLDENRAM_END
+        }
+        else if(options.slabsHighBank!=null) {
+            if(options.compTarget.machine.BSSHIGHRAM_START == 0u ||
+                options.compTarget.machine.BSSHIGHRAM_END == 0u ||
+                options.compTarget.machine.BSSHIGHRAM_END <= options.compTarget.machine.BSSHIGHRAM_START) {
+                throw AssemblyError("current compilation target hasn't got the high ram area properly defined or it is simply not available")
+            }
+            if(options.varsHighBank!=null && options.varsHighBank!=options.slabsHighBank)
+                throw AssemblyError("slabs and vars high bank must be the same")
+            relocateBssSlabs = true
+            relocatedBssStart = options.compTarget.machine.BSSHIGHRAM_START
+            relocatedBssEnd = options.compTarget.machine.BSSHIGHRAM_END
+        }
+
         asmgen.out("; bss sections")
-        if(options.varsHigh) {
-            if(options.compTarget.machine.BSSHIGHRAM_START == 0u || options.compTarget.machine.BSSHIGHRAM_END==0u) {
-                throw AssemblyError("current compilation target hasn't got the high ram area properly defined")
-            }
-            // BSS vars in high ram area, memory() slabs just concatenated at the end of the program.
-            if(symboltable.allMemorySlabs.isNotEmpty()) {
+        asmgen.out("PROG8_VARSHIGH_RAMBANK = ${options.varsHighBank ?: 1}")
+        if(relocateBssVars) {
+            if(!relocateBssSlabs)
                 asmgen.out("  .dsection slabs_BSS")
-            }
             asmgen.out("prog8_program_end\t; end of program label for progend()")
-            asmgen.out("  * = ${options.compTarget.machine.BSSHIGHRAM_START.toHex()}")
+            asmgen.out("  * = ${relocatedBssStart.toHex()}")
             asmgen.out("prog8_bss_section_start")
             asmgen.out("  .dsection BSS")
-            asmgen.out("  .cerror * >= ${options.compTarget.machine.BSSHIGHRAM_END.toHex()}, \"too many variables for BSS section\"")
+            if(relocateBssSlabs)
+                asmgen.out("  .dsection slabs_BSS")
+            asmgen.out("  .cerror * > ${relocatedBssEnd.toHex()}, \"too many variables/data for BSS section\"")
             asmgen.out("prog8_bss_section_size = * - prog8_bss_section_start")
         } else {
-            // BSS vars followed by memory() slabs, concatenated at the end of the program.
             asmgen.out("prog8_bss_section_start")
             asmgen.out("  .dsection BSS")
             asmgen.out("prog8_bss_section_size = * - prog8_bss_section_start")
-            if(symboltable.allMemorySlabs.isNotEmpty()) {
+            if(!relocateBssSlabs)
                 asmgen.out("  .dsection slabs_BSS")
-            }
             asmgen.out("prog8_program_end\t; end of program label for progend()")
+            if(relocateBssSlabs) {
+                asmgen.out("  * = ${relocatedBssStart.toHex()}")
+                asmgen.out("  .dsection slabs_BSS")
+                asmgen.out("  .cerror * > ${relocatedBssEnd.toHex()}, \"too many data for slabs_BSS section\"")
+            }
         }
     }
 
     private fun block2asm(block: PtBlock) {
         asmgen.out("")
         asmgen.out("; ---- block: '${block.name}' ----")
-        if(block.address!=null)
-            asmgen.out("* = ${block.address!!.toHex()}")
+        if(block.options.address!=null)
+            asmgen.out("* = ${block.options.address!!.toHex()}")
         else {
-            if(block.alignment==PtBlock.BlockAlignment.WORD)
+            if(block.options.alignment==PtBlock.BlockAlignment.WORD)
                 asmgen.out("\t.align 2")
-            else if(block.alignment==PtBlock.BlockAlignment.PAGE)
+            else if(block.options.alignment==PtBlock.BlockAlignment.PAGE)
                 asmgen.out("\t.align $100")
         }
 
-        asmgen.out("${block.name}\t" + (if(block.forceOutput) ".block" else ".proc"))
+        asmgen.out("${block.name}\t" + (if(block.options.forceOutput) ".block" else ".proc"))
         asmgen.outputSourceLine(block)
 
         createBlockVariables(block)
@@ -236,7 +280,7 @@ internal class ProgramAndVarsGen(
             asmgen.out("  rts\n  .bend")
         }
 
-        asmgen.out(if(block.forceOutput) "\n\t.bend" else "\n\t.pend")
+        asmgen.out(if(block.options.forceOutput) "\n\t.bend" else "\n\t.pend")
     }
 
     private fun getVars(scope: StNode): Map<String, StNode> =
@@ -269,16 +313,14 @@ internal class ProgramAndVarsGen(
 
     internal fun translateAsmSubroutine(sub: PtAsmSub) {
         if(sub.inline) {
-            if(options.optimize) {
-                return
-            }
+            return      // subroutine gets inlined at call site.
         }
 
         asmgen.out("")
 
         val asmStartScope: String
         val asmEndScope: String
-        if(sub.definingBlock()!!.forceOutput) {
+        if(sub.definingBlock()!!.options.forceOutput) {
             asmStartScope = ".block"
             asmEndScope = ".bend"
         } else {
@@ -301,7 +343,7 @@ internal class ProgramAndVarsGen(
 
         val asmStartScope: String
         val asmEndScope: String
-        if(sub.definingBlock()!!.forceOutput) {
+        if(sub.definingBlock()!!.options.forceOutput) {
             asmStartScope = ".block"
             asmEndScope = ".bend"
         } else {
@@ -311,7 +353,9 @@ internal class ProgramAndVarsGen(
 
         asmgen.out("${sub.name}\t$asmStartScope")
 
-        val scope = symboltable.lookupOrElse(sub.scopedName) { throw AssemblyError("lookup") }
+        val scope = symboltable.lookupOrElse(sub.scopedName) {
+            throw AssemblyError("lookup ${sub.scopedName}")
+        }
         require(scope.type==StNodeType.SUBROUTINE)
         val varsInSubroutine = getVars(scope)
 
@@ -331,7 +375,7 @@ internal class ProgramAndVarsGen(
         asmsubs2asm(sub.children)
 
         // the main.start subroutine is the program's entrypoint and should perform some initialization logic
-        if(sub.name=="start" && sub.definingBlock()!!.name=="main")
+        if((sub.name=="start" || sub.name=="p8s_start") && (sub.definingBlock()!!.name=="main" || sub.definingBlock()!!.name=="p8b_main"))
             entrypointInitialization()
 
         if(functioncallAsmGen.optimizeIntArgsViaRegisters(sub)) {
@@ -369,12 +413,6 @@ internal class ProgramAndVarsGen(
                 else -> throw AssemblyError("weird dt for extravar $dt")
             }
         }
-        if(asmGenInfo.usedRegsaveA)      // will probably never occur
-            asmgen.out("prog8_regsaveA     .byte  ?")
-        if(asmGenInfo.usedRegsaveX)
-            asmgen.out("prog8_regsaveX     .byte  ?")
-        if(asmGenInfo.usedRegsaveY)
-            asmgen.out("prog8_regsaveY     .byte  ?")
         if(asmGenInfo.usedFloatEvalResultVar1)
             asmgen.out("$subroutineFloatEvalResultVar1    .fill  ${options.compTarget.machine.FLOAT_MEM_SIZE}")
         if(asmGenInfo.usedFloatEvalResultVar2)
@@ -434,12 +472,12 @@ internal class ProgramAndVarsGen(
                 asmgen.out("""
                     lda  #<${name}_init_value
                     ldy  #>${name}_init_value
-                    sta  cx16.r0L
-                    sty  cx16.r0H
+                    sta  cx16.r0
+                    sty  cx16.r0+1
                     lda  #<${name}
                     ldy  #>${name}
-                    sta  cx16.r1L
-                    sty  cx16.r1H
+                    sta  cx16.r1
+                    sty  cx16.r1+1
                     lda  #<$size
                     ldy  #>$size
                     jsr  sys.memcopy""")
@@ -458,7 +496,6 @@ internal class ProgramAndVarsGen(
         }
 
         asmgen.out("""+        
-                    ldx  #127       ; init estack ptr (half page)
                     clv
                     clc""")
     }
@@ -480,8 +517,8 @@ internal class ProgramAndVarsGen(
         val vars = allocator.zeropageVars.filter { it.value.dt==DataType.STR }
         for (variable in vars) {
             val scopedName = variable.key
-            val svar = symboltable.flat.getValue(scopedName) as StStaticVariable
-            if(svar.onetimeInitializationStringValue!=null)
+            val svar = symboltable.lookup(scopedName) as? StStaticVariable
+            if(svar?.onetimeInitializationStringValue!=null)
                 result.add(ZpStringWithInitial(scopedName, variable.value, svar.onetimeInitializationStringValue!!))
         }
         return result
@@ -492,8 +529,8 @@ internal class ProgramAndVarsGen(
         val vars = allocator.zeropageVars.filter { it.value.dt in ArrayDatatypes }
         for (variable in vars) {
             val scopedName = variable.key
-            val svar = symboltable.flat.getValue(scopedName) as StStaticVariable
-            if(svar.onetimeInitializationArrayValue!=null)
+            val svar = symboltable.lookup(scopedName) as? StStaticVariable
+            if(svar?.onetimeInitializationArrayValue!=null)
                 result.add(ZpArrayWithInitial(scopedName, variable.value, svar.onetimeInitializationArrayValue!!))
         }
         return result
@@ -504,9 +541,17 @@ internal class ProgramAndVarsGen(
         for ((scopedName, zpvar) in zpVariables) {
             if (scopedName.startsWith("cx16.r"))
                 continue        // The 16 virtual registers of the cx16 are not actual variables in zp, they're memory mapped
+            val variable = symboltable.flat.getValue(scopedName) as StStaticVariable
+            if(variable.dt in SplitWordArrayTypes) {
+                val lsbAddr = zpvar.address
+                val msbAddr = zpvar.address + (zpvar.size/2).toUInt()
+                asmgen.out("${scopedName.substringAfterLast('.')}_lsb \t= $lsbAddr \t; zp ${zpvar.dt} (lsbs)")
+                asmgen.out("${scopedName.substringAfterLast('.')}_msb \t= $msbAddr \t; zp ${zpvar.dt} (msbs)")
+            } else {
                 asmgen.out("${scopedName.substringAfterLast('.')} \t= ${zpvar.address} \t; zp ${zpvar.dt}")
             }
         }
+    }
 
     private fun nonZpVariables2asm(variables: List<StStaticVariable>) {
         asmgen.out("")
@@ -543,6 +588,11 @@ internal class ProgramAndVarsGen(
             DataType.UWORD -> asmgen.out("${variable.name}\t.word  ?")
             DataType.WORD -> asmgen.out("${variable.name}\t.sint  ?")
             DataType.FLOAT -> asmgen.out("${variable.name}\t.fill  ${compTarget.machine.FLOAT_MEM_SIZE}")
+            in SplitWordArrayTypes -> {
+                val numbytesPerHalf = compTarget.memorySize(variable.dt, variable.length!!) / 2
+                asmgen.out("${variable.name}_lsb\t.fill  $numbytesPerHalf")
+                asmgen.out("${variable.name}_msb\t.fill  $numbytesPerHalf")
+            }
             in ArrayDatatypes -> {
                 val numbytes = compTarget.memorySize(variable.dt, variable.length!!)
                 asmgen.out("${variable.name}\t.fill  $numbytes")
@@ -627,6 +677,18 @@ internal class ProgramAndVarsGen(
                         asmgen.out("  .sint  " + chunk.joinToString())
                 }
             }
+            DataType.ARRAY_UW_SPLIT -> {
+                val data = makeArrayFillDataUnsigned(dt, value, orNumberOfZeros)
+                asmgen.out("_array_$varname := ${data.joinToString()}")
+                asmgen.out("${varname}_lsb\t.byte <_array_$varname")
+                asmgen.out("${varname}_msb\t.byte >_array_$varname")
+            }
+            DataType.ARRAY_W_SPLIT -> {
+                val data = makeArrayFillDataSigned(dt, value, orNumberOfZeros)
+                asmgen.out("_array_$varname := ${data.joinToString()}")
+                asmgen.out("${varname}_lsb\t.byte <_array_$varname")
+                asmgen.out("${varname}_msb\t.byte >_array_$varname")
+            }
             DataType.ARRAY_F -> {
                 val array = value ?: zeroFilledArray(orNumberOfZeros!!)
                 val floatFills = array.map {
@@ -686,7 +748,7 @@ internal class ProgramAndVarsGen(
                     val number = it.number!!.toInt()
                     "$"+number.toString(16).padStart(2, '0')
                 }
-            DataType.ARRAY_UW -> array.map {
+            DataType.ARRAY_UW, DataType.ARRAY_UW_SPLIT -> array.map {
                 if(it.number!=null) {
                     "$" + it.number!!.toInt().toString(16).padStart(4, '0')
                 }
@@ -718,11 +780,11 @@ internal class ProgramAndVarsGen(
                     else
                         "-$$hexnum"
                 }
-            DataType.ARRAY_UW -> array.map {
+            DataType.ARRAY_UW, DataType.ARRAY_UW_SPLIT -> array.map {
                 val number = it.number!!.toInt()
                 "$" + number.toString(16).padStart(4, '0')
             }
-            DataType.ARRAY_W -> array.map {
+            DataType.ARRAY_W, DataType.ARRAY_W_SPLIT -> array.map {
                 val number = it.number!!.toInt()
                 val hexnum = number.absoluteValue.toString(16).padStart(4, '0')
                 if(number>=0)

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

@@ -0,0 +1,253 @@
+package prog8.codegen.cpu6502.assignment
+
+import prog8.code.ast.PtBinaryExpression
+import prog8.code.ast.PtExpression
+import prog8.code.core.*
+import prog8.code.target.C64Target
+import prog8.code.target.Cx16Target
+import prog8.codegen.cpu6502.AsmGen6502Internal
+
+//
+// This contains codegen for stack-based evaluation of binary expressions.
+// It uses the CPU stack so depth is limited.
+// It is called "as a last resort" if the optimized codegen path is unable
+// to come up with a special case of the expression.
+//
+internal class AnyExprAsmGen(
+    private val asmgen: AsmGen6502Internal
+) {
+    fun assignAnyExpressionUsingStack(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
+        when(expr.type) {
+            in ByteDatatypes -> {
+                if(expr.left.type in ByteDatatypes && expr.right.type in ByteDatatypes)
+                    return assignByteBinExpr(expr, assign)
+                if (expr.left.type in WordDatatypes && expr.right.type in WordDatatypes) {
+                    require(expr.operator in ComparisonOperators)
+                    throw AssemblyError("words operands comparison -> byte, should have been handled by assignOptimizedComparisonWords()")
+                }
+                if (expr.left.type==DataType.FLOAT && expr.right.type==DataType.FLOAT) {
+                    require(expr.operator in ComparisonOperators)
+                    return assignFloatBinExpr(expr, assign)
+                }
+                throw AssemblyError("weird expr operand types: ${expr.left.type} and ${expr.right.type}")
+            }
+            in WordDatatypes -> {
+                require(expr.left.type in WordDatatypes && expr.right.type in WordDatatypes) {
+                    "both operands must be words"
+                }
+                return assignWordBinExpr(expr)
+            }
+            DataType.FLOAT -> {
+                require(expr.left.type==DataType.FLOAT && expr.right.type==DataType.FLOAT) {
+                    "both operands must be floats"
+                }
+                return assignFloatBinExpr(expr, assign)
+            }
+            else -> throw AssemblyError("weird expression type in assignment")
+        }
+    }
+
+    private fun assignWordBinExpr(expr: PtBinaryExpression): Boolean {
+        when(expr.operator) {
+            "+" -> TODO("word + at ${expr.position}")
+            "-" -> TODO("word - at ${expr.position}")
+            "*" -> TODO("word * at ${expr.position}")
+            "/" -> TODO("word / at ${expr.position}")
+            "<<" -> TODO("word << at ${expr.position}")
+            ">>" -> TODO("word >> at ${expr.position}")
+            "%" -> TODO("word % at ${expr.position}")
+            "and" -> TODO("word logical and (with optional shortcircuit) ${expr.position}")
+            "or" -> TODO("word logical or (with optional shortcircuit) ${expr.position}")
+            "&" -> TODO("word and at ${expr.position}")
+            "|" -> TODO("word or at ${expr.position}")
+            "^", "xor" -> TODO("word xor at ${expr.position}")
+            "==" -> TODO("word == at ${expr.position}")
+            "!=" -> TODO("word != at ${expr.position}")
+            "<" -> TODO("word < at ${expr.position}")
+            "<=" -> TODO("word <= at ${expr.position}")
+            ">" -> TODO("word > at ${expr.position}")
+            ">=" -> TODO("word >= at ${expr.position}")
+            else -> return false
+        }
+    }
+
+    private fun assignByteBinExpr(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
+        when(expr.operator) {
+            "+" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  clc |  adc  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "-" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  sec |  sbc  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "*" -> {
+                TODO("byte * at ${expr.position}")
+            }
+            "/" -> {
+                TODO("byte / at ${expr.position}")
+            }
+            "<<" -> {
+                TODO("byte << at ${expr.position}")
+            }
+            ">>" -> {
+                TODO("byte >> at ${expr.position}")
+            }
+            "%" -> {
+                TODO("byte % at ${expr.position}")
+            }
+            "and" -> TODO("logical and (with optional shortcircuit) ${expr.position}")
+            "or" -> TODO("logical or (with optional shortcircuit) ${expr.position}")
+            "&" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  and  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "|" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  ora  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "^", "xor" -> {
+                asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.A, false)
+                asmgen.out("  pha")
+                asmgen.assignExpressionToVariable(expr.right, "P8ZP_SCRATCH_B1", DataType.UBYTE)
+                asmgen.out("  pla |  eor  P8ZP_SCRATCH_B1")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "==" -> {
+                TODO("byte == at ${expr.position}")
+            }
+            "!=" -> {
+                TODO("byte != at ${expr.position}")
+            }
+            "<" -> {
+                TODO("byte < at ${expr.position}")
+            }
+            "<=" -> {
+                TODO("byte <= at ${expr.position}")
+            }
+            ">" -> {
+                TODO("byte > at ${expr.position}")
+            }
+            ">=" -> {
+                TODO("byte >= at ${expr.position}")
+            }
+            else -> return false
+        }
+    }
+
+    private fun assignFloatBinExpr(expr: PtBinaryExpression, assign: AsmAssignment): Boolean {
+        when(expr.operator) {
+            "+" -> {
+                assignFloatOperandsToFACandARG(expr.left, expr.right)
+                asmgen.out("  jsr  floats.FADDT")
+                asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
+                return true
+            }
+            "-" -> {
+                assignFloatOperandsToFACandARG(expr.right, expr.left)
+                asmgen.out("  jsr  floats.FSUBT")
+                asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
+                return true
+            }
+            "*" -> {
+                assignFloatOperandsToFACandARG(expr.left, expr.right)
+                asmgen.out("  jsr  floats.FMULTT")
+                asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
+                return true
+            }
+            "/" -> {
+                assignFloatOperandsToFACandARG(expr.right, expr.left)
+                asmgen.out("  jsr  floats.FDIVT")
+                asmgen.assignRegister(RegisterOrPair.FAC1, assign.target)
+                return true
+            }
+            "==" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_equal_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "!=" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_notequal_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "<" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_less_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            ">" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_greater_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            "<=" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_lesseq_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            ">=" -> {
+                setupFloatComparisonFAC1vsVarAY(expr)
+                asmgen.out("  jsr  floats.var_fac1_greatereq_f")
+                asmgen.assignRegister(RegisterOrPair.A, assign.target)
+                return true
+            }
+            else -> TODO("float expression operator ${expr.operator}")
+        }
+    }
+
+    private fun assignFloatOperandsToFACandARG(left: PtExpression, right: PtExpression) {
+        when(asmgen.options.compTarget.name) {
+            C64Target.NAME -> {
+                // c64 has a quirk: always make sure FAC2 is loaded last (done using CONUPK)  otherwise the result will be corrupt on C64
+                // this requires some more forced copying around of float values in certain cases
+                if (right.isSimple()) {
+                    asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1, true)
+                    asmgen.assignExpressionToRegister(right, RegisterOrPair.FAC2, true)
+                } else {
+                    asmgen.assignExpressionToRegister(right, RegisterOrPair.FAC1, true)
+                    asmgen.pushFAC1()
+                    asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1, true)
+                    asmgen.popFAC2()
+                }
+            }
+            Cx16Target.NAME -> {
+                asmgen.assignExpressionToRegister(left, RegisterOrPair.FAC1, true)
+                if (!right.isSimple()) asmgen.pushFAC1()
+                asmgen.assignExpressionToRegister(right, RegisterOrPair.FAC2, true)
+                if (!right.isSimple()) asmgen.popFAC1()
+            }
+            else -> TODO("don't know how to evaluate float expression for selected compilation target")
+        }
+    }
+
+    private fun setupFloatComparisonFAC1vsVarAY(expr: PtBinaryExpression) {
+        asmgen.assignExpressionToRegister(expr.left, RegisterOrPair.FAC1, true)
+        if(!expr.right.isSimple()) asmgen.pushFAC1()
+        asmgen.assignExpressionToVariable(expr.right, "floats.floats_temp_var", DataType.FLOAT)
+        if(!expr.right.isSimple()) asmgen.popFAC1()
+        asmgen.out("  lda  #<floats.floats_temp_var |  ldy  #>floats.floats_temp_var")
+    }
+}

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

@@ -10,8 +10,7 @@ internal enum class TargetStorageKind {
     VARIABLE,
     ARRAY,
     MEMORY,
-    REGISTER,
-    STACK
+    REGISTER
 }
 
 internal enum class SourceStorageKind {
@@ -20,7 +19,6 @@ internal enum class SourceStorageKind {
     ARRAY,
     MEMORY,
     REGISTER,
-    STACK,              // value is already present on stack
     EXPRESSION,         // expression in ast-form, still to be evaluated
 }
 
@@ -115,12 +113,12 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                 left is PtIdentifier && left.name==scopedName
             }
             TargetStorageKind.ARRAY -> {
-                left is PtArrayIndexer && left isSameAs array!!
+                left is PtArrayIndexer && left isSameAs array!! && left.splitWords==array.splitWords
             }
             TargetStorageKind.MEMORY -> {
                 left isSameAs memory!!
             }
-            TargetStorageKind.REGISTER, TargetStorageKind.STACK -> {
+            TargetStorageKind.REGISTER -> {
                 false
             }
         }
@@ -178,8 +176,8 @@ internal class AsmAssignSource(val kind: SourceStorageKind,
                     AsmAssignSource(SourceStorageKind.EXPRESSION, program, asmgen, value.type, expression = value)
                 }
                 is PtFunctionCall -> {
-                    val symbol = asmgen.symbolTable.lookup(value.name)
-                    val sub = symbol!!.astNode as IPtSubroutine
+                    val symbol = asmgen.symbolTable.lookup(value.name) ?: throw AssemblyError("lookup error ${value.name}")
+                    val sub = symbol.astNode as IPtSubroutine
                     val returnType = sub.returnsWhatWhere().firstOrNull { rr -> rr.first.registerOrPair != null || rr.first.statusflag!=null }?.second
                             ?: throw AssemblyError("can't translate zero return values in assignment")
 

codeGenCpu6502/test/Dummies.kt

@@ -18,6 +18,8 @@ internal object DummyMemsizer : IMemSizer {
 }
 
 internal object DummyStringEncoder : IStringEncoding {
+    override val defaultEncoding: Encoding = Encoding.ISO
+
     override fun encodeString(str: String, encoding: Encoding): List<UByte> {
         return emptyList()
     }
@@ -27,11 +29,11 @@ internal object DummyStringEncoder : IStringEncoding {
     }
 }
 
-internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true, private val keepMessagesAfterReporting: Boolean=false):
-    IErrorReporter {
+internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true, private val keepMessagesAfterReporting: Boolean=false): IErrorReporter {
 
     val errors = mutableListOf<String>()
     val warnings = mutableListOf<String>()
+    val infos = mutableListOf<String>()
 
     override fun err(msg: String, position: Position) {
         val text = "${position.toClickableStr()} $msg"
@@ -45,13 +47,24 @@ internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors:
             warnings.add(text)
     }
 
+    override fun info(msg: String, position: Position) {
+        val text = "${position.toClickableStr()} $msg"
+        if(text !in infos)
+            infos.add(text)
+    }
+
+    override fun undefined(symbol: List<String>, position: Position) {
+        err("undefined symbol: ${symbol.joinToString(".")}", position)
+    }
+
     override fun noErrors(): Boolean  = errors.isEmpty()
 
     override fun report() {
+        infos.forEach { println("UNITTEST COMPILATION REPORT: INFO: $it") }
         warnings.forEach { println("UNITTEST COMPILATION REPORT: WARNING: $it") }
         errors.forEach { println("UNITTEST COMPILATION REPORT: ERROR: $it") }
         if(throwExceptionAtReportIfErrors)
-            finalizeNumErrors(errors.size, warnings.size)
+            finalizeNumErrors(errors.size, warnings.size, infos.size)
         if(!keepMessagesAfterReporting) {
             clear()
         }
@@ -60,5 +73,6 @@ internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors:
     fun clear() {
         errors.clear()
         warnings.clear()
+        infos.clear()
     }
 }

codeGenCpu6502/test/TestCodegen.kt

@@ -1,7 +1,9 @@
 package prog8tests.codegencpu6502
 
 import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.assertions.withClue
 import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.ints.shouldBeGreaterThanOrEqual
 import io.kotest.matchers.shouldBe
 import prog8.code.SymbolTableMaker
 import prog8.code.ast.*
@@ -20,6 +22,7 @@ class TestCodegen: FunSpec({
             CbmPrgLauncherType.NONE,
             ZeropageType.DONTUSE,
             zpReserved = emptyList(),
+            zpAllowed = CompilationOptions.AllZeropageAllowed,
             floats = true,
             noSysInit = false,
             compTarget = target,
@@ -40,9 +43,9 @@ class TestCodegen: FunSpec({
 //        xx += cx16.r0
 //    }
 //}
-        val codegen = AsmGen6502()
+        val codegen = AsmGen6502(prefixSymbols = false)
         val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
-        val block = PtBlock("main", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val block = PtBlock("main",false, SourceCode.Generated("test"), PtBlock.Options(), Position.DUMMY)
         val sub = PtSub("start", emptyList(), null, Position.DUMMY)
         sub.add(PtVariable("pi", DataType.UBYTE, ZeropageWish.DONTCARE, PtNumber(DataType.UBYTE, 0.0, Position.DUMMY), null, Position.DUMMY))
         sub.add(PtVariable("particleX", DataType.ARRAY_UB, ZeropageWish.DONTCARE, null, 3u, Position.DUMMY))
@@ -92,7 +95,7 @@ class TestCodegen: FunSpec({
         program.add(block)
 
         // define the "cx16.r0" virtual register
-        val cx16block = PtBlock("cx16", null, false, false, PtBlock.BlockAlignment.NONE, SourceCode.Generated("test"), Position.DUMMY)
+        val cx16block = PtBlock("cx16", false, SourceCode.Generated("test"), PtBlock.Options(), Position.DUMMY)
         cx16block.add(PtMemMapped("r0", DataType.UWORD, 100u, null, Position.DUMMY))
         program.add(cx16block)
 
@@ -104,12 +107,22 @@ class TestCodegen: FunSpec({
         Files.deleteIfExists(Path("${result.name}.asm"))
     }
 
-    test("64tass assembler available? - if this fails you need to install 64tass in the path") {
+    test("64tass assembler available? - if this fails you need to install 64tass version 1.58 or newer in the path") {
         val command = mutableListOf("64tass", "--version")
         shouldNotThrowAny {
-            val proc = ProcessBuilder(command).inheritIO().start()
+            val proc = ProcessBuilder(command).start()
+            val output = String(proc.inputStream.readBytes())
             val result = proc.waitFor()
             result.shouldBe(0)
+            val (_, version) = output.split('V')
+            val (major, minor, _) = version.split('.')
+            val majorNum = major.toInt()
+            val minorNum = minor.toInt()
+            withClue("64tass version should be 1.58 or newer") {
+                majorNum shouldBeGreaterThanOrEqual 1
+                if (majorNum == 1)
+                    minorNum shouldBeGreaterThanOrEqual 58
+            }
         }
     }
 })

codeGenExperimental/build.gradle

@@ -29,17 +29,17 @@ dependencies {
     implementation project(':codeGenIntermediate')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
 
 }
 
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
 }

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

@@ -15,7 +15,7 @@ class ExperiCodeGen: ICodeGeneratorBackend {
         symbolTable: SymbolTable,
         options: CompilationOptions,
         errors: IErrorReporter
-    ): IAssemblyProgram? {
+    ): 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:
@@ -26,6 +26,15 @@ class ExperiCodeGen: ICodeGeneratorBackend {
         IRFileWriter(irProgram, null).write()
 
         println("** experimental codegen stub: no assembly generated **")
-        return null
+        return EmptyProgram
     }
 }
+
+private object EmptyProgram : IAssemblyProgram {
+    override val name = "<Empty Program>"
+    override fun assemble(options: CompilationOptions, errors: IErrorReporter): Boolean {
+        println("** nothing assembled **")
+        return true
+    }
+
+}

codeGenIntermediate/build.gradle

@@ -28,18 +28,18 @@ dependencies {
     implementation project(':intermediate')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.5.5'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
 }
 
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
     test {

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

@@ -13,7 +13,9 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         if(assignment.target.children.single() is PtMachineRegister)
             throw AssemblyError("assigning to a register should be done by just evaluating the expression into resultregister")
 
-        return translateRegularAssign(assignment)
+        val chunks = translateRegularAssign(assignment)
+        chunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(assignment.position)
+        return chunks
     }
 
     internal fun translate(augAssign: PtAugmentedAssign): IRCodeChunks {
@@ -24,7 +26,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         val memory = augAssign.target.memory
         val array = augAssign.target.array
 
-        return if(ident!=null) {
+        val chunks = if(ident!=null) {
             assignVarAugmented(ident.name, augAssign)
         } else if(memory != null) {
             if(memory.address is PtNumber)
@@ -39,6 +41,8 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         } else {
             fallbackAssign(augAssign)
         }
+        chunks.filterIsInstance<IRCodeChunk>().firstOrNull()?.appendSrcPosition(augAssign.position)
+        return chunks
     }
 
     private fun assignMemoryAugmented(
@@ -46,25 +50,26 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         assignment: PtAugmentedAssign
     ): IRCodeChunks {
         val value = assignment.value
-        val vmDt = irType(value.type)
+        val targetDt = irType(assignment.target.type)
+        val signed = assignment.target.type in SignedDatatypes
         return when(assignment.operator) {
-            "+" -> expressionEval.operatorPlusInplace(address, null, vmDt, value)
-            "-" -> expressionEval.operatorMinusInplace(address, null, vmDt, value)
-            "*" -> expressionEval.operatorMultiplyInplace(address, null, vmDt, value)
-            "/" -> expressionEval.operatorDivideInplace(address, null, vmDt, value.type in SignedDatatypes, value)
-            "|" -> expressionEval.operatorOrInplace(address, null, vmDt, value)
-            "&" -> expressionEval.operatorAndInplace(address, null, vmDt, value)
-            "^" -> 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)
+            "+=" -> expressionEval.operatorPlusInplace(address, null, targetDt, value)
+            "-=" -> expressionEval.operatorMinusInplace(address, null, targetDt, value)
+            "*=" -> expressionEval.operatorMultiplyInplace(address, null, targetDt, value)
+            "/=" -> expressionEval.operatorDivideInplace(address, null, targetDt, signed, value)
+            "|=" -> expressionEval.operatorOrInplace(address, null, targetDt, value)
+            "&=" -> expressionEval.operatorAndInplace(address, null, targetDt, value)
+            "^=" -> expressionEval.operatorXorInplace(address, null, targetDt, value)
+            "<<=" -> expressionEval.operatorShiftLeftInplace(address, null, targetDt, value)
+            ">>=" -> expressionEval.operatorShiftRightInplace(address, null, targetDt, signed, value)
+            "%=" -> expressionEval.operatorModuloInplace(address, null, targetDt, value)
+            "==" -> expressionEval.operatorEqualsInplace(address, null, targetDt, value)
+            "!=" -> expressionEval.operatorNotEqualsInplace(address, null, targetDt, value)
+            "<" -> expressionEval.operatorLessInplace(address, null, targetDt, signed, value)
+            ">" -> expressionEval.operatorGreaterInplace(address, null, targetDt, signed, value)
+            "<=" -> expressionEval.operatorLessEqualInplace(address, null, targetDt, signed, value)
+            ">=" -> expressionEval.operatorGreaterEqualInplace(address, null, targetDt, signed, value)
+            in PrefixOperators -> inplacePrefix(assignment.operator, targetDt, address, null)
 
             else -> throw AssemblyError("invalid augmented assign operator ${assignment.operator}")
         }
@@ -72,60 +77,44 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
 
     private fun assignVarAugmented(symbol: String, assignment: PtAugmentedAssign): IRCodeChunks {
         val value = assignment.value
+        val signed = assignment.target.type in SignedDatatypes
         val targetDt = irType(assignment.target.type)
-        return when (assignment.operator) {
+        return when(assignment.operator) {
             "+=" -> 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.operatorDivideInplace(null, symbol, targetDt, signed, value)
             "|=" -> expressionEval.operatorOrInplace(null, symbol, targetDt, value)
+            "or=" -> expressionEval.operatorLogicalOrInplace(null, symbol, targetDt, value)
             "&=" -> expressionEval.operatorAndInplace(null, symbol, targetDt, value)
-            "^=" -> expressionEval.operatorXorInplace(null, symbol, targetDt, value)
+            "and=" -> expressionEval.operatorLogicalAndInplace(null, symbol, targetDt, value)
+            "^=", "xor=" -> expressionEval.operatorXorInplace(null, symbol, targetDt, value)
             "<<=" -> expressionEval.operatorShiftLeftInplace(null, symbol, targetDt, value)
-            ">>=" -> expressionEval.operatorShiftRightInplace(null, symbol, targetDt, value.type in SignedDatatypes, value)
+            ">>=" -> expressionEval.operatorShiftRightInplace(null, symbol, targetDt, signed, 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)
+            "<" -> expressionEval.operatorLessInplace(null, symbol, targetDt, signed, value)
+            ">" -> expressionEval.operatorGreaterInplace(null, symbol, targetDt, signed, value)
+            "<=" -> expressionEval.operatorLessEqualInplace(null, symbol, targetDt, signed, value)
+            ">=" -> expressionEval.operatorGreaterEqualInplace(null, symbol, targetDt, signed, value)
             in PrefixOperators -> inplacePrefix(assignment.operator, targetDt, null, symbol)
             else -> throw AssemblyError("invalid augmented assign operator ${assignment.operator}")
         }
     }
 
     private fun fallbackAssign(origAssign: PtAugmentedAssign): IRCodeChunks {
-        if (codeGen.options.slowCodegenWarnings)
-            codeGen.errors.warn("indirect code for in-place assignment", origAssign.position)
         val value: PtExpression
         if(origAssign.operator in PrefixOperators) {
-            value = PtPrefix(origAssign.operator, origAssign.value.type, origAssign.value.position)
+            value = PtPrefix(origAssign.operator, origAssign.target.type, origAssign.value.position)
             value.add(origAssign.value)
         } else {
             require(origAssign.operator.endsWith('='))
-            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)
+            value = PtBinaryExpression(origAssign.operator.dropLast(1), origAssign.target.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)
@@ -184,15 +173,18 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
                 } 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)
+                    if(extendByteToWord) {
+                        valueRegister = codeGen.registers.nextFree()
+                        addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=valueRegister, reg2=(assignment.value as PtMachineRegister).register), null)
+                    }
                 } else {
                     val tr = expressionEval.translateExpression(assignment.value)
                     valueRegister = tr.resultReg
                     addToResult(result, tr, valueRegister, -1)
                     if(extendByteToWord) {
+                        valueRegister = codeGen.registers.nextFree()
                         val opcode = if(assignment.value.type in SignedDatatypes) Opcode.EXTS else Opcode.EXT
-                        addInstr(result, IRInstruction(opcode, IRDataType.BYTE, reg1 = valueRegister), null)
+                        addInstr(result, IRInstruction(opcode, IRDataType.BYTE, reg1=valueRegister, reg2=tr.resultReg), null)
                     }
                 }
             }
@@ -214,8 +206,7 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             val variable = targetArray.variable.name
             val itemsize = codeGen.program.memsizer.memorySize(targetArray.type)
 
-            if(targetArray.variable.type==DataType.UWORD) {
-                // indexing a pointer var instead of a real array or string
+            if(targetArray.usesPointerVariable) {
                 if(itemsize!=1)
                     throw AssemblyError("non-array var indexing requires bytes dt")
                 if(targetArray.index.type!=DataType.UBYTE)
@@ -235,36 +226,71 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
             }
 
             val fixedIndex = constIntValue(targetArray.index)
+            val arrayLength = codeGen.symbolTable.getLength(targetArray.variable.name)
             if(zero) {
                 if(fixedIndex!=null) {
-                    val offset = fixedIndex*itemsize
-                    val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZM, targetDt, labelSymbol = "$variable+$offset") }
+                    val chunk = IRCodeChunk(null, null).also {
+                        if(targetArray.splitWords) {
+                            it += IRInstruction(Opcode.STOREZM, IRDataType.BYTE, immediate = arrayLength, labelSymbol = "${variable}_lsb", symbolOffset = fixedIndex)
+                            it += IRInstruction(Opcode.STOREZM, IRDataType.BYTE, immediate = arrayLength, labelSymbol = "${variable}_msb", symbolOffset = fixedIndex)
+                        }
+                        else
+                            it += IRInstruction(Opcode.STOREZM, targetDt, labelSymbol = variable, symbolOffset = fixedIndex*itemsize)
+                    }
                     result += chunk
                 } else {
                     val (code, indexReg) = loadIndexReg(targetArray, itemsize)
                     result += code
-                    result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREZX, targetDt, reg1=indexReg, labelSymbol = variable) }
+                    result += IRCodeChunk(null, null).also {
+                        if(targetArray.splitWords) {
+                            it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1 = indexReg, immediate = arrayLength, labelSymbol = variable+"_lsb")
+                            it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1 = indexReg, immediate = arrayLength, labelSymbol = variable+"_msb")
+                        }
+                        else
+                            it += IRInstruction(Opcode.STOREZX, targetDt, reg1=indexReg, labelSymbol = variable)
+                    }
                 }
             } else {
                 if(targetDt== IRDataType.FLOAT) {
                     if(fixedIndex!=null) {
                         val offset = fixedIndex*itemsize
-                        val chunk = IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREM, targetDt, fpReg1 = valueFpRegister, labelSymbol = "$variable+$offset") }
+                        val chunk = IRCodeChunk(null, null).also {
+                            it += IRInstruction(Opcode.STOREM, targetDt, fpReg1 = valueFpRegister, labelSymbol = variable, symbolOffset = offset)
+                        }
                         result += chunk
                     } else {
                         val (code, indexReg) = loadIndexReg(targetArray, itemsize)
                         result += code
-                        result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREX, targetDt, reg1 = indexReg, fpReg1 = valueFpRegister, labelSymbol = variable) }
+                        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, targetDt, reg1 = valueRegister, labelSymbol = "$variable+$offset") }
+                        val chunk = IRCodeChunk(null, null).also {
+                            if(targetArray.splitWords) {
+                                val msbReg = codeGen.registers.nextFree()
+                                it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = valueRegister, immediate = arrayLength, labelSymbol = "${variable}_lsb", symbolOffset = fixedIndex)
+                                it += IRInstruction(Opcode.MSIG, IRDataType.BYTE, reg1 = msbReg, reg2 = valueRegister)
+                                it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = msbReg, immediate = arrayLength, labelSymbol = "${variable}_msb", symbolOffset = fixedIndex)
+                            }
+                            else
+                                it += IRInstruction(Opcode.STOREM, targetDt, reg1 = valueRegister, labelSymbol = variable, symbolOffset = fixedIndex*itemsize)
+                        }
                         result += chunk
                     } else {
                         val (code, indexReg) = loadIndexReg(targetArray, itemsize)
                         result += code
-                        result += IRCodeChunk(null, null).also { it += IRInstruction(Opcode.STOREX, targetDt, reg1 = valueRegister, reg2=indexReg, labelSymbol = variable) }
+                        result += IRCodeChunk(null, null).also {
+                            if(targetArray.splitWords) {
+                                val msbReg = codeGen.registers.nextFree()
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1 = valueRegister, reg2=indexReg, immediate = arrayLength, labelSymbol = "${variable}_lsb")
+                                it += IRInstruction(Opcode.MSIG, IRDataType.BYTE, reg1 = msbReg, reg2 = valueRegister)
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1 = msbReg, reg2=indexReg, immediate = arrayLength, labelSymbol = "${variable}_msb")
+                            }
+                            else
+                                it += IRInstruction(Opcode.STOREX, targetDt, reg1 = valueRegister, reg2=indexReg, labelSymbol = variable)
+                        }
                     }
                 }
             }
@@ -301,21 +327,15 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
     }
 
     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.
+        // returns the code to load the Index into the register, which is also returned.
 
         val result = mutableListOf<IRCodeChunkBase>()
-        if(itemsize==1) {
+        if(itemsize==1 || array.splitWords) {
             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: PtExpression
         mult = PtBinaryExpression("*", DataType.UBYTE, array.position)
         mult.children += array.index
@@ -324,5 +344,4 @@ internal class AssignmentGen(private val codeGen: IRCodeGen, private val express
         addToResult(result, tr, tr.resultReg, -1)
         return Pair(result, tr.resultReg)
     }
-    }
 }

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

@@ -1,9 +1,10 @@
 package prog8.codegen.intermediate
 
-import prog8.code.StStaticVariable
 import prog8.code.ast.*
 import prog8.code.core.AssemblyError
 import prog8.code.core.DataType
+import prog8.code.core.SignedDatatypes
+import prog8.code.core.SplitWordArrayTypes
 import prog8.intermediate.*
 
 
@@ -13,41 +14,84 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         return when(call.name) {
             "any" -> funcAny(call)
             "all" -> funcAll(call)
-            "abs" -> funcAbs(call)
+            "abs__byte", "abs__word", "abs__float" -> funcAbs(call)
             "cmp" -> funcCmp(call)
             "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)
-            "pushw" -> funcPushw(call)
-            "rsave",
-            "rsavex",
-            "rrestore",
-            "rrestorex" -> ExpressionCodeResult.EMPTY  // vm doesn't have registers to save/restore
-            "callfar" -> throw AssemblyError("callfar() is for cx16 target only")
+            "sqrt__ubyte", "sqrt__uword", "sqrt__float" -> funcSqrt(call)
+            "divmod__ubyte" -> funcDivmod(call, IRDataType.BYTE)
+            "divmod__uword" -> funcDivmod(call, IRDataType.WORD)
+            "rsave", "rrestore" -> ExpressionCodeResult.EMPTY  // vm doesn't have registers to save/restore
+            "callfar" -> funcCallfar(call)
+            "call" -> funcCall(call)
             "msb" -> funcMsb(call)
             "lsb" -> funcLsb(call)
             "memory" -> funcMemory(call)
-            "peek" -> funcPeek(call)
-            "peekw" -> funcPeekW(call)
-            "poke" -> funcPoke(call)
-            "pokew" -> funcPokeW(call)
-            "pokemon" -> ExpressionCodeResult.EMPTY     // easter egg function
+            "peek" -> funcPeek(call, IRDataType.BYTE)
+            "peekw" -> funcPeek(call, IRDataType.WORD)
+            "peekf" -> funcPeek(call, IRDataType.FLOAT)
+            "poke" -> funcPoke(call, IRDataType.BYTE)
+            "pokew" -> funcPoke(call, IRDataType.WORD)
+            "pokef" -> funcPoke(call, IRDataType.FLOAT)
+            "pokemon" -> funcPokemon(call)
             "mkword" -> funcMkword(call)
+            "clamp__byte", "clamp__ubyte", "clamp__word", "clamp__uword" -> funcClamp(call)
+            "min__byte", "min__ubyte", "min__word", "min__uword" -> funcMin(call)
+            "max__byte", "max__ubyte", "max__word", "max__uword" -> funcMax(call)
             "sort" -> funcSort(call)
             "reverse" -> funcReverse(call)
-            "rol" -> funcRolRor(Opcode.ROXL, call)
-            "ror" -> funcRolRor(Opcode.ROXR, call)
-            "rol2" -> funcRolRor(Opcode.ROL, call)
-            "ror2" -> funcRolRor(Opcode.ROR, call)
+            "setlsb" -> funcSetLsbMsb(call, false)
+            "setmsb" -> funcSetLsbMsb(call, true)
+            "rol" -> funcRolRor(call)
+            "ror" -> funcRolRor(call)
+            "rol2" -> funcRolRor(call)
+            "ror2" -> funcRolRor(call)
             "prog8_lib_stringcompare" -> funcStringCompare(call)
+            "prog8_lib_square_byte" -> funcSquare(call, IRDataType.BYTE)
+            "prog8_lib_square_word" -> funcSquare(call, IRDataType.WORD)
             else -> throw AssemblyError("missing builtinfunc for ${call.name}")
         }
     }
 
+    private fun funcSquare(call: PtBuiltinFunctionCall, resultType: IRDataType): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val valueTr = exprGen.translateExpression(call.args[0])
+        addToResult(result, valueTr, valueTr.resultReg, valueTr.resultFpReg)
+        return if(resultType==IRDataType.FLOAT) {
+            val resultFpReg = codeGen.registers.nextFreeFloat()
+            addInstr(result, IRInstruction(Opcode.SQUARE, resultType, fpReg1 = resultFpReg, fpReg2 = valueTr.resultFpReg), null)
+            ExpressionCodeResult(result, resultType, -1, resultFpReg)
+        }
+        else {
+            val resultReg = codeGen.registers.nextFree()
+            addInstr(result, IRInstruction(Opcode.SQUARE, resultType, reg1 = resultReg, reg2 = valueTr.resultReg), null)
+            ExpressionCodeResult(result, resultType, resultReg, -1)
+        }
+    }
+
+    private fun funcCall(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val addressTr = exprGen.translateExpression(call.args[0])
+        addToResult(result, addressTr, addressTr.resultReg, -1)
+        addInstr(result, IRInstruction(Opcode.CALLI, reg1 = addressTr.resultReg), null)
+        if(call.void)
+            return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+        else
+            return ExpressionCodeResult(result, IRDataType.WORD, codeGen.registers.nextFree(), -1)      // TODO actually the result is returned in CPU registers AY...
+    }
+
+    private fun funcCallfar(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
+        val bankTr = exprGen.translateExpression(call.args[0])
+        val addressTr = exprGen.translateExpression(call.args[1])
+        val argumentwordTr = exprGen.translateExpression(call.args[2])
+        addToResult(result, bankTr, bankTr.resultReg, -1)
+        addToResult(result, addressTr, addressTr.resultReg, -1)
+        addToResult(result, argumentwordTr, argumentwordTr.resultReg, -1)
+        result += codeGen.makeSyscall(IMSyscall.CALLFAR, listOf(IRDataType.BYTE to bankTr.resultReg, IRDataType.WORD to addressTr.resultReg, IRDataType.WORD to argumentwordTr.resultReg), IRDataType.WORD to argumentwordTr.resultReg)
+        return ExpressionCodeResult(result, IRDataType.WORD, argumentwordTr.resultReg, -1)
+    }
+
     private fun funcDivmod(call: PtBuiltinFunctionCall, type: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         val number = call.args[0]
@@ -79,6 +123,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
     private fun funcStringCompare(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
         val left  = exprGen.translateExpression(call.args[0])
         val right = exprGen.translateExpression(call.args[1])
         addToResult(result, left, left.resultReg, -1)
@@ -102,9 +147,34 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
 
     private fun funcAny(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
-        val array = codeGen.symbolTable.flat.getValue(arrayName.name) as StStaticVariable
+        val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
+        val result = mutableListOf<IRCodeChunkBase>()
+        val lengthReg = codeGen.registers.nextFree()
+
+        if(arrayName.type in SplitWordArrayTypes) {
+            // any(lsb-array) or any(msb-array)
+            addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
+            val trLsb = exprGen.translateExpression(PtIdentifier(arrayName.name+"_lsb", DataType.ARRAY_UB, call.position))
+            addToResult(result, trLsb, trLsb.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = arrayLength), null)
+            result += codeGen.makeSyscall(IMSyscall.ANY_BYTE, listOf(IRDataType.WORD to trLsb.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to trLsb.resultReg)
+            val shortcircuitLabel = codeGen.createLabelName()
+            result += IRCodeChunk(null, null).also {
+                it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1 = trLsb.resultReg, immediate = 0)
+                it += IRInstruction(Opcode.BSTNE, labelSymbol = shortcircuitLabel)
+                it += IRInstruction(Opcode.PREPARECALL, immediate = 2)
+            }
+            val trMsb = exprGen.translateExpression(PtIdentifier(arrayName.name+"_msb", DataType.ARRAY_UB, call.position))
+            addToResult(result, trMsb, trMsb.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = arrayLength), null)
+            result += codeGen.makeSyscall(IMSyscall.ANY_BYTE, listOf(IRDataType.WORD to trMsb.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to trMsb.resultReg)
+            addInstr(result, IRInstruction(Opcode.ORR, IRDataType.BYTE, reg1=trLsb.resultReg, reg2=trMsb.resultReg), null)
+            result += IRCodeChunk(shortcircuitLabel, null)
+            return ExpressionCodeResult(result, IRDataType.BYTE, trLsb.resultReg, -1)
+        }
+
         val syscall =
-            when (array.dt) {
+            when (arrayName.type) {
                 DataType.ARRAY_UB,
                 DataType.ARRAY_B -> IMSyscall.ANY_BYTE
                 DataType.ARRAY_UW,
@@ -112,20 +182,25 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 DataType.ARRAY_F -> IMSyscall.ANY_FLOAT
                 else -> throw IllegalArgumentException("weird type")
             }
-        val result = mutableListOf<IRCodeChunkBase>()
-        val tr = exprGen.translateExpression(call.args[0])
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
+        val tr = exprGen.translateExpression(arrayName)
         addToResult(result, tr, tr.resultReg, -1)
-        val lengthReg = codeGen.registers.nextFree()
-        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = array.length), null)
+        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = arrayLength), null)
         result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to tr.resultReg)
         return ExpressionCodeResult(result, IRDataType.BYTE, tr.resultReg, -1)
     }
 
     private fun funcAll(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
-        val array = codeGen.symbolTable.flat.getValue(arrayName.name) as StStaticVariable
+        val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
+
+        if(arrayName.type in SplitWordArrayTypes) {
+            // this is a bit complicated to calculate.... have to check all recombined (lsb,msb) words for $0000
+            TODO("all(split words $arrayName)")
+        }
+
         val syscall =
-            when(array.dt) {
+            when(arrayName.type) {
                 DataType.ARRAY_UB,
                 DataType.ARRAY_B -> IMSyscall.ALL_BYTE
                 DataType.ARRAY_UW,
@@ -134,10 +209,11 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 else -> throw IllegalArgumentException("weird type")
             }
         val result = mutableListOf<IRCodeChunkBase>()
-        val tr = exprGen.translateExpression(call.args[0])
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
+        val tr = exprGen.translateExpression(arrayName)
         addToResult(result, tr, tr.resultReg, -1)
         val lengthReg = codeGen.registers.nextFree()
-        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = array.length), null)
+        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = arrayLength), 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)
     }
@@ -151,21 +227,13 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         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)
-                }
-                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.BSTPOS, 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)
@@ -175,32 +243,54 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 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.BSTPOS, 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")
+            DataType.FLOAT -> {
+                val resultFpReg = codeGen.registers.nextFreeFloat()
+                addInstr(result, IRInstruction(Opcode.FABS, IRDataType.FLOAT, fpReg1 = resultFpReg, fpReg2 = tr.resultFpReg), null)
+                return ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpReg)
+            }
+            else -> throw AssemblyError("weird dt")
         }
     }
 
     private fun funcSgn(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        val vmDt = irType(call.type)
         val tr = exprGen.translateExpression(call.args.single())
+        val resultReg = codeGen.registers.nextFree()
+
+        if(tr.dt==IRDataType.FLOAT) {
+            addToResult(result, tr, -1, tr.resultFpReg)
+            result += IRCodeChunk(null, null).also {
+                it += IRInstruction(Opcode.SGN, tr.dt, reg1 = resultReg, fpReg1 = tr.resultFpReg)
+            }
+        } else {
+            addToResult(result, tr, tr.resultReg, -1)
+            result += IRCodeChunk(null, null).also {
+                it += IRInstruction(Opcode.SGN, tr.dt, reg1 = resultReg, reg2 = tr.resultReg)
+            }
+        }
+        return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
+    }
+
+    private fun funcSqrt(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = exprGen.translateExpression(call.args.single())
+        val dt = call.args[0].type
+        when(dt) {
+            DataType.UBYTE -> {
                 addToResult(result, tr, tr.resultReg, -1)
                 val resultReg = codeGen.registers.nextFree()
                 result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.SGN, vmDt, reg1 = resultReg, reg2 = tr.resultReg)
+                    it += IRInstruction(Opcode.SQRT, IRDataType.BYTE, reg1=resultReg, reg2=tr.resultReg)
                 }
-        return ExpressionCodeResult(result, vmDt, resultReg, -1)
+                return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
             }
-
-    private fun funcSqrt16(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val result = mutableListOf<IRCodeChunkBase>()
-        val tr = exprGen.translateExpression(call.args.single())
+            DataType.UWORD -> {
                 addToResult(result, tr, tr.resultReg, -1)
                 val resultReg = codeGen.registers.nextFree()
                 result += IRCodeChunk(null, null).also {
@@ -208,210 +298,312 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
                 }
                 return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
             }
-
-    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 ExpressionCodeResult(result, IRDataType.BYTE, reg, -1)
-    }
-
-    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 ExpressionCodeResult(result, IRDataType.WORD, reg, -1)
-    }
-
-    private fun funcPush(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val result = mutableListOf<IRCodeChunkBase>()
-        val tr = exprGen.translateExpression(call.args.single())
-        addToResult(result, tr, tr.resultReg, -1)
+            DataType.FLOAT -> {
+                addToResult(result, tr, -1, tr.resultFpReg)
+                val resultFpReg = codeGen.registers.nextFreeFloat()
                 result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.PUSH, IRDataType.BYTE, reg1=tr.resultReg)
+                    it += IRInstruction(Opcode.SQRT, IRDataType.FLOAT, fpReg1 = resultFpReg, fpReg2 = tr.resultFpReg)
                 }
-        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+                return ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpReg)
             }
-
-    private fun funcPushw(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val result = mutableListOf<IRCodeChunkBase>()
-        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 = tr.resultReg)
+            else -> throw AssemblyError("invalid dt")
         }
-        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
     private fun funcReverse(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
-        val array = codeGen.symbolTable.flat.getValue(arrayName.name) as StStaticVariable
+        val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
+        val lengthReg = codeGen.registers.nextFree()
+        val result = mutableListOf<IRCodeChunkBase>()
+
+        if(arrayName.type in SplitWordArrayTypes) {
+            // reverse the lsb and msb arrays both, independently
+            addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
+            val trLsb = exprGen.translateExpression(PtIdentifier(arrayName.name+"_lsb", DataType.ARRAY_UB, call.position))
+            addToResult(result, trLsb, trLsb.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(arrayName.type==DataType.STR) arrayLength!!-1 else arrayLength), null)
+            result += codeGen.makeSyscall(IMSyscall.REVERSE_BYTES, listOf(IRDataType.WORD to trLsb.resultReg, IRDataType.BYTE to lengthReg), null)
+            val trMsb = exprGen.translateExpression(PtIdentifier(arrayName.name+"_msb", DataType.ARRAY_UB, call.position))
+            addToResult(result, trMsb, trMsb.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(arrayName.type==DataType.STR) arrayLength!!-1 else arrayLength), null)
+            result += codeGen.makeSyscall(IMSyscall.REVERSE_BYTES, listOf(IRDataType.WORD to trMsb.resultReg, IRDataType.BYTE to lengthReg), null)
+            return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
+        }
+
         val syscall =
-            when(array.dt) {
+            when(arrayName.type) {
                 DataType.ARRAY_UB, DataType.ARRAY_B, DataType.STR -> IMSyscall.REVERSE_BYTES
                 DataType.ARRAY_UW, DataType.ARRAY_W -> IMSyscall.REVERSE_WORDS
                 DataType.ARRAY_F -> IMSyscall.REVERSE_FLOATS
                 else -> throw IllegalArgumentException("weird type to reverse")
             }
-        val result = mutableListOf<IRCodeChunkBase>()
-        val tr = exprGen.translateExpression(call.args[0])
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
+        val tr = exprGen.translateExpression(arrayName)
         addToResult(result, tr, tr.resultReg, -1)
-        val lengthReg = codeGen.registers.nextFree()
-        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(array.dt==DataType.STR) array.length!!-1 else array.length), null)
+        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(arrayName.type==DataType.STR) arrayLength!!-1 else arrayLength), null)
         result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), null)
         return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
     private fun funcSort(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val arrayName = call.args[0] as PtIdentifier
-        val array = codeGen.symbolTable.flat.getValue(arrayName.name) as StStaticVariable
+        val arrayLength = codeGen.symbolTable.getLength(arrayName.name)
         val syscall =
-            when(array.dt) {
+            when(arrayName.type) {
                 DataType.ARRAY_UB -> IMSyscall.SORT_UBYTE
                 DataType.ARRAY_B -> IMSyscall.SORT_BYTE
                 DataType.ARRAY_UW -> IMSyscall.SORT_UWORD
                 DataType.ARRAY_W -> IMSyscall.SORT_WORD
                 DataType.STR -> IMSyscall.SORT_UBYTE
                 DataType.ARRAY_F -> throw IllegalArgumentException("sorting a floating point array is not supported")
+                in SplitWordArrayTypes -> TODO("split word sort")
                 else -> throw IllegalArgumentException("weird type to sort")
             }
         val result = mutableListOf<IRCodeChunkBase>()
-        val tr = exprGen.translateExpression(call.args[0])
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
+        val tr = exprGen.translateExpression(arrayName)
         addToResult(result, tr, tr.resultReg, -1)
         val lengthReg = codeGen.registers.nextFree()
-        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(array.dt==DataType.STR) array.length!!-1 else array.length), null)
+        addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1 = lengthReg, immediate = if(arrayName.type==DataType.STR) arrayLength!!-1 else arrayLength), null)
         result += codeGen.makeSyscall(syscall, listOf(IRDataType.WORD to tr.resultReg, IRDataType.BYTE to lengthReg), null)
         return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
     private fun funcMkword(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        val resultReg = codeGen.registers.nextFree()
+        if((call.args[0] as? PtNumber)?.number == 0.0) {
+            // msb is 0, use EXT
+            val lsbTr = exprGen.translateExpression(call.args[1])
+            addToResult(result, lsbTr, lsbTr.resultReg, -1)
+            addInstr(result, IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1=resultReg, reg2 = lsbTr.resultReg), null)
+        } else {
             val msbTr = exprGen.translateExpression(call.args[0])
             addToResult(result, msbTr, msbTr.resultReg, -1)
             val lsbTr = exprGen.translateExpression(call.args[1])
             addToResult(result, lsbTr, lsbTr.resultReg, -1)
-        result += IRCodeChunk(null, null).also {
-            it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1 = lsbTr.resultReg, reg2 = msbTr.resultReg)
+            addInstr(result, IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=resultReg, reg2 = msbTr.resultReg, reg3 = lsbTr.resultReg), null)
         }
-        return ExpressionCodeResult(result, IRDataType.WORD, lsbTr.resultReg, -1)
+        return ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
     }
 
-    private fun funcPokeW(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcClamp(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
+        val type = irType(call.type)
+        val valueTr = exprGen.translateExpression(call.args[0])
+        val minimumTr = exprGen.translateExpression(call.args[1])
+        val maximumTr = exprGen.translateExpression(call.args[2])
+        result += valueTr.chunks
+        result += minimumTr.chunks
+        result += maximumTr.chunks
+        if(type==IRDataType.FLOAT) {
+            result += codeGen.makeSyscall(
+                IMSyscall.CLAMP_FLOAT, listOf(
+                    valueTr.dt to valueTr.resultFpReg,
+                    minimumTr.dt to minimumTr.resultFpReg,
+                    maximumTr.dt to maximumTr.resultFpReg,
+                ), type to valueTr.resultFpReg
+            )
+            return ExpressionCodeResult(result, type, -1, valueTr.resultFpReg)
+        } else {
+            val syscall = when(call.type) {
+                DataType.UBYTE -> IMSyscall.CLAMP_UBYTE
+                DataType.BYTE -> IMSyscall.CLAMP_BYTE
+                DataType.UWORD -> IMSyscall.CLAMP_UWORD
+                DataType.WORD -> IMSyscall.CLAMP_WORD
+                else -> throw AssemblyError("invalid dt")
+            }
+            result += codeGen.makeSyscall(syscall, listOf(
+                    valueTr.dt to valueTr.resultReg,
+                    minimumTr.dt to minimumTr.resultReg,
+                    maximumTr.dt to maximumTr.resultReg,
+                ), type to valueTr.resultReg
+            )
+            return ExpressionCodeResult(result, type, valueTr.resultReg, -1)
+        }
+    }
+
+    private fun funcMin(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val type = irType(call.type)
+        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 comparisonOpcode = if(call.type in SignedDatatypes) Opcode.BGTSR else Opcode.BGTR
+        val after = codeGen.createLabelName()
+        result += IRCodeChunk(null, null).also {
+            it += IRInstruction(comparisonOpcode, type, reg1 = rightTr.resultReg, reg2 = leftTr.resultReg, labelSymbol = after)
+            // right <= left, take right
+            it += IRInstruction(Opcode.LOADR, type, reg1=leftTr.resultReg, reg2=rightTr.resultReg)
+            it += IRInstruction(Opcode.JUMP, labelSymbol = after)
+        }
+        result += IRCodeChunk(after, null)
+        return ExpressionCodeResult(result, type, leftTr.resultReg, -1)
+    }
+
+    private fun funcMax(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val type = irType(call.type)
+        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 comparisonOpcode = if(call.type in SignedDatatypes) Opcode.BGTSR else Opcode.BGTR
+        val after = codeGen.createLabelName()
+        result += IRCodeChunk(null, null).also {
+            it += IRInstruction(comparisonOpcode, type, reg1 = leftTr.resultReg, reg2 = rightTr.resultReg, labelSymbol = after)
+            // right >= left, take right
+            it += IRInstruction(Opcode.LOADR, type, reg1=leftTr.resultReg, reg2=rightTr.resultReg)
+            it += IRInstruction(Opcode.JUMP, labelSymbol = after)
+        }
+        result += IRCodeChunk(after, null)
+        return ExpressionCodeResult(result, type, leftTr.resultReg, -1)
+    }
+
+    private fun funcPoke(call: PtBuiltinFunctionCall, dt: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
         if(codeGen.isZero(call.args[1])) {
             if (call.args[0] is PtNumber) {
                 val address = (call.args[0] as PtNumber).number.toInt()
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZM, IRDataType.WORD, address = address)
+                    it += IRInstruction(Opcode.STOREZM, dt, address = address)
                 }
             } else {
                 val tr = exprGen.translateExpression(call.args[0])
                 addToResult(result, tr, tr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZI, IRDataType.WORD, reg1 = tr.resultReg)
+                    it += IRInstruction(Opcode.STOREZI, dt, reg1 = tr.resultReg)
                 }
             }
         } else {
             if (call.args[0] is PtNumber) {
                 val address = (call.args[0] as PtNumber).number.toInt()
                 val tr = exprGen.translateExpression(call.args[1])
+                if(dt==IRDataType.FLOAT) {
+                    addToResult(result, tr, -1, tr.resultFpReg)
+                    result += IRCodeChunk(null, null).also {
+                        it += IRInstruction(Opcode.STOREM, dt, fpReg1 = tr.resultFpReg, address = address)
+                    }
+                } else {
                     addToResult(result, tr, tr.resultReg, -1)
                     result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREM, IRDataType.WORD, reg1 = tr.resultReg, address = address)
+                        it += IRInstruction(Opcode.STOREM, dt, reg1 = tr.resultReg, address = address)
+                    }
                 }
             } else {
                 val addressTr = exprGen.translateExpression(call.args[0])
                 addToResult(result, addressTr, addressTr.resultReg, -1)
                 val valueTr = exprGen.translateExpression(call.args[1])
+                if(dt==IRDataType.FLOAT) {
+                    addToResult(result, valueTr, -1, valueTr.resultFpReg)
+                    result += IRCodeChunk(null, null).also {
+                        it += IRInstruction(Opcode.STOREI, IRDataType.FLOAT, reg1 = addressTr.resultReg, fpReg1 = valueTr.resultFpReg)
+                    }
+                } else {
                     addToResult(result, valueTr, valueTr.resultReg, -1)
                     result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREI, IRDataType.WORD, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
+                        it += IRInstruction(Opcode.STOREI, dt, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
+                    }
                 }
             }
         }
         return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
     }
 
-    private fun funcPoke(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+    private fun funcPeek(call: PtBuiltinFunctionCall, dt: IRDataType): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        if(codeGen.isZero(call.args[1])) {
-            if (call.args[0] is PtNumber) {
+        return if(dt==IRDataType.FLOAT) {
+            if(call.args[0] is PtNumber) {
+                val resultFpRegister = codeGen.registers.nextFreeFloat()
                 val address = (call.args[0] as PtNumber).number.toInt()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = resultFpRegister, address = address)
+                }
+                ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpRegister)
+            } else {
+                val tr = exprGen.translateExpression(call.args.single())
+                addToResult(result, tr, tr.resultReg, -1)
+                val resultFpReg = codeGen.registers.nextFreeFloat()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADI, IRDataType.FLOAT, reg1 = tr.resultReg, fpReg1 = resultFpReg)
+                }
+                ExpressionCodeResult(result, IRDataType.FLOAT, -1, resultFpReg)
+            }
+        } else {
+            if (call.args[0] is PtNumber) {
+                val resultRegister = codeGen.registers.nextFree()
+                val address = (call.args[0] as PtNumber).number.toInt()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADM, dt, reg1 = resultRegister, address = address)
+                }
+                ExpressionCodeResult(result, dt, resultRegister, -1)
+            } else {
+                val tr = exprGen.translateExpression(call.args.single())
+                addToResult(result, tr, tr.resultReg, -1)
+                val resultReg = codeGen.registers.nextFree()
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.LOADI, dt, reg1 = resultReg, reg2 = tr.resultReg)
+                }
+                ExpressionCodeResult(result, dt, resultReg, -1)
+            }
+        }
+    }
+
+    private fun funcPokemon(call: PtBuiltinFunctionCall): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val address = call.args[0]
+
+        fun pokeM(result: MutableList<IRCodeChunkBase>, address: Int, value: PtExpression) {
+            if(codeGen.isZero(value)) {
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.STOREZM, IRDataType.BYTE, address = address)
                 }
             } else {
-                val tr = exprGen.translateExpression(call.args[0])
-                addToResult(result, tr, tr.resultReg, -1)
-                result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = tr.resultReg)
-                }
-            }
-        } else {
-            if (call.args[0] is PtNumber) {
-                val address = (call.args[0] as PtNumber).number.toInt()
-                val tr = exprGen.translateExpression(call.args[1])
+                val tr = exprGen.translateExpression(value)
                 addToResult(result, tr, tr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.STOREM, IRDataType.BYTE, reg1 = tr.resultReg, address = address)
                 }
+            }
+        }
+
+        fun pokeI(result: MutableList<IRCodeChunkBase>, register: Int, value: PtExpression) {
+            if(codeGen.isZero(value)) {
+                result += IRCodeChunk(null, null).also {
+                    it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = register)
+                }
             } else {
-                val addressTr = exprGen.translateExpression(call.args[0])
-                addToResult(result, addressTr, addressTr.resultReg, -1)
-                val valueTr = exprGen.translateExpression(call.args[1])
+                val valueTr = exprGen.translateExpression(value)
                 addToResult(result, valueTr, valueTr.resultReg, -1)
                 result += IRCodeChunk(null, null).also {
-                    it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = addressTr.resultReg)
+                    it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = register)
                 }
             }
         }
-        return ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
-    }
-
-    private fun funcPeekW(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val result = mutableListOf<IRCodeChunkBase>()
-        return if(call.args[0] is PtNumber) {
-            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, address = address)
-            }
-            ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
-        } else {
-            val tr = exprGen.translateExpression(call.args.single())
-            addToResult(result, tr, tr.resultReg, -1)
-            val resultReg = codeGen.registers.nextFree()
-            result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADI, IRDataType.WORD, reg1 = resultReg, reg2 = tr.resultReg)
-            }
-            ExpressionCodeResult(result, IRDataType.WORD, resultReg, -1)
-        }
-    }
 
-    private fun funcPeek(call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val result = mutableListOf<IRCodeChunkBase>()
-        return if(call.args[0] is PtNumber) {
+        return if(address is PtNumber) {
             val resultRegister = codeGen.registers.nextFree()
-            val address = (call.args[0] as PtNumber).number.toInt()
+            val addressNum = address.number.toInt()
             result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1 = resultRegister, address = address)
+                it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1 = resultRegister, address = addressNum)
             }
+            pokeM(result, addressNum, call.args[1])
             ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
         } else {
-            val tr = exprGen.translateExpression(call.args.single())
-            addToResult(result, tr, tr.resultReg, -1)
+            val addressTr = exprGen.translateExpression(address)
+            addToResult(result, addressTr, addressTr.resultReg, -1)
             val resultReg = codeGen.registers.nextFree()
             result += IRCodeChunk(null, null).also {
-                it += IRInstruction(Opcode.LOADI, IRDataType.BYTE, reg1 = resultReg, reg2 = tr.resultReg)
+                it += IRInstruction(Opcode.LOADI, IRDataType.BYTE, reg1 = resultReg, reg2 = addressTr.resultReg)
             }
+            pokeI(result, addressTr.resultReg, call.args[1])
             ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
         }
     }
 
+
     private fun funcMemory(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val name = (call.args[0] as PtString).value
         val code = IRCodeChunk(null, null)
@@ -423,6 +615,7 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
     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.
+        // ....To be more strict, maybe we should introduce a new result register that is of type .b?
     }
 
     private fun funcMsb(call: PtBuiltinFunctionCall): ExpressionCodeResult {
@@ -430,25 +623,177 @@ internal class BuiltinFuncGen(private val codeGen: IRCodeGen, private val exprGe
         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 = resultReg, reg2 = tr.resultReg)
-        }
+        addInstr(result, IRInstruction(Opcode.MSIG, IRDataType.BYTE, reg1 = resultReg, reg2 = tr.resultReg), null)
         // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
         return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
     }
 
-    private fun funcRolRor(opcode: Opcode, call: PtBuiltinFunctionCall): ExpressionCodeResult {
-        val vmDt = irType(call.args[0].type)
+    private fun funcRolRor(call: PtBuiltinFunctionCall): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        val tr = exprGen.translateExpression(call.args[0])
-        addToResult(result, tr, tr.resultReg, -1)
-        result += IRCodeChunk(null, null).also {
-            it += IRInstruction(opcode, vmDt, reg1 = tr.resultReg)
+        val arg = call.args[0]
+        val vmDt = irType(arg.type)
+        val opcodeMemAndReg = when(call.name) {
+            "rol" -> Opcode.ROXLM to Opcode.ROXL
+            "ror" -> Opcode.ROXRM to Opcode.ROXR
+            "rol2" -> Opcode.ROLM to Opcode.ROL
+            "ror2" -> Opcode.RORM to Opcode.ROR
+            else -> throw AssemblyError("wrong func")
         }
-        result += assignRegisterTo(call.args[0], tr.resultReg)
+
+        val ident = arg as? PtIdentifier
+        if(ident!=null) {
+            addInstr(result, IRInstruction(opcodeMemAndReg.first, vmDt, labelSymbol = ident.name), null)
             return ExpressionCodeResult(result, vmDt, -1, -1)
         }
 
+        val memAddr  = (arg as? PtMemoryByte)?.address?.asConstInteger()
+        if(memAddr!=null) {
+            addInstr(result, IRInstruction(opcodeMemAndReg.first, vmDt, address = memAddr), null)
+            return ExpressionCodeResult(result, vmDt, -1, -1)
+        }
+
+        val arr = (arg as? PtArrayIndexer)
+        val index = arr?.index?.asConstInteger()
+        if(arr!=null && index!=null) {
+            val variable = arr.variable.name
+            val itemsize = codeGen.program.memsizer.memorySize(arr.type)
+            addInstr(result, IRInstruction(opcodeMemAndReg.first, vmDt, labelSymbol = variable, symbolOffset = index*itemsize), null)
+            return ExpressionCodeResult(result, vmDt, -1, -1)
+        }
+
+        val opcode = opcodeMemAndReg.second
+        val saveCarry = opcode in OpcodesThatDependOnCarry && !arg.isSimple()
+        if(saveCarry)
+            addInstr(result, IRInstruction(Opcode.PUSHST), null)    // save Carry
+        val tr = exprGen.translateExpression(arg)
+        addToResult(result, tr, tr.resultReg, -1)
+        if(saveCarry)
+            addInstr(result, IRInstruction(Opcode.POPST), null)
+        addInstr(result, IRInstruction(opcode, vmDt, reg1 = tr.resultReg), null)
+        if(saveCarry)
+            addInstr(result, IRInstruction(Opcode.PUSHST), null)    // save Carry
+        result += assignRegisterTo(arg, tr.resultReg)
+        if(saveCarry)
+            addInstr(result, IRInstruction(Opcode.POPST), null)
+        return ExpressionCodeResult(result, vmDt, -1, -1)
+    }
+
+    private fun funcSetLsbMsb(call: PtBuiltinFunctionCall, msb: Boolean): ExpressionCodeResult {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val target = call.args[0]
+        val isConstZeroValue = call.args[1].asConstInteger()==0
+        when(target) {
+            is PtIdentifier -> {
+                if(isConstZeroValue) {
+                    result += IRCodeChunk(null, null).also {
+                        val pointerReg = codeGen.registers.nextFree()
+                        it += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1 = pointerReg, labelSymbol = target.name)
+                        if (msb)
+                            it += IRInstruction(Opcode.INC, IRDataType.WORD, reg1 = pointerReg)
+                        it += IRInstruction(Opcode.STOREZI, IRDataType.BYTE, reg1 = pointerReg)
+                    }
+                } else {
+                    val valueTr = exprGen.translateExpression(call.args[1])
+                    addToResult(result, valueTr, valueTr.resultReg, -1)
+                    result += IRCodeChunk(null, null).also {
+                        val pointerReg = codeGen.registers.nextFree()
+                        it += IRInstruction(Opcode.LOAD, IRDataType.WORD, reg1 = pointerReg, labelSymbol = target.name)
+                        if (msb)
+                            it += IRInstruction(Opcode.INC, IRDataType.WORD, reg1 = pointerReg)
+                        it += IRInstruction(Opcode.STOREI, IRDataType.BYTE, reg1 = valueTr.resultReg, reg2 = pointerReg)
+                    }
+                }
+            }
+            is PtArrayIndexer -> {
+                require(!target.usesPointerVariable)
+                if(target.splitWords) {
+                    // lsb/msb in split arrays, element index 'size' is always 1
+                    val constIndex = target.index.asConstInteger()
+                    val varName = target.variable.name + if(msb) "_msb" else "_lsb"
+                    if(isConstZeroValue) {
+                        if(constIndex!=null) {
+                            val offsetReg = codeGen.registers.nextFree()
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=offsetReg, immediate = constIndex)
+                                it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1=offsetReg, labelSymbol = varName)
+                            }
+                        } else {
+                            val indexTr = exprGen.translateExpression(target.index)
+                            addToResult(result, indexTr, indexTr.resultReg, -1)
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1=indexTr.resultReg, labelSymbol = varName)
+                            }
+                        }
+                    } else {
+                        val valueTr = exprGen.translateExpression(call.args[1])
+                        addToResult(result, valueTr, valueTr.resultReg, -1)
+                        if(constIndex!=null) {
+                            val offsetReg = codeGen.registers.nextFree()
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=offsetReg, immediate = constIndex)
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1=valueTr.resultReg, reg2=offsetReg, labelSymbol = varName)
+                            }
+                        } else {
+                            val indexTr = exprGen.translateExpression(target.index)
+                            addToResult(result, indexTr, indexTr.resultReg, -1)
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1=valueTr.resultReg, reg2=indexTr.resultReg, labelSymbol = varName)
+                            }
+                        }
+                    }
+                }
+                else {
+                    val eltSize = codeGen.program.memsizer.memorySize(target.type)
+                    val constIndex = target.index.asConstInteger()
+                    if(isConstZeroValue) {
+                        if(constIndex!=null) {
+                            val offsetReg = codeGen.registers.nextFree()
+                            val offset = eltSize*constIndex + if(msb) 1 else 0
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=offsetReg, immediate = offset)
+                                it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1=offsetReg, labelSymbol = target.variable.name)
+                            }
+                        } else {
+                            val indexTr = exprGen.translateExpression(target.index)
+                            addToResult(result, indexTr, indexTr.resultReg, -1)
+                            result += IRCodeChunk(null, null).also {
+                                if(eltSize>1)
+                                    it += codeGen.multiplyByConst(IRDataType.BYTE, indexTr.resultReg, eltSize)
+                                if(msb)
+                                    it += IRInstruction(Opcode.INC, IRDataType.BYTE, reg1=indexTr.resultReg)
+                                it += IRInstruction(Opcode.STOREZX, IRDataType.BYTE, reg1=indexTr.resultReg, labelSymbol = target.variable.name)
+                            }
+                        }
+                    } else {
+                        val valueTr = exprGen.translateExpression(call.args[1])
+                        addToResult(result, valueTr, valueTr.resultReg, -1)
+                        if(constIndex!=null) {
+                            val offsetReg = codeGen.registers.nextFree()
+                            val offset = eltSize*constIndex + if(msb) 1 else 0
+                            result += IRCodeChunk(null, null).also {
+                                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=offsetReg, immediate = offset)
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1=valueTr.resultReg, reg2=offsetReg, labelSymbol = target.variable.name)
+                            }
+                        } else {
+                            val indexTr = exprGen.translateExpression(target.index)
+                            addToResult(result, indexTr, indexTr.resultReg, -1)
+                            result += IRCodeChunk(null, null).also {
+                                if(eltSize>1)
+                                    it += codeGen.multiplyByConst(IRDataType.BYTE, indexTr.resultReg, eltSize)
+                                if(msb)
+                                    it += IRInstruction(Opcode.INC, IRDataType.BYTE, reg1=indexTr.resultReg)
+                                it += IRInstruction(Opcode.STOREX, IRDataType.BYTE, reg1=valueTr.resultReg, reg2=indexTr.resultReg, labelSymbol = target.variable.name)
+                            }
+                        }
+                    }
+                }
+            }
+            else -> throw AssemblyError("weird target for setlsb/setmsb: $target")
+        }
+        return ExpressionCodeResult(result, IRDataType.WORD, -1, -1)
+    }
+
+
     private fun assignRegisterTo(target: PtExpression, register: Int): IRCodeChunks {
         val assignment = PtAssignment(target.position)
         val assignTarget = PtAssignTarget(target.position)

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

@@ -1,13 +1,9 @@
 package prog8.codegen.intermediate
 
 import prog8.code.StRomSub
-import prog8.code.StStaticVariable
 import prog8.code.StSub
 import prog8.code.ast.*
-import prog8.code.core.AssemblyError
-import prog8.code.core.DataType
-import prog8.code.core.PassByValueDatatypes
-import prog8.code.core.SignedDatatypes
+import prog8.code.core.*
 import prog8.intermediate.*
 
 internal class ExpressionCodeResult(val chunks: IRCodeChunks, val dt: IRDataType, val resultReg: Int, val resultFpReg: Int) {
@@ -35,7 +31,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val code = IRCodeChunk(null, null)
                 if(vmDt==IRDataType.FLOAT) {
                     val resultFpRegister = codeGen.registers.nextFreeFloat()
-                    code += IRInstruction(Opcode.LOAD, vmDt, fpReg1 = resultFpRegister, immediateFp = expr.number.toFloat())
+                    code += IRInstruction(Opcode.LOAD, vmDt, fpReg1 = resultFpRegister, immediateFp = expr.number)
                     ExpressionCodeResult(code, vmDt,-1, resultFpRegister)
                 }
                 else {
@@ -45,9 +41,9 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 }
             }
             is PtIdentifier -> {
-                val vmDt = irType(expr.type)
                 val code = IRCodeChunk(null, null)
                 if (expr.type in PassByValueDatatypes) {
+                    val vmDt = irType(expr.type)
                     if(vmDt==IRDataType.FLOAT) {
                         val resultFpRegister = codeGen.registers.nextFreeFloat()
                         code += IRInstruction(Opcode.LOADM, vmDt, fpReg1 = resultFpRegister, labelSymbol = expr.name)
@@ -60,6 +56,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     }
                 } else {
                     // for strings and arrays etc., load the *address* of the value instead
+                    val vmDt = if(expr.type==DataType.UNDEFINED) IRDataType.WORD else irType(expr.type)
                     val resultRegister = codeGen.registers.nextFree()
                     code += IRInstruction(Opcode.LOAD, vmDt, reg1 = resultRegister, labelSymbol = expr.name)
                     ExpressionCodeResult(code, vmDt, resultRegister, -1)
@@ -69,10 +66,28 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 val vmDt = irType(expr.type)
                 val symbol = expr.identifier.name
                 // note: LOAD <symbol>  gets you the address of the symbol, whereas LOADM <symbol> would get you the value stored at that location
-                val code = IRCodeChunk(null, null)
+                val result = mutableListOf<IRCodeChunkBase>()
                 val resultRegister = codeGen.registers.nextFree()
-                code += IRInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, labelSymbol = symbol)
-                ExpressionCodeResult(code, vmDt, resultRegister, -1)
+                addInstr(result, IRInstruction(Opcode.LOAD, vmDt, reg1 = resultRegister, labelSymbol = symbol), null)
+                if(expr.isFromArrayElement) {
+                    val indexTr = translateExpression(expr.arrayIndexExpr!!)
+                    addToResult(result, indexTr, indexTr.resultReg, -1)
+                    if(expr.identifier.type in SplitWordArrayTypes) {
+                        result += IRCodeChunk(null, null).also {
+                            // multiply indexTr resultreg by the eltSize and add this to the resultRegister.
+                            it += IRInstruction(Opcode.ADDR, IRDataType.BYTE, reg1=resultRegister, reg2=indexTr.resultReg)
+                        }
+                    } else {
+                        val eltSize = codeGen.program.memsizer.memorySize(expr.identifier.type, 1)
+                        result += IRCodeChunk(null, null).also {
+                            // multiply indexTr resultreg by the eltSize and add this to the resultRegister.
+                            if(eltSize>1)
+                                it += IRInstruction(Opcode.MUL, IRDataType.BYTE, reg1=indexTr.resultReg, immediate = eltSize)
+                            it += IRInstruction(Opcode.ADDR, IRDataType.BYTE, reg1=resultRegister, reg2=indexTr.resultReg)
+                        }
+                    }
+                }
+                ExpressionCodeResult(result, vmDt, resultRegister, -1)
             }
             is PtMemoryByte -> {
                 val result = mutableListOf<IRCodeChunkBase>()
@@ -105,9 +120,9 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
 
     private fun translate(check: PtContainmentCheck): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
-        val iterable = codeGen.symbolTable.flat.getValue(check.iterable.name) as StStaticVariable
-        when(iterable.dt) {
+        when(check.iterable.type) {
             DataType.STR -> {
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 2), null)
                 val elementTr = translateExpression(check.element)
                 addToResult(result, elementTr, elementTr.resultReg, -1)
                 val iterableTr = translateExpression(check.iterable)
@@ -116,27 +131,43 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1)
             }
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
                 val elementTr = translateExpression(check.element)
                 addToResult(result, elementTr, elementTr.resultReg, -1)
                 val iterableTr = translateExpression(check.iterable)
                 addToResult(result, iterableTr, iterableTr.resultReg, -1)
                 val lengthReg = codeGen.registers.nextFree()
-                addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterable.length!!), null)
+                val iterableLength = codeGen.symbolTable.getLength(check.iterable.name)
+                addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null)
                 result += codeGen.makeSyscall(IMSyscall.BYTEARRAY_CONTAINS, listOf(IRDataType.BYTE to elementTr.resultReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to elementTr.resultReg)
                 return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1)
             }
             DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
                 val elementTr = translateExpression(check.element)
                 addToResult(result, elementTr, elementTr.resultReg, -1)
                 val iterableTr = translateExpression(check.iterable)
                 addToResult(result, iterableTr, iterableTr.resultReg, -1)
                 val lengthReg = codeGen.registers.nextFree()
-                addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterable.length!!), null)
+                val iterableLength = codeGen.symbolTable.getLength(check.iterable.name)
+                addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null)
                 result += codeGen.makeSyscall(IMSyscall.WORDARRAY_CONTAINS, listOf(IRDataType.WORD to elementTr.resultReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to elementTr.resultReg)
                 return ExpressionCodeResult(result, IRDataType.BYTE, elementTr.resultReg, -1)
             }
-            DataType.ARRAY_F -> throw AssemblyError("containment check in float-array not supported")
-            else -> throw AssemblyError("weird iterable dt ${iterable.dt} for ${check.iterable.name}")
+            DataType.ARRAY_F -> {
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = 3), null)
+                val elementTr = translateExpression(check.element)
+                addToResult(result, elementTr, -1, elementTr.resultFpReg)
+                val iterableTr = translateExpression(check.iterable)
+                addToResult(result, iterableTr, iterableTr.resultReg, -1)
+                val lengthReg = codeGen.registers.nextFree()
+                val resultReg = codeGen.registers.nextFree()
+                val iterableLength = codeGen.symbolTable.getLength(check.iterable.name)
+                addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=lengthReg, immediate = iterableLength!!), null)
+                result += codeGen.makeSyscall(IMSyscall.FLOATARRAY_CONTAINS, listOf(IRDataType.FLOAT to elementTr.resultFpReg, IRDataType.WORD to iterableTr.resultReg, IRDataType.BYTE to lengthReg), IRDataType.BYTE to resultReg)
+                return ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
+            }
+            else -> throw AssemblyError("weird iterable dt ${check.iterable.type} for ${check.iterable.name}")
         }
     }
 
@@ -146,11 +177,10 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val result = mutableListOf<IRCodeChunkBase>()
         val arrayVarSymbol = arrayIx.variable.name
 
-        if(arrayIx.variable.type==DataType.UWORD) {
-            // indexing a pointer var instead of a real array or string
+        if(arrayIx.usesPointerVariable) {
             if(eltSize!=1)
                 throw AssemblyError("non-array var indexing requires bytes dt")
-            if(arrayIx.index.type!=DataType.UBYTE)
+            if(arrayIx.index.type !in ByteDatatypes)
                 throw AssemblyError("non-array var indexing requires bytes index")
             val tr = translateExpression(arrayIx.index)
             addToResult(result, tr, tr.resultReg, -1)
@@ -160,16 +190,43 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         }
 
         var resultRegister = -1
+
+        if(arrayIx.splitWords) {
+            require(vmDt==IRDataType.WORD)
+            val arrayLength = codeGen.symbolTable.getLength(arrayIx.variable.name)
+            resultRegister = codeGen.registers.nextFree()
+            val finalResultReg = codeGen.registers.nextFree()
+            if(arrayIx.index is PtNumber) {
+                val memOffset = (arrayIx.index as PtNumber).number.toInt()
+                result += IRCodeChunk(null, null).also {
+                    val tmpRegMsb = codeGen.registers.nextFree()
+                    it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1=tmpRegMsb, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_msb", symbolOffset = memOffset)
+                    it += IRInstruction(Opcode.LOADM, IRDataType.BYTE, reg1=resultRegister, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_lsb", symbolOffset = memOffset)
+                    it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=finalResultReg, reg2=tmpRegMsb, reg3=resultRegister)
+                }
+            } else {
+                val tr = translateExpression(arrayIx.index)
+                addToResult(result, tr, tr.resultReg, -1)
+                result += IRCodeChunk(null, null).also {
+                    val tmpRegMsb = codeGen.registers.nextFree()
+                    it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1=tmpRegMsb, reg2 = tr.resultReg, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_msb")
+                    it += IRInstruction(Opcode.LOADX, IRDataType.BYTE, reg1=resultRegister, reg2 = tr.resultReg, immediate = arrayLength, labelSymbol= "${arrayVarSymbol}_lsb")
+                    it += IRInstruction(Opcode.CONCAT, IRDataType.BYTE, reg1=finalResultReg, reg2=tmpRegMsb, reg3=resultRegister)
+                }
+            }
+            return ExpressionCodeResult(result, vmDt, finalResultReg, -1)
+        }
+
         var resultFpRegister = -1
         if(arrayIx.index is PtNumber) {
-            val memOffset = ((arrayIx.index as PtNumber).number.toInt() * eltSize).toString()
+            val memOffset = ((arrayIx.index as PtNumber).number.toInt() * eltSize)
             if(vmDt==IRDataType.FLOAT) {
                 resultFpRegister = codeGen.registers.nextFreeFloat()
-                addInstr(result, IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1=resultFpRegister, labelSymbol = "$arrayVarSymbol+$memOffset"), null)
+                addInstr(result, IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1=resultFpRegister, labelSymbol = arrayVarSymbol, symbolOffset = memOffset), null)
             }
             else {
                 resultRegister = codeGen.registers.nextFree()
-                addInstr(result, IRInstruction(Opcode.LOADM, vmDt, reg1=resultRegister, labelSymbol = "$arrayVarSymbol+$memOffset"), null)
+                addInstr(result, IRInstruction(Opcode.LOADM, vmDt, reg1=resultRegister, labelSymbol = arrayVarSymbol, symbolOffset = memOffset), null)
             }
         } else {
             val tr = translateExpression(arrayIx.index)
@@ -247,13 +304,13 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 when(cast.value.type) {
                     DataType.BYTE -> {
                         // byte -> uword:   sign extend
-                        actualResultReg2 = tr.resultReg
-                        addInstr(result, IRInstruction(Opcode.EXTS, type = IRDataType.BYTE, reg1 = actualResultReg2), null)
+                        actualResultReg2 = codeGen.registers.nextFree()
+                        addInstr(result, IRInstruction(Opcode.EXTS, type = IRDataType.BYTE, reg1 = actualResultReg2, reg2 = tr.resultReg), null)
                     }
                     DataType.UBYTE -> {
                         // ubyte -> uword:   sign extend
-                        actualResultReg2 = tr.resultReg
-                        addInstr(result, IRInstruction(Opcode.EXT, type = IRDataType.BYTE, reg1 = actualResultReg2), null)
+                        actualResultReg2 = codeGen.registers.nextFree()
+                        addInstr(result, IRInstruction(Opcode.EXT, type = IRDataType.BYTE, reg1 = actualResultReg2, reg2 = tr.resultReg), null)
                     }
                     DataType.WORD -> {
                         actualResultReg2 = tr.resultReg
@@ -269,13 +326,13 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 when(cast.value.type) {
                     DataType.BYTE -> {
                         // byte -> word:   sign extend
-                        actualResultReg2 = tr.resultReg
-                        addInstr(result, IRInstruction(Opcode.EXTS, type = IRDataType.BYTE, reg1 = actualResultReg2), null)
+                        actualResultReg2 = codeGen.registers.nextFree()
+                        addInstr(result, IRInstruction(Opcode.EXTS, type = IRDataType.BYTE, reg1 = actualResultReg2, reg2=tr.resultReg), null)
                     }
                     DataType.UBYTE -> {
                         // byte -> word:   sign extend
-                        actualResultReg2 = tr.resultReg
-                        addInstr(result, IRInstruction(Opcode.EXT, type = IRDataType.BYTE, reg1 = actualResultReg2), null)
+                        actualResultReg2 = codeGen.registers.nextFree()
+                        addInstr(result, IRInstruction(Opcode.EXT, type = IRDataType.BYTE, reg1 = actualResultReg2, reg2=tr.resultReg), null)
                     }
                     DataType.UWORD -> {
                         actualResultReg2 = tr.resultReg
@@ -312,7 +369,6 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
     }
 
     private fun translate(binExpr: PtBinaryExpression): ExpressionCodeResult {
-        require(!codeGen.options.useNewExprCode)
         val vmDt = irType(binExpr.left.type)
         val signed = binExpr.left.type in SignedDatatypes
         return when(binExpr.operator) {
@@ -321,9 +377,11 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             "*" -> operatorMultiply(binExpr, vmDt)
             "/" -> operatorDivide(binExpr, vmDt, signed)
             "%" -> operatorModulo(binExpr, vmDt)
-            "|" -> operatorOr(binExpr, vmDt)
-            "&" -> operatorAnd(binExpr, vmDt)
-            "^" -> operatorXor(binExpr, vmDt)
+            "|" -> operatorOr(binExpr, vmDt, true)
+            "&" -> operatorAnd(binExpr, vmDt, true)
+            "^", "xor" -> operatorXor(binExpr, vmDt)
+            "or" -> operatorOr(binExpr, vmDt, false)
+            "and" -> operatorAnd(binExpr, vmDt, false)
             "<<" -> operatorShiftLeft(binExpr, vmDt)
             ">>" -> operatorShiftRight(binExpr, vmDt, signed)
             "==" -> operatorEquals(binExpr, vmDt, false)
@@ -340,6 +398,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         when (val callTarget = codeGen.symbolTable.flat.getValue(fcall.name)) {
             is StSub -> {
                 val result = mutableListOf<IRCodeChunkBase>()
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = callTarget.parameters.size), null)
                 // assign the arguments
                 val argRegisters = mutableListOf<FunctionCallArgs.ArgumentSpec>()
                 for ((arg, parameter) in fcall.args.zip(callTarget.parameters)) {
@@ -360,8 +419,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                         FunctionCallArgs.RegSpec(returnIrType, codeGen.registers.nextFree(), null)
                 }
                 // create the call
-                val call = IRInstruction(Opcode.CALL, labelSymbol = fcall.name, fcallArgs = FunctionCallArgs(argRegisters, returnRegSpec))
-                addInstr(result, call, null)
+                addInstr(result, IRInstruction(Opcode.CALL, labelSymbol = fcall.name, fcallArgs = FunctionCallArgs(argRegisters, returnRegSpec)), null)
                 return if(fcall.void)
                     ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
                 else if(fcall.type==DataType.FLOAT)
@@ -371,6 +429,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             }
             is StRomSub -> {
                 val result = mutableListOf<IRCodeChunkBase>()
+                addInstr(result, IRInstruction(Opcode.PREPARECALL, immediate = callTarget.parameters.size), null)
                 // assign the arguments
                 val argRegisters = mutableListOf<FunctionCallArgs.ArgumentSpec>()
                 for ((arg, parameter) in fcall.args.zip(callTarget.parameters)) {
@@ -383,6 +442,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     result += tr.chunks
                 }
                 // return value
+                var statusFlagResult: Statusflag? = null
                 val returnRegSpec = if(fcall.void) null else {
                     if(callTarget.returns.isEmpty())
                         null
@@ -391,8 +451,11 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                         val returnIrType = irType(returns.type)
                         if(returnIrType==IRDataType.FLOAT)
                             FunctionCallArgs.RegSpec(returnIrType, codeGen.registers.nextFreeFloat(), returns.register)
-                        else
-                            FunctionCallArgs.RegSpec(returnIrType, codeGen.registers.nextFree(), returns.register)
+                        else {
+                            statusFlagResult = returns.register.statusflag
+                            val returnRegister = if(statusFlagResult==null) codeGen.registers.nextFree() else -1
+                            FunctionCallArgs.RegSpec(returnIrType, returnRegister, returns.register)
+                        }
                     } else {
                         // multiple return values: take the first *register* (not status flag) return value and ignore the rest.
                         val returns = callTarget.returns.first { it.register.registerOrPair!=null }
@@ -410,12 +473,48 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     else
                         IRInstruction(Opcode.CALL, address = callTarget.address!!.toInt(), fcallArgs = FunctionCallArgs(argRegisters, returnRegSpec))
                 addInstr(result, call, null)
+                var finalReturnRegister = returnRegSpec?.registerNum ?: -1
+
+                if(fcall.parent is PtAssignment || fcall.parent is PtTypeCast) {
+                    // look if the status flag bit should actually be returned as a 0/1 byte value in a result register (so it can be assigned)
+                    if(statusFlagResult!=null && returnRegSpec!=null) {
+                        // assign status flag bit to the return value register
+                        finalReturnRegister = returnRegSpec.registerNum
+                        if(finalReturnRegister<0)
+                            finalReturnRegister = codeGen.registers.nextFree()
+                        when(statusFlagResult) {
+                            Statusflag.Pc -> {
+                                addInstr(result, IRInstruction(Opcode.SCS, returnRegSpec.dt, reg1=finalReturnRegister), null)
+                            }
+                            else -> {
+                                val branchOpcode = when(statusFlagResult) {
+                                    Statusflag.Pc -> throw AssemblyError("carry should be treated separately")
+                                    Statusflag.Pz -> Opcode.BSTEQ
+                                    Statusflag.Pv -> Opcode.BSTVS
+                                    Statusflag.Pn -> Opcode.BSTNEG
+                                }
+                                val setLabel = codeGen.createLabelName()
+                                val endLabel = codeGen.createLabelName()
+                                result += IRCodeChunk(null, null).also {
+                                    it += IRInstruction(branchOpcode, labelSymbol = setLabel)
+                                    it += IRInstruction(Opcode.LOAD, returnRegSpec.dt, reg1=finalReturnRegister, immediate = 0)
+                                    it += IRInstruction(Opcode.JUMP, labelSymbol = endLabel)
+                                }
+                                result += IRCodeChunk(setLabel, null).also {
+                                    it += IRInstruction(Opcode.LOAD, returnRegSpec.dt, reg1=finalReturnRegister, immediate = 1)
+                                }
+                                result += IRCodeChunk(endLabel, null)
+                            }
+                        }
+                    }
+                }
+
                 return if(fcall.void)
                     ExpressionCodeResult(result, IRDataType.BYTE, -1, -1)
                 else if(fcall.type==DataType.FLOAT)
-                    ExpressionCodeResult(result, returnRegSpec!!.dt, -1, returnRegSpec.registerNum)
+                    ExpressionCodeResult(result, returnRegSpec!!.dt, -1, finalReturnRegister)
                 else
-                    ExpressionCodeResult(result, returnRegSpec!!.dt, returnRegSpec.registerNum, -1)
+                    ExpressionCodeResult(result, returnRegSpec!!.dt, finalReturnRegister, -1)
             }
             else -> throw AssemblyError("invalid node type")
         }
@@ -428,6 +527,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         greaterEquals: Boolean
     ): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        val cmpResultReg = codeGen.registers.nextFree()
         if(vmDt==IRDataType.FLOAT) {
             val leftTr = translateExpression(binExpr.left)
             addToResult(result, leftTr, -1, leftTr.resultFpReg)
@@ -442,10 +542,10 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             } else {
                 if (greaterEquals) Opcode.SGE else Opcode.SGT
             }
-            addInstr(result, IRInstruction(ins, IRDataType.BYTE, reg1 = resultRegister, reg2 = zeroRegister), null)
-            return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
+            addInstr(result, IRInstruction(ins, IRDataType.BYTE, reg1=cmpResultReg, reg2 = resultRegister, reg3 = zeroRegister), null)
+            return ExpressionCodeResult(result, IRDataType.BYTE, cmpResultReg, -1)
         } else {
-            if(binExpr.left.type==DataType.STR && binExpr.right.type==DataType.STR) {
+            if(binExpr.left.type==DataType.STR || binExpr.right.type==DataType.STR) {
                 throw AssemblyError("str compares should have been replaced with builtin function call to do the compare")
             } else {
                 val leftTr = translateExpression(binExpr.left)
@@ -457,8 +557,8 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 } else {
                     if (greaterEquals) Opcode.SGE else Opcode.SGT
                 }
-                addInstr(result, IRInstruction(ins, vmDt, reg1 = leftTr.resultReg, reg2 = rightTr.resultReg), null)
-                return ExpressionCodeResult(result, IRDataType.BYTE, leftTr.resultReg, -1)
+                addInstr(result, IRInstruction(ins, vmDt, reg1=cmpResultReg, reg2 = leftTr.resultReg, reg3 = rightTr.resultReg), null)
+                return ExpressionCodeResult(result, IRDataType.BYTE, cmpResultReg, -1)
             }
         }
     }
@@ -470,6 +570,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         lessEquals: Boolean
     ): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        val cmpResultRegister = codeGen.registers.nextFree()
         if(vmDt==IRDataType.FLOAT) {
             val leftTr = translateExpression(binExpr.left)
             addToResult(result, leftTr, -1, leftTr.resultFpReg)
@@ -484,10 +585,10 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             } else {
                 if (lessEquals) Opcode.SLE else Opcode.SLT
             }
-            addInstr(result, IRInstruction(ins, IRDataType.BYTE, reg1 = resultRegister, reg2 = zeroRegister), null)
-            return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
+            addInstr(result, IRInstruction(ins, IRDataType.BYTE, reg1=cmpResultRegister, reg2 = resultRegister, reg3 = zeroRegister), null)
+            return ExpressionCodeResult(result, IRDataType.BYTE, cmpResultRegister, -1)
         } else {
-            if(binExpr.left.type==DataType.STR && binExpr.right.type==DataType.STR) {
+            if(binExpr.left.type==DataType.STR || binExpr.right.type==DataType.STR) {
                 throw AssemblyError("str compares should have been replaced with builtin function call to do the compare")
             } else {
                 val leftTr = translateExpression(binExpr.left)
@@ -499,8 +600,8 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 } else {
                     if (lessEquals) Opcode.SLE else Opcode.SLT
                 }
-                addInstr(result, IRInstruction(ins, vmDt, reg1 = leftTr.resultReg, reg2 = rightTr.resultReg), null)
-                return ExpressionCodeResult(result, IRDataType.BYTE, leftTr.resultReg, -1)
+                addInstr(result, IRInstruction(ins, vmDt, reg1=cmpResultRegister, reg2 = leftTr.resultReg, reg3 = rightTr.resultReg), null)
+                return ExpressionCodeResult(result, IRDataType.BYTE, cmpResultRegister, -1)
             }
         }
     }
@@ -515,18 +616,20 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             val resultRegister = codeGen.registers.nextFree()
             val valueReg = codeGen.registers.nextFree()
             val label = codeGen.createLabelName()
-            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=resultRegister, immediate = 1), null)
-            addInstr(result, IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=valueReg, fpReg1 = leftTr.resultFpReg, fpReg2 = rightTr.resultFpReg), null)
-            if (notEquals) {
-                addInstr(result, IRInstruction(Opcode.BNE, IRDataType.BYTE, reg1=valueReg, immediate = 0, labelSymbol = label), null)
-            } else {
-                addInstr(result, IRInstruction(Opcode.BEQ, IRDataType.BYTE, reg1=valueReg, immediate = 0, labelSymbol = label), null)
+            result += IRCodeChunk(null, null).also {
+                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=resultRegister, immediate = 1)
+                it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=valueReg, fpReg1 = leftTr.resultFpReg, fpReg2 = rightTr.resultFpReg)
+                it += IRInstruction(Opcode.CMPI, IRDataType.BYTE, reg1=valueReg, immediate = 0)
+                it += if (notEquals)
+                    IRInstruction(Opcode.BSTNE, labelSymbol = label)
+                else
+                    IRInstruction(Opcode.BSTEQ, labelSymbol = label)
+                it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=resultRegister, immediate = 0)
             }
-            addInstr(result, IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=resultRegister, immediate = 0), null)
             result += IRCodeChunk(label, null)
             return ExpressionCodeResult(result, IRDataType.BYTE, resultRegister, -1)
         } else {
-            if(binExpr.left.type==DataType.STR && binExpr.right.type==DataType.STR) {
+            if(binExpr.left.type==DataType.STR || binExpr.right.type==DataType.STR) {
                 throw AssemblyError("str compares should have been replaced with builtin function call to do the compare")
             } else {
                 return if(constValue(binExpr.right)==0.0) {
@@ -542,8 +645,9 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     val rightTr = translateExpression(binExpr.right)
                     addToResult(result, rightTr, rightTr.resultReg, -1)
                     val opcode = if (notEquals) Opcode.SNE else Opcode.SEQ
-                    addInstr(result, IRInstruction(opcode, vmDt, reg1 = leftTr.resultReg, reg2 = rightTr.resultReg), null)
-                    ExpressionCodeResult(result, IRDataType.BYTE, leftTr.resultReg, -1)
+                    val resultReg = codeGen.registers.nextFree()
+                    addInstr(result, IRInstruction(opcode, vmDt, reg1 = resultReg, reg2 = leftTr.resultReg, reg3 = rightTr.resultReg), null)
+                    ExpressionCodeResult(result, IRDataType.BYTE, resultReg, -1)
                 }
             }
         }
@@ -602,8 +706,19 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         }
     }
 
-    private fun operatorAnd(binExpr: PtBinaryExpression, vmDt: IRDataType): ExpressionCodeResult {
+    private fun operatorAnd(binExpr: PtBinaryExpression, vmDt: IRDataType, bitwise: Boolean): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        if(!bitwise && !binExpr.right.isSimple()) {
+            // short-circuit  LEFT and RIGHT  -->  if LEFT then RIGHT else LEFT   (== if !LEFT then LEFT else RIGHT)
+            val leftTr = translateExpression(binExpr.left)
+            addToResult(result, leftTr, leftTr.resultReg, -1)
+            val shortcutLabel = codeGen.createLabelName()
+            addInstr(result, IRInstruction(Opcode.BSTEQ, labelSymbol = shortcutLabel), null)
+            val rightTr = translateExpression(binExpr.right)
+            addToResult(result, rightTr, leftTr.resultReg, -1)
+            result += IRCodeChunk(shortcutLabel, null)
+            return ExpressionCodeResult(result, vmDt, leftTr.resultReg, -1)
+        } else {
             return if(binExpr.right is PtNumber) {
                 val tr = translateExpression(binExpr.left)
                 addToResult(result, tr, tr.resultReg, -1)
@@ -618,9 +733,21 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 ExpressionCodeResult(result, vmDt, leftTr.resultReg, -1)
             }
         }
+    }
 
-    private fun operatorOr(binExpr: PtBinaryExpression, vmDt: IRDataType): ExpressionCodeResult {
+    private fun operatorOr(binExpr: PtBinaryExpression, vmDt: IRDataType, bitwise: Boolean): ExpressionCodeResult {
         val result = mutableListOf<IRCodeChunkBase>()
+        if(!bitwise && !binExpr.right.isSimple()) {
+            // short-circuit  LEFT or RIGHT  -->  if LEFT then LEFT else RIGHT
+            val leftTr = translateExpression(binExpr.left)
+            addToResult(result, leftTr, leftTr.resultReg, -1)
+            val shortcutLabel = codeGen.createLabelName()
+            addInstr(result, IRInstruction(Opcode.BSTNE, labelSymbol = shortcutLabel), null)
+            val rightTr = translateExpression(binExpr.right)
+            addToResult(result, rightTr, leftTr.resultReg, -1)
+            result += IRCodeChunk(shortcutLabel, null)
+            return ExpressionCodeResult(result, vmDt, leftTr.resultReg, -1)
+        } else {
             return if(binExpr.right is PtNumber) {
                 val tr = translateExpression(binExpr.left)
                 addToResult(result, tr, tr.resultReg, -1)
@@ -635,6 +762,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 ExpressionCodeResult(result, vmDt, leftTr.resultReg, -1)
             }
         }
+    }
 
     private fun operatorModulo(binExpr: PtBinaryExpression, vmDt: IRDataType): ExpressionCodeResult {
         require(vmDt!=IRDataType.FLOAT) {"floating-point modulo not supported ${binExpr.position}"}
@@ -661,7 +789,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
                 val tr = translateExpression(binExpr.left)
                 addToResult(result, tr, -1, tr.resultFpReg)
-                val factor = constFactorRight.number.toFloat()
+                val factor = constFactorRight.number
                 result += codeGen.divideByConstFloat(tr.resultFpReg, factor)
                 return ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
             } else {
@@ -717,13 +845,13 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
             return if(constFactorLeft!=null) {
                 val tr = translateExpression(binExpr.right)
                 addToResult(result, tr, -1, tr.resultFpReg)
-                val factor = constFactorLeft.number.toFloat()
+                val factor = constFactorLeft.number
                 result += codeGen.multiplyByConstFloat(tr.resultFpReg, factor)
                 ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
             } else if(constFactorRight!=null) {
                 val tr = translateExpression(binExpr.left)
                 addToResult(result, tr, -1, tr.resultFpReg)
-                val factor = constFactorRight.number.toFloat()
+                val factor = constFactorRight.number
                 result += codeGen.multiplyByConstFloat(tr.resultFpReg, factor)
                 ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
             } else {
@@ -771,7 +899,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 return if(binExpr.right is PtNumber) {
                     val tr = translateExpression(binExpr.left)
                     addToResult(result, tr, -1, tr.resultFpReg)
-                    addInstr(result, IRInstruction(Opcode.SUB, vmDt, fpReg1 = tr.resultFpReg, immediateFp = (binExpr.right as PtNumber).number.toFloat()), null)
+                    addInstr(result, IRInstruction(Opcode.SUB, vmDt, fpReg1 = tr.resultFpReg, immediateFp = (binExpr.right as PtNumber).number), null)
                     ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
                 } else {
                     val leftTr = translateExpression(binExpr.left)
@@ -826,7 +954,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 return if(binExpr.right is PtNumber) {
                     val tr = translateExpression(binExpr.left)
                     addToResult(result, tr, -1, tr.resultFpReg)
-                    addInstr(result, IRInstruction(Opcode.ADD, vmDt, fpReg1 = tr.resultFpReg, immediateFp = (binExpr.right as PtNumber).number.toFloat()), null)
+                    addInstr(result, IRInstruction(Opcode.ADD, vmDt, fpReg1 = tr.resultFpReg, immediateFp = (binExpr.right as PtNumber).number), null)
                     ExpressionCodeResult(result, vmDt, -1, tr.resultFpReg)
                 } else {
                     val leftTr = translateExpression(binExpr.left)
@@ -876,8 +1004,38 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         addInstr(result, if(knownAddress!=null)
             IRInstruction(Opcode.ANDM, vmDt, reg1=tr.resultReg, address = knownAddress)
         else
-            IRInstruction(Opcode.ANDM, vmDt, reg1=tr.resultReg, labelSymbol = symbol)
-            ,null)
+            IRInstruction(Opcode.ANDM, vmDt, reg1=tr.resultReg, labelSymbol = symbol),null)
+        return result
+    }
+
+    internal fun operatorLogicalAndInplace(knownAddress: Int?, symbol: String?, vmDt: IRDataType, operand: PtExpression): IRCodeChunks {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = translateExpression(operand)
+        if(!operand.isSimple()) {
+            // short-circuit  LEFT and RIGHT  -->  if LEFT then RIGHT else LEFT   (== if !LEFT then LEFT else RIGHT)
+            val inplaceReg = codeGen.registers.nextFree()
+            val shortcutLabel = codeGen.createLabelName()
+            result += IRCodeChunk(null, null).also {
+                it += if(knownAddress!=null)
+                    IRInstruction(Opcode.LOADM, vmDt, reg1=inplaceReg, address = knownAddress)
+                else
+                    IRInstruction(Opcode.LOADM, vmDt, reg1=inplaceReg, labelSymbol = symbol)
+                it += IRInstruction(Opcode.BSTEQ, labelSymbol = shortcutLabel)
+            }
+            addToResult(result, tr, tr.resultReg, -1)
+            addInstr(result, if(knownAddress!=null)
+                IRInstruction(Opcode.STOREM, vmDt, reg1=tr.resultReg, address = knownAddress)
+            else
+                IRInstruction(Opcode.STOREM, vmDt, reg1=tr.resultReg, labelSymbol = symbol), null)
+            result += IRCodeChunk(shortcutLabel, null)
+        } else {
+            // normal evaluation, it is *likely* shorter and faster because of the simple operands.
+            addToResult(result, tr, tr.resultReg, -1)
+            addInstr(result, if(knownAddress!=null)
+                IRInstruction(Opcode.ANDM, vmDt, reg1=tr.resultReg, address = knownAddress)
+            else
+                IRInstruction(Opcode.ANDM, vmDt, reg1=tr.resultReg, labelSymbol = symbol),null)
+        }
         return result
     }
 
@@ -888,8 +1046,38 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         addInstr(result, if(knownAddress!=null)
             IRInstruction(Opcode.ORM, vmDt, reg1=tr.resultReg, address = knownAddress)
         else
-            IRInstruction(Opcode.ORM, vmDt, reg1=tr.resultReg, labelSymbol = symbol)
-            , null)
+            IRInstruction(Opcode.ORM, vmDt, reg1=tr.resultReg, labelSymbol = symbol), null)
+        return result
+    }
+
+    internal fun operatorLogicalOrInplace(knownAddress: Int?, symbol: String?, vmDt: IRDataType, operand: PtExpression): IRCodeChunks {
+        val result = mutableListOf<IRCodeChunkBase>()
+        val tr = translateExpression(operand)
+        if(!operand.isSimple()) {
+            // short-circuit  LEFT or RIGHT  -->  if LEFT then LEFT else RIGHT
+            val inplaceReg = codeGen.registers.nextFree()
+            val shortcutLabel = codeGen.createLabelName()
+            result += IRCodeChunk(null, null).also {
+                it += if(knownAddress!=null)
+                    IRInstruction(Opcode.LOADM, vmDt, reg1=inplaceReg, address = knownAddress)
+                else
+                    IRInstruction(Opcode.LOADM, vmDt, reg1=inplaceReg, labelSymbol = symbol)
+                it += IRInstruction(Opcode.BSTNE, labelSymbol = shortcutLabel)
+            }
+            addToResult(result, tr, tr.resultReg, -1)
+            addInstr(result, if(knownAddress!=null)
+                IRInstruction(Opcode.STOREM, vmDt, reg1=tr.resultReg, address = knownAddress)
+            else
+                IRInstruction(Opcode.STOREM, vmDt, reg1=tr.resultReg, labelSymbol = symbol), null)
+            result += IRCodeChunk(shortcutLabel, null)
+        } else {
+            // normal evaluation, it is *likely* shorter and faster because of the simple operands.
+            addToResult(result, tr, tr.resultReg, -1)
+            addInstr(result, if(knownAddress!=null)
+                IRInstruction(Opcode.ORM, vmDt, reg1=tr.resultReg, address = knownAddress)
+            else
+                IRInstruction(Opcode.ORM, vmDt, reg1=tr.resultReg, labelSymbol = symbol), null)
+        }
         return result
     }
 
@@ -898,7 +1086,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val constFactorRight = operand as? PtNumber
         if(vmDt==IRDataType.FLOAT) {
             if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
-                val factor = constFactorRight.number.toFloat()
+                val factor = constFactorRight.number
                 result += codeGen.divideByConstFloatInplace(knownAddress, symbol, factor)
             } else {
                 val tr = translateExpression(operand)
@@ -947,7 +1135,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val constFactorRight = operand as? PtNumber
         if(vmDt==IRDataType.FLOAT) {
             if(constFactorRight!=null) {
-                val factor = constFactorRight.number.toFloat()
+                val factor = constFactorRight.number
                 result += codeGen.multiplyByConstFloatInplace(knownAddress, symbol, factor)
             } else {
                 val tr = translateExpression(operand)
@@ -1213,6 +1401,7 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
     ): MutableList<IRCodeChunkBase> {
         val result = mutableListOf<IRCodeChunkBase>()
         val valueReg = codeGen.registers.nextFree()
+        val cmpResultReg = codeGen.registers.nextFree()
         if(operand is PtNumber) {
             val numberReg = codeGen.registers.nextFree()
             if (knownAddress != null) {
@@ -1220,16 +1409,16 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, vmDt, reg1 = valueReg, address = knownAddress)
                     it += IRInstruction(Opcode.LOAD, vmDt, reg1=numberReg, immediate = operand.number.toInt())
-                    it += IRInstruction(compareAndSetOpcode, vmDt, reg1 = valueReg, reg2 = numberReg)
-                    it += IRInstruction(Opcode.STOREM, vmDt, reg1 = valueReg, address = knownAddress)
+                    it += IRInstruction(compareAndSetOpcode, vmDt, reg1 = cmpResultReg, reg2 = valueReg, reg3 = numberReg)
+                    it += IRInstruction(Opcode.STOREM, vmDt, reg1 = cmpResultReg, address = knownAddress)
                 }
             } else {
                 // in-place modify a symbol (variable)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, vmDt, reg1 = valueReg, labelSymbol = symbol)
                     it += IRInstruction(Opcode.LOAD, vmDt, reg1=numberReg, immediate = operand.number.toInt())
-                    it += IRInstruction(compareAndSetOpcode, vmDt, reg1 = valueReg, reg2 = numberReg)
-                    it += IRInstruction(Opcode.STOREM, vmDt, reg1 = valueReg, labelSymbol = symbol)
+                    it += IRInstruction(compareAndSetOpcode, vmDt, reg1=cmpResultReg, reg2 = valueReg, reg3 = numberReg)
+                    it += IRInstruction(Opcode.STOREM, vmDt, reg1 = cmpResultReg, labelSymbol = symbol)
                 }
             }
         } else {
@@ -1239,15 +1428,15 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                 // in-place modify a memory location
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, vmDt, reg1 = valueReg, address = knownAddress)
-                    it += IRInstruction(compareAndSetOpcode, vmDt, reg1 = valueReg, reg2 = tr.resultReg)
-                    it += IRInstruction(Opcode.STOREM, vmDt, reg1 = valueReg, address = knownAddress)
+                    it += IRInstruction(compareAndSetOpcode, vmDt, reg1=cmpResultReg, reg2 = valueReg, reg3 = tr.resultReg)
+                    it += IRInstruction(Opcode.STOREM, vmDt, reg1 = cmpResultReg, address = knownAddress)
                 }
             } else {
                 // in-place modify a symbol (variable)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, vmDt, reg1 = valueReg, labelSymbol = symbol)
-                    it += IRInstruction(compareAndSetOpcode, vmDt, reg1 = valueReg, reg2 = tr.resultReg)
-                    it += IRInstruction(Opcode.STOREM, vmDt, reg1 = valueReg, labelSymbol = symbol)
+                    it += IRInstruction(compareAndSetOpcode, vmDt, reg1=cmpResultReg, reg2 = valueReg, reg3 = tr.resultReg)
+                    it += IRInstruction(Opcode.STOREM, vmDt, reg1 = cmpResultReg, labelSymbol = symbol)
                 }
             }
         }
@@ -1266,31 +1455,33 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
         val zeroReg = codeGen.registers.nextFree()
         if(operand is PtNumber) {
             val numberReg = codeGen.registers.nextFreeFloat()
+            val cmpResultReg = codeGen.registers.nextFree()
             if (knownAddress != null) {
                 // in-place modify a memory location
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = valueReg, address = knownAddress)
-                    it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = numberReg, immediateFp = operand.number.toFloat())
+                    it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = numberReg, immediateFp = operand.number)
                     it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg, fpReg2 = numberReg)
                     it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=zeroReg, immediate = 0)
-                    it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpReg, reg2=zeroReg)
-                    it += IRInstruction(Opcode.FFROMUB, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg)
+                    it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpResultReg, reg2=cmpReg, reg3=zeroReg)
+                    it += IRInstruction(Opcode.FFROMUB, IRDataType.FLOAT, reg1=cmpResultReg, fpReg1 = valueReg)
                     it += IRInstruction(Opcode.STOREM, IRDataType.FLOAT, fpReg1 = valueReg, address = knownAddress)
                 }
             } else {
                 // in-place modify a symbol (variable)
                 result += IRCodeChunk(null, null).also {
                     it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = valueReg, labelSymbol = symbol)
-                    it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = numberReg, immediateFp = operand.number.toFloat())
+                    it += IRInstruction(Opcode.LOAD, IRDataType.FLOAT, fpReg1 = numberReg, immediateFp = operand.number)
                     it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg, fpReg2 = numberReg)
                     it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=zeroReg, immediate = 0)
-                    it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpReg, reg2=zeroReg)
-                    it += IRInstruction(Opcode.FFROMUB, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg)
+                    it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpResultReg, reg2=cmpReg, reg3=zeroReg)
+                    it += IRInstruction(Opcode.FFROMUB, IRDataType.FLOAT, reg1=cmpResultReg, fpReg1 = valueReg)
                     it += IRInstruction(Opcode.STOREM, IRDataType.FLOAT, fpReg1 = valueReg, labelSymbol = symbol)
                 }
             }
         } else {
             val tr = translateExpression(operand)
+            val cmpResultReg = codeGen.registers.nextFree()
             addToResult(result, tr, -1, tr.resultFpReg)
             if (knownAddress != null) {
                 // in-place modify a memory location
@@ -1298,8 +1489,8 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = valueReg, address = knownAddress)
                     it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg, fpReg2 = tr.resultFpReg)
                     it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=zeroReg, immediate = 0)
-                    it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpReg, reg2=zeroReg)
-                    it += IRInstruction(Opcode.FFROMUB, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg)
+                    it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpResultReg, reg2=cmpReg, reg3=zeroReg)
+                    it += IRInstruction(Opcode.FFROMUB, IRDataType.FLOAT, reg1=cmpResultReg, fpReg1 = valueReg)
                     it += IRInstruction(Opcode.STOREM, IRDataType.FLOAT, fpReg1 = valueReg, address = knownAddress)
                 }
             } else {
@@ -1308,8 +1499,8 @@ internal class ExpressionGen(private val codeGen: IRCodeGen) {
                     it += IRInstruction(Opcode.LOADM, IRDataType.FLOAT, fpReg1 = valueReg, labelSymbol = symbol)
                     it += IRInstruction(Opcode.FCOMP, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg, fpReg2 = tr.resultFpReg)
                     it += IRInstruction(Opcode.LOAD, IRDataType.BYTE, reg1=zeroReg, immediate = 0)
-                    it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpReg, reg2=zeroReg)
-                    it += IRInstruction(Opcode.FFROMUB, IRDataType.FLOAT, reg1=cmpReg, fpReg1 = valueReg)
+                    it += IRInstruction(compareAndSetOpcode, IRDataType.BYTE, reg1=cmpResultReg, reg2=cmpReg, reg3=zeroReg)
+                    it += IRInstruction(Opcode.FFROMUB, IRDataType.FLOAT, reg1=cmpResultReg, fpReg1 = valueReg)
                     it += IRInstruction(Opcode.STOREM, IRDataType.FLOAT, fpReg1 = valueReg, labelSymbol = symbol)
                 }
             }

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

@@ -23,7 +23,7 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
     }
 
     private fun optimizeOnlyJoinChunks() {
-        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
+        irprog.foreachSub { sub ->
             joinChunks(sub)
             removeEmptyChunks(sub)
             joinChunks(sub)
@@ -32,10 +32,11 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
     }
 
     private fun peepholeOptimize() {
-        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
+        irprog.foreachSub { sub ->
             joinChunks(sub)
             removeEmptyChunks(sub)
             joinChunks(sub)
+
             sub.chunks.withIndex().forEach { (index, chunk1) ->
                 // we don't optimize Inline Asm chunks here.
                 val chunk2 = if(index<sub.chunks.size-1) sub.chunks[index+1] else null
@@ -44,22 +45,41 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                         val indexedInstructions = chunk1.instructions.withIndex()
                             .map { IndexedValue(it.index, it.value) }
                         val changed = removeNops(chunk1, indexedInstructions)
-                                || removeDoubleLoadsAndStores(chunk1, indexedInstructions)       // TODO not yet implemented
+                                || replaceConcatZeroMsbWithExt(chunk1, indexedInstructions)
+                                || removeDoubleLoadsAndStores(chunk1, indexedInstructions)
                                 || removeUselessArithmetic(chunk1, indexedInstructions)
+                                || removeNeedlessCompares(chunk1, indexedInstructions)
                                 || removeWeirdBranches(chunk1, chunk2, indexedInstructions)
                                 || removeDoubleSecClc(chunk1, indexedInstructions)
                                 || cleanupPushPop(chunk1, indexedInstructions)
-                        // TODO other optimizations:
-                        //  more complex optimizations such as unused registers
+                        // TODO other optimizations
                     } while (changed)
                 }
             }
             removeEmptyChunks(sub)
         }
 
+        // TODO also do register optimization step here at the end?
+
         irprog.linkChunks()  // re-link
     }
 
+    private fun replaceConcatZeroMsbWithExt(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if (ins.opcode == Opcode.CONCAT) {
+                // if the previous instruction loads a zero in the msb, this can be turned into EXT.B instead
+                val prev = indexedInstructions[idx-1].value
+                if(prev.opcode==Opcode.LOAD && prev.immediate==0 && prev.reg1==ins.reg2) {
+                    chunk.instructions[idx] = IRInstruction(Opcode.EXT, IRDataType.BYTE, reg1 = ins.reg1, reg2 = ins.reg3)
+                    chunk.instructions.removeAt(idx-1)
+                    changed = true
+                }
+            }
+        }
+        return changed
+    }
+
     private fun removeEmptyChunks(sub: IRSubroutine) {
         if(sub.chunks.isEmpty())
             return
@@ -67,7 +87,7 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
         /*
         Empty Code chunk with label ->
             If next chunk has no label -> move label to next chunk, remove original
-            If next chunk has label -> label name should be the same, remove original. Otherwise FOR NOW leave it in place. (TODO: merge both labels into 1)
+            If next chunk has label -> label name should be the same, remove original. Otherwise merge both labels into 1.
             If is last chunk -> keep chunk in place because of the label.
         Empty Code chunk without label ->
             should not have been generated! ERROR.
@@ -76,6 +96,7 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
 
         val relabelChunks = mutableListOf<Pair<Int, String>>()
         val removeChunks = mutableListOf<Int>()
+        val replaceLabels = mutableMapOf<String, String>()
 
         sub.chunks.withIndex().forEach { (index, chunk) ->
             if(chunk is IRCodeChunk && chunk.instructions.isEmpty()) {
@@ -89,10 +110,18 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                             relabelChunks += Pair(index + 1, chunk.label!!)
                             removeChunks += index
                         } else {
+                            // merge both labels into 1 except if this is the label chunk at the start of the subroutine
+                            if(index>0) {
                                 if (chunk.label == nextchunk.label)
                                     removeChunks += index
                                 else {
-                                // TODO: merge labels on same chunk
+                                    removeChunks += index
+                                    replaceLabels[chunk.label!!] = nextchunk.label!!
+                                    replaceLabels.entries.forEach { (key, value) ->
+                                        if (value == chunk.label)
+                                            replaceLabels[key] = nextchunk.label!!
+                                    }
+                                }
                             }
                         }
                     }
@@ -102,10 +131,32 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
 
         relabelChunks.forEach { (index, label) ->
             val chunk = IRCodeChunk(label, null)
-            chunk.instructions += sub.chunks[index].instructions
+            val subChunk = sub.chunks[index]
+            chunk.instructions += subChunk.instructions
+            if(subChunk is IRCodeChunk)
+                chunk.appendSrcPositions(subChunk.sourceLinesPositions)
             sub.chunks[index] = chunk
         }
         removeChunks.reversed().forEach { index -> sub.chunks.removeAt(index) }
+
+        sub.chunks.forEach { chunk ->
+            chunk.instructions.withIndex().forEach { (idx, instr) ->
+                instr.labelSymbol?.let {
+                    if(instr.opcode in OpcodesThatBranch) {
+                        replaceLabels.forEach { (from, to) ->
+                            if (it == from) {
+                                chunk.instructions[idx] = instr.copy(labelSymbol = to)
+                            }
+                            else {
+                                val actualPrefix = "$from."
+                                if (it.startsWith(actualPrefix))
+                                    chunk.instructions[idx] = instr.copy(labelSymbol = "$to.")
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
 
     private fun joinChunks(sub: IRSubroutine) {
@@ -137,6 +188,8 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
                     if(mayJoinCodeChunks(lastChunk, candidate)) {
                         lastChunk.instructions += candidate.instructions
                         lastChunk.next = candidate.next
+                        if(lastChunk is IRCodeChunk)
+                            lastChunk.appendSrcPositions(candidate.sourceLinesPositions)
                     }
                     else
                         chunks += candidate
@@ -264,6 +317,30 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
         return changed
     }
 
+    private fun removeNeedlessCompares(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        // a CMPI with 0, after an instruction like LOAD that already sets the status bits, can be removed.
+        // but only if the instruction after it is not using the Carry bit because that won't be set by a LOAD instruction etc.
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if(idx>0 && idx<(indexedInstructions.size-1) && ins.opcode==Opcode.CMPI && ins.immediate==0) {
+                val previous = indexedInstructions[idx-1].value
+                if(previous.reg1==ins.reg1) {
+                    if (previous.opcode in OpcodesThatSetStatusbitsIncludingCarry) {
+                        chunk.instructions.removeAt(idx)
+                        changed = true
+                    } else if (previous.opcode in OpcodesThatSetStatusbitsButNotCarry) {
+                        val next = indexedInstructions[idx + 1].value
+                        if (next.opcode !in OpcodesThatDependOnCarry) {
+                            chunk.instructions.removeAt(idx)
+                            changed = true
+                        }
+                    }
+                }
+            }
+        }
+        return changed
+    }
+
     private fun removeUselessArithmetic(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
         // note: this is hard to solve for the non-immediate instructions atm because the values are loaded into registers first
         var changed = false
@@ -333,18 +410,21 @@ class IRPeepholeOptimizer(private val irprog: IRProgram) {
     }
 
     private fun removeDoubleLoadsAndStores(chunk: IRCodeChunk, indexedInstructions: List<IndexedValue<IRInstruction>>): Boolean {
+        return false
+
+/*
         var changed = false
         indexedInstructions.forEach { (idx, ins) ->
 
             // TODO: detect multiple loads to the same target registers, only keep first (if source is not I/O memory)
             // TODO: detect multiple stores to the same target, only keep first (if target is not I/O memory)
             // TODO: detect multiple float ffrom/fto to the same target, only keep first
-            // TODO: detect multiple sequential rnd with same reg1, only keep one
             // TODO: detect subsequent same xors/nots/negs, remove the pairs completely as they cancel out
             // TODO: detect multiple same ands, ors; only keep first
             // TODO: (hard) detect multiple registers being assigned the same value (and not changed) - use only 1 of them
             // ...
         }
         return changed
+*/
     }
 }

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

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

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

@@ -1,7 +1,6 @@
 package prog8.codegen.intermediate
 
 import prog8.code.core.IErrorReporter
-import prog8.code.core.SourceCode.Companion.libraryFilePrefix
 import prog8.intermediate.*
 
 
@@ -16,7 +15,7 @@ class IRUnusedCodeRemover(
         irprog.blocks.reversed().forEach { block ->
             if(block.isEmpty()) {
                 irprog.blocks.remove(block)
-                irprog.st.removeTree(block.label)
+                pruneSymboltable(block.label)
                 numRemoved++
             }
         }
@@ -24,20 +23,45 @@ class IRUnusedCodeRemover(
         return numRemoved
     }
 
+    private fun pruneSymboltable(blockLabel: String) {
+        // we could clean up the SymbolTable as well, but ONLY if these symbols aren't referenced somewhere still in an instruction or variable initializer value
+        val prefix = "$blockLabel."
+        val blockVars = irprog.st.allVariables().filter { it.name.startsWith(prefix) }
+        blockVars.forEach { stVar ->
+            irprog.allSubs().flatMap { it.chunks }.forEach { chunk ->
+                chunk.instructions.forEach { ins ->
+                    if(ins.labelSymbol == stVar.name) {
+                        return  // symbol occurs in an instruction
+                    }
+                }
+            }
+
+            irprog.st.allVariables().forEach { variable ->
+                val initValue = variable.onetimeInitializationArrayValue
+                if(!initValue.isNullOrEmpty()) {
+                    if(initValue.any {
+                        it.addressOfSymbol?.startsWith(blockLabel)==true
+                    })
+                        return   // symbol occurs in an initializer value (address-of this symbol)_
+                }
+            }
+        }
+
+        irprog.st.removeTree(blockLabel)
+    }
+
     private fun removeUnusedSubroutines(): Int {
         val allLabeledChunks = mutableMapOf<String, IRCodeChunkBase>()
-        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
-            sub.chunks.forEach { chunk ->
+        irprog.foreachCodeChunk { 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)
+                    if(!block.options.ignoreUnused) {
+                        errors.info("unused subroutine '${sub.label}'", sub.position)
                     }
                     block.children.remove(sub)
                     irprog.st.removeTree(sub.label)
@@ -57,8 +81,8 @@ class IRUnusedCodeRemover(
         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)
+                    if(!block.options.ignoreUnused) {
+                        errors.info("unused subroutine '${sub.label}'", sub.position)
                     }
                     block.children.remove(sub)
                     irprog.st.removeTree(sub.label)
@@ -78,7 +102,7 @@ class IRUnusedCodeRemover(
         // check if asmsub is called from another asmsub
         irprog.blocks.asSequence().forEach { block ->
             block.children.filterIsInstance<IRAsmSubroutine>().forEach { sub ->
-                if (block.forceOutput || block.library)
+                if (block.options.forceOutput || block.library)
                     linkedAsmSubs += sub
                 if (sub.asmChunk.isNotEmpty()) {
                     allSubs.forEach { (label, asmsub) ->
@@ -97,14 +121,12 @@ class IRUnusedCodeRemover(
         }
 
         // 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 ->
+        irprog.foreachCodeChunk { 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)
     }
@@ -123,16 +145,35 @@ class IRUnusedCodeRemover(
     }
 
     private fun removeUnreachable(allLabeledChunks: MutableMap<String, IRCodeChunkBase>): Int {
-        val entrypointSub = irprog.blocks.single { it.label=="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())
 
+        // all chunks referenced in array initializer values are also 'reachable':
+        irprog.st.allVariables()
+            .filter { !it.uninitialized }
+            .forEach {
+                it.onetimeInitializationArrayValue?.let { array ->
+                    array.forEach {elt ->
+                        if(elt.addressOfSymbol!=null && irprog.st.lookup(elt.addressOfSymbol!!)==null)
+                            reachable.add(irprog.getChunkWithLabel(elt.addressOfSymbol!!))
+                    }
+                }
+            }
+
         fun grow() {
             val new = mutableSetOf<IRCodeChunkBase>()
             reachable.forEach {
                 it.next?.let { next -> new += next }
                 it.instructions.forEach { instr ->
                     if (instr.branchTarget == null)
-                        instr.labelSymbol?.let { label -> allLabeledChunks[label]?.let { chunk -> new += chunk } }
+                        instr.labelSymbol?.let { label ->
+                            val chunk = allLabeledChunks[label.substringBeforeLast('.')]
+                            if(chunk!=null)
+                                new+=chunk
+                            else
+                                allLabeledChunks[label]?.let { new += it }
+                        }
                     else
                         new += instr.branchTarget!!
                 }
@@ -154,8 +195,19 @@ class IRUnusedCodeRemover(
     private fun removeSimpleUnlinked(allLabeledChunks: Map<String, IRCodeChunkBase>): Int {
         val linkedChunks = mutableSetOf<IRCodeChunkBase>()
 
-        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
-            sub.chunks.forEach { chunk ->
+        // all chunks referenced in array initializer values are linked as well!:
+        irprog.st.allVariables()
+            .filter { !it.uninitialized }
+            .forEach {
+                it.onetimeInitializationArrayValue?.let { array ->
+                    array.forEach {elt ->
+                        if(elt.addressOfSymbol!=null && irprog.st.lookup(elt.addressOfSymbol!!)==null)
+                            linkedChunks += irprog.getChunkWithLabel(elt.addressOfSymbol!!)
+                    }
+                }
+            }
+
+        irprog.foreachCodeChunk { chunk ->
             chunk.next?.let { next -> linkedChunks += next }
             chunk.instructions.forEach {
                 if(it.branchTarget==null) {
@@ -167,16 +219,23 @@ class IRUnusedCodeRemover(
             if (chunk.label == "main.start")
                 linkedChunks += chunk
         }
+
+        // make sure that chunks that are only used as a prefix of a label, are also marked as linked
+        linkedChunks.toList().forEach { chunk ->
+            chunk.instructions.forEach {
+                if(it.labelSymbol!=null) {
+                    val chunkName = it.labelSymbol!!.substringBeforeLast('.')
+                    allLabeledChunks[chunkName]?.let { linkedChunks+=it }
+                }
+            }
         }
 
         return removeUnlinkedChunks(linkedChunks)
     }
 
-    private fun removeUnlinkedChunks(
-        linkedChunks: Set<IRCodeChunkBase>
-    ): Int {
+    private fun removeUnlinkedChunks(linkedChunks: Set<IRCodeChunkBase>): Int {
         var numRemoved = 0
-        irprog.blocks.asSequence().flatMap { it.children.filterIsInstance<IRSubroutine>() }.forEach { sub ->
+        irprog.foreachSub { sub ->
             sub.chunks.withIndex().reversed().forEach { (index, chunk) ->
                 if (chunk !in linkedChunks) {
                     if (chunk === sub.chunks[0]) {

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

@@ -16,7 +16,7 @@ class VmCodeGen: ICodeGeneratorBackend {
         symbolTable: SymbolTable,
         options: CompilationOptions,
         errors: IErrorReporter
-    ): IAssemblyProgram? {
+    ): IAssemblyProgram {
         val irCodeGen = IRCodeGen(program, symbolTable, options, errors)
         val irProgram = irCodeGen.generate()
         return VmAssemblyProgram(irProgram.name, irProgram)

codeGenIntermediate/test/Dummies.kt

@@ -16,6 +16,8 @@ internal object DummyMemsizer : IMemSizer {
 }
 
 internal object DummyStringEncoder : IStringEncoding {
+    override val defaultEncoding: Encoding = Encoding.ISO
+
     override fun encodeString(str: String, encoding: Encoding): List<UByte> {
         return emptyList()
     }
@@ -25,11 +27,11 @@ internal object DummyStringEncoder : IStringEncoding {
     }
 }
 
-internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true, private val keepMessagesAfterReporting: Boolean=false):
-    IErrorReporter {
+internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors: Boolean=true, private val keepMessagesAfterReporting: Boolean=false): IErrorReporter {
 
     val errors = mutableListOf<String>()
     val warnings = mutableListOf<String>()
+    val infos = mutableListOf<String>()
 
     override fun err(msg: String, position: Position) {
         val text = "${position.toClickableStr()} $msg"
@@ -43,13 +45,24 @@ internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors:
             warnings.add(text)
     }
 
+    override fun info(msg: String, position: Position) {
+        val text = "${position.toClickableStr()} $msg"
+        if(text !in infos)
+            infos.add(text)
+    }
+
+    override fun undefined(symbol: List<String>, position: Position) {
+        err("undefined symbol: ${symbol.joinToString(".")}", position)
+    }
+
     override fun noErrors(): Boolean  = errors.isEmpty()
 
     override fun report() {
+        infos.forEach { println("UNITTEST COMPILATION REPORT: INFO: $it") }
         warnings.forEach { println("UNITTEST COMPILATION REPORT: WARNING: $it") }
         errors.forEach { println("UNITTEST COMPILATION REPORT: ERROR: $it") }
         if(throwExceptionAtReportIfErrors)
-            finalizeNumErrors(errors.size, warnings.size)
+            finalizeNumErrors(errors.size, warnings.size, infos.size)
         if(!keepMessagesAfterReporting) {
             clear()
         }
@@ -58,5 +71,6 @@ internal class ErrorReporterForTests(private val throwExceptionAtReportIfErrors:
     fun clear() {
         errors.clear()
         warnings.clear()
+        infos.clear()
     }
 }

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, false, false, IRBlock.BlockAlignment.NONE, Position.DUMMY)
+        val block = IRBlock("main", false, IRBlock.Options(), Position.DUMMY)
         val sub = IRSubroutine("main.start", emptyList(), null, Position.DUMMY)
         chunks.forEach { sub += it }
         block += sub
@@ -18,12 +18,13 @@ class TestIRPeepholeOpt: FunSpec({
             CbmPrgLauncherType.NONE,
             ZeropageType.DONTUSE,
             emptyList(),
+            CompilationOptions.AllZeropageAllowed,
             floats = false,
             noSysInit = true,
             compTarget = target,
             loadAddress = target.machine.PROGRAM_LOAD_ADDRESS
         )
-        val prog = IRProgram("test", IRSymbolTable(null), options, target)
+        val prog = IRProgram("test", IRSymbolTable(), options, target)
         prog.addBlock(block)
         prog.linkChunks()
         prog.validate()
@@ -36,7 +37,7 @@ class TestIRPeepholeOpt: FunSpec({
         return makeIRProgram(listOf(chunk))
     }
 
-    fun IRProgram.chunks(): List<IRCodeChunkBase> = this.blocks.flatMap { it.children.filterIsInstance<IRSubroutine>() }.flatMap { it.chunks }
+    fun IRProgram.chunks(): List<IRCodeChunkBase> = this.allSubs().flatMap { it.chunks }.toList()
 
     test("remove nops") {
         val irProg = makeIRProgram(listOf(
@@ -52,9 +53,9 @@ class TestIRPeepholeOpt: FunSpec({
 
     test("remove jmp to label below") {
         val c1 = IRCodeChunk("main.start", null)
-        c1 += IRInstruction(Opcode.JUMP, labelSymbol = "label")  // removed, but chunk stays because of label
+        c1 += IRInstruction(Opcode.JUMP, labelSymbol = "label")
         val c2 = IRCodeChunk("label", null)
-        c2 += IRInstruction(Opcode.JUMP, labelSymbol = "label2") // removed, but chunk stays because of label
+        c2 += IRInstruction(Opcode.JUMP, labelSymbol = "label2")
         c2 += IRInstruction(Opcode.NOP)  // removed
         val c3 = IRCodeChunk("label2", null)
         c3 += IRInstruction(Opcode.JUMP, labelSymbol = "label3")
@@ -66,15 +67,13 @@ class TestIRPeepholeOpt: FunSpec({
         irProg.chunks().flatMap { it.instructions }.size shouldBe 5
         val opt = IRPeepholeOptimizer(irProg)
         opt.optimize(true, ErrorReporterForTests())
-        irProg.chunks().size shouldBe 4
+        irProg.chunks().size shouldBe 3
         irProg.chunks()[0].label shouldBe "main.start"
-        irProg.chunks()[1].label shouldBe "label"
-        irProg.chunks()[2].label shouldBe "label2"
-        irProg.chunks()[3].label shouldBe "label3"
+        irProg.chunks()[1].label shouldBe "label2"
+        irProg.chunks()[2].label shouldBe "label3"
         irProg.chunks()[0].isEmpty() shouldBe true
-        irProg.chunks()[1].isEmpty() shouldBe true
-        irProg.chunks()[2].isEmpty() shouldBe false
-        irProg.chunks()[3].isEmpty() shouldBe true
+        irProg.chunks()[1].isEmpty() shouldBe false
+        irProg.chunks()[2].isEmpty() shouldBe true
         val instr = irProg.chunks().flatMap { it.instructions }
         instr.size shouldBe 2
         instr[0].opcode shouldBe Opcode.JUMP

codeGenIntermediate/test/TestVmCodeGen.kt

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

codeOptimizers/build.gradle

@@ -27,16 +27,17 @@ dependencies {
     implementation project(':codeCore')
     implementation project(':compilerAst')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
 }
 
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
 }

codeOptimizers/codeOptimizers.iml

@@ -11,5 +11,6 @@
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
     <orderEntry type="module" module-name="codeCore" />
     <orderEntry type="module" module-name="compilerAst" />
+    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
   </component>
 </module>

codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt

@@ -1,71 +0,0 @@
-package prog8.optimizer
-
-import prog8.ast.IStatementContainer
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.expressions.BinaryExpression
-import prog8.ast.statements.AssignTarget
-import prog8.ast.statements.Assignment
-import prog8.ast.statements.AssignmentOrigin
-import prog8.ast.walk.AstWalker
-import prog8.ast.walk.IAstModification
-import prog8.code.core.AugmentAssignmentOperators
-import prog8.code.core.CompilationOptions
-import prog8.code.core.DataType
-import prog8.code.target.VMTarget
-
-
-class BinExprSplitter(private val program: Program, private val options: CompilationOptions) : AstWalker() {
-
-    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
-
-        if(options.compTarget.name == VMTarget.NAME)
-            return noModifications  // don't split expressions when targeting the vm codegen, it handles nested expressions well
-
-        if(assignment.value.inferType(program) istype DataType.FLOAT && !options.optimizeFloatExpressions)
-            return noModifications
-
-        val binExpr = assignment.value as? BinaryExpression
-        if (binExpr != null) {
-
-            if(binExpr.operator in AugmentAssignmentOperators && isSimpleTarget(assignment.target)) {
-                if(assignment.target isSameAs binExpr.right)
-                    return noModifications
-                if(assignment.target isSameAs binExpr.left) {
-                    if(binExpr.right.isSimple)
-                        return noModifications
-                    val leftBx = binExpr.left as? BinaryExpression
-                    if(leftBx!=null && (!leftBx.left.isSimple || !leftBx.right.isSimple))
-                        return noModifications
-                    val rightBx = binExpr.right as? BinaryExpression
-                    if(rightBx!=null && (!rightBx.left.isSimple || !rightBx.right.isSimple))
-                        return noModifications
-                }
-
-                if(binExpr.right.isSimple) {
-                    val firstAssign = Assignment(assignment.target.copy(), binExpr.left, AssignmentOrigin.OPTIMIZER, binExpr.left.position)
-                    val targetExpr = assignment.target.toExpression()
-                    val augExpr = BinaryExpression(targetExpr, binExpr.operator, binExpr.right, binExpr.right.position)
-                    return listOf(
-                        IAstModification.ReplaceNode(binExpr, augExpr, assignment),
-                        IAstModification.InsertBefore(assignment, firstAssign, assignment.parent as IStatementContainer)
-                    )
-                }
-            }
-
-            // Further unraveling of binary expressions is really complicated here and
-            // often results in much bigger code, thereby defeating the purpose a bit.
-            // All in all this should probably be fixed in a better code generation backend
-            // that doesn't require this at all.
-        }
-
-        return noModifications
-    }
-
-    private fun isSimpleTarget(target: AssignTarget) =
-            if (target.identifier!=null || target.memoryAddress!=null)
-                !target.isIOAddress(options.compTarget.machine)
-            else
-                false
-
-}

codeOptimizers/src/prog8/optimizer/ConstExprEvaluator.kt

@@ -1,17 +1,19 @@
 package prog8.optimizer
 
+import prog8.ast.Program
 import prog8.ast.base.ExpressionError
 import prog8.ast.base.FatalAstException
-import prog8.ast.expressions.Expression
+import prog8.ast.expressions.FunctionCallExpression
 import prog8.ast.expressions.NumericLiteral
 import prog8.code.core.DataType
 import prog8.code.core.IntegerDatatypes
 import prog8.code.core.Position
+import kotlin.math.*
 
 
 class ConstExprEvaluator {
 
-    fun evaluate(left: NumericLiteral, operator: String, right: NumericLiteral): Expression {
+    fun evaluate(left: NumericLiteral, operator: String, right: NumericLiteral): NumericLiteral {
         try {
             return when(operator) {
                 "+" -> plus(left, right)
@@ -19,9 +21,9 @@ class ConstExprEvaluator {
                 "*" -> multiply(left, right)
                 "/" -> divide(left, right)
                 "%" -> remainder(left, right)
-                "&" -> bitwiseand(left, right)
-                "|" -> bitwiseor(left, right)
-                "^" -> bitwisexor(left, right)
+                "&" -> bitwiseAnd(left, right)
+                "|" -> bitwiseOr(left, right)
+                "^" -> bitwiseXor(left, right)
                 "<" -> NumericLiteral.fromBoolean(left < right, left.position)
                 ">" -> NumericLiteral.fromBoolean(left > right, left.position)
                 "<=" -> NumericLiteral.fromBoolean(left <= right, left.position)
@@ -30,6 +32,9 @@ class ConstExprEvaluator {
                 "!=" -> NumericLiteral.fromBoolean(left != right, left.position)
                 "<<" -> shiftedleft(left, right)
                 ">>" -> shiftedright(left, right)
+                "and" -> logicalAnd(left, right)
+                "or" -> logicalOr(left, right)
+                "xor" -> logicalXor(left, right)
                 else -> throw FatalAstException("const evaluation for invalid operator $operator")
             }
         } catch (ax: FatalAstException) {
@@ -37,7 +42,7 @@ class ConstExprEvaluator {
         }
     }
 
-    private fun shiftedright(left: NumericLiteral, amount: NumericLiteral): Expression {
+    private fun shiftedright(left: NumericLiteral, amount: NumericLiteral): NumericLiteral {
         if(left.type !in IntegerDatatypes || amount.type !in IntegerDatatypes)
             throw ExpressionError("cannot compute $left >> $amount", left.position)
         val result =
@@ -48,52 +53,81 @@ class ConstExprEvaluator {
         return NumericLiteral(left.type, result.toDouble(), left.position)
     }
 
-    private fun shiftedleft(left: NumericLiteral, amount: NumericLiteral): Expression {
+    private fun shiftedleft(left: NumericLiteral, amount: NumericLiteral): NumericLiteral {
         if(left.type !in IntegerDatatypes || amount.type !in IntegerDatatypes)
             throw ExpressionError("cannot compute $left << $amount", left.position)
         val result = left.number.toInt().shl(amount.number.toInt())
-        return NumericLiteral(left.type, result.toDouble(), left.position)
+//        when(left.type) {
+//            DataType.BOOL -> result = result and 1
+//            DataType.UBYTE -> result = result and 255
+//            DataType.BYTE -> result = result.toByte().toInt()
+//            DataType.UWORD -> result = result and 65535
+//            DataType.WORD -> result = result.toShort().toInt()
+//            else -> { /* keep as it is */ }
+//        }
+        return NumericLiteral.optimalNumeric(result.toDouble(), left.position)
     }
 
-    private fun bitwisexor(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
+    private fun bitwiseXor(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
         if(left.type== DataType.UBYTE) {
             if(right.type in IntegerDatatypes) {
                 return NumericLiteral(DataType.UBYTE, (left.number.toInt() xor (right.number.toInt() and 255)).toDouble(), left.position)
             }
         } else if(left.type== DataType.UWORD) {
             if(right.type in IntegerDatatypes) {
-                return NumericLiteral(DataType.UWORD, (left.number.toInt() xor right.number.toInt()).toDouble(), left.position)
+                return NumericLiteral(DataType.UWORD, (left.number.toInt() xor right.number.toInt() and 65535).toDouble(), left.position)
+            }
+        } else if(left.type== DataType.LONG) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteral.optimalNumeric((left.number.toInt() xor right.number.toInt()).toDouble(), left.position)
             }
         }
         throw ExpressionError("cannot calculate $left ^ $right", left.position)
     }
 
-    private fun bitwiseor(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
+    private fun bitwiseOr(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
         if(left.type== DataType.UBYTE) {
             if(right.type in IntegerDatatypes) {
                 return NumericLiteral(DataType.UBYTE, (left.number.toInt() or (right.number.toInt() and 255)).toDouble(), left.position)
             }
         } else if(left.type== DataType.UWORD) {
             if(right.type in IntegerDatatypes) {
-                return NumericLiteral(DataType.UWORD, (left.number.toInt() or right.number.toInt()).toDouble(), left.position)
+                return NumericLiteral(DataType.UWORD, (left.number.toInt() or right.number.toInt() and 65535).toDouble(), left.position)
+            }
+        } else if(left.type== DataType.LONG) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteral.optimalNumeric((left.number.toInt() or right.number.toInt()).toDouble(), left.position)
             }
         }
         throw ExpressionError("cannot calculate $left | $right", left.position)
     }
 
-    private fun bitwiseand(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
+    private fun bitwiseAnd(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
         if(left.type== DataType.UBYTE) {
             if(right.type in IntegerDatatypes) {
                 return NumericLiteral(DataType.UBYTE, (left.number.toInt() and (right.number.toInt() and 255)).toDouble(), left.position)
             }
         } else if(left.type== DataType.UWORD) {
             if(right.type in IntegerDatatypes) {
-                return NumericLiteral(DataType.UWORD, (left.number.toInt() and right.number.toInt()).toDouble(), left.position)
+                return NumericLiteral(DataType.UWORD, (left.number.toInt() and right.number.toInt() and 65535).toDouble(), left.position)
+            }
+        } else if(left.type== DataType.LONG) {
+            if(right.type in IntegerDatatypes) {
+                return NumericLiteral.optimalNumeric((left.number.toInt() and right.number.toInt()).toDouble(), left.position)
             }
         }
         throw ExpressionError("cannot calculate $left & $right", left.position)
     }
 
+    private fun logicalAnd(left: NumericLiteral, right: NumericLiteral): NumericLiteral =
+        NumericLiteral.fromBoolean(left.asBooleanValue and right.asBooleanValue, left.position)
+
+    private fun logicalOr(left: NumericLiteral, right: NumericLiteral): NumericLiteral =
+        NumericLiteral.fromBoolean(left.asBooleanValue or right.asBooleanValue, left.position)
+
+    private fun logicalXor(left: NumericLiteral, right: NumericLiteral): NumericLiteral =
+        NumericLiteral.fromBoolean(left.asBooleanValue xor right.asBooleanValue, left.position)
+
     private fun plus(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
         val error = "cannot add $left and $right"
         return when (left.type) {
@@ -206,4 +240,154 @@ class ConstExprEvaluator {
             else -> throw ExpressionError(error, left.position)
         }
     }
+
+    fun evaluate(call: FunctionCallExpression, program: Program): NumericLiteral? {
+        if(call.target.nameInSource.size!=2)
+            return null  // likely a builtin function, or user function, these get evaluated elsewhere
+        val constArgs = call.args.mapNotNull { it.constValue(program) }
+        if(constArgs.size!=call.args.size)
+            return null
+
+        return when(call.target.nameInSource[0]) {
+            "math" -> evalMath(call, constArgs)
+            "floats" -> evalFloats(call, constArgs)
+            "string" -> evalString(call, constArgs)
+            else -> null
+        }
+    }
+
+    private fun evalFloats(func: FunctionCallExpression, args: List<NumericLiteral>): NumericLiteral? {
+        val result= when(func.target.nameInSource[1]) {
+            "pow" -> args[0].number.pow(args[1].number)
+            "sin" -> sin(args[0].number)
+            "cos" -> cos(args[0].number)
+            "tan" -> tan(args[0].number)
+            "atan" -> atan(args[0].number)
+            "ln" -> ln(args[0].number)
+            "log2" -> log2(args[0].number)
+            "rad" -> args[0].number/360.0 * 2 * PI
+            "deg" -> args[0].number/ 2 / PI * 360.0
+            "round" -> round(args[0].number)
+            "floor" -> floor(args[0].number)
+            "ceil" -> ceil(args[0].number)
+            "minf", "min" -> min(args[0].number, args[1].number)
+            "maxf", "max" -> max(args[0].number, args[1].number)
+            "clampf", "clamp" -> {
+                var value = args[0].number
+                val minimum = args[1].number
+                val maximum = args[2].number
+                if(value<minimum)
+                    value=minimum
+                if(value<maximum)
+                    value
+                else
+                    maximum
+            }
+            else -> null
+        }
+
+        return if(result==null)
+            null
+        else
+            NumericLiteral(DataType.FLOAT, result, func.position)
+    }
+
+    private fun evalMath(func: FunctionCallExpression, args: List<NumericLiteral>): NumericLiteral? {
+        return when(func.target.nameInSource[1]) {
+            "sin8u" -> {
+                val value = truncate(128.0 + 127.5 * sin(args.single().number / 256.0 * 2 * PI))
+                NumericLiteral(DataType.UBYTE, value, func.position)
+            }
+            "cos8u" -> {
+                val value = truncate(128.0 + 127.5 * cos(args.single().number / 256.0 * 2 * PI))
+                NumericLiteral(DataType.UBYTE, value, func.position)
+            }
+            "sin8" -> {
+                val value = truncate(127.0  * sin(args.single().number / 256.0 * 2 * PI))
+                NumericLiteral(DataType.BYTE, value, func.position)
+            }
+            "cos8" -> {
+                val value = truncate(127.0  * cos(args.single().number / 256.0 * 2 * PI))
+                NumericLiteral(DataType.BYTE, value, func.position)
+            }
+            "sinr8u" -> {
+                val value = truncate(128.0 + 127.5 * sin(args.single().number / 180.0 * 2 * PI))
+                NumericLiteral(DataType.UBYTE, value, func.position)
+            }
+            "cosr8u" -> {
+                val value = truncate(128.0 + 127.5 * cos(args.single().number / 180.0 * 2 * PI))
+                NumericLiteral(DataType.UBYTE, value, func.position)
+            }
+            "sinr8" -> {
+                val value = truncate(127.0  * sin(args.single().number / 180.0 * 2 * PI))
+                NumericLiteral(DataType.BYTE, value, func.position)
+            }
+            "cosr8" -> {
+                val value = truncate(127.0  * cos(args.single().number / 180.0 * 2 * PI))
+                NumericLiteral(DataType.BYTE, value, func.position)
+            }
+            "log2" -> {
+                val value = truncate(log2(args.single().number))
+                NumericLiteral(DataType.UBYTE, value, func.position)
+            }
+            "log2w" -> {
+                val value = truncate(log2(args.single().number))
+                NumericLiteral(DataType.UWORD, value, func.position)
+            }
+            "atan2" -> {
+                val x1f = args[0].number
+                val y1f = args[1].number
+                val x2f = args[2].number
+                val y2f = args[3].number
+                var radians = atan2(y2f-y1f, x2f-x1f)
+                if(radians<0)
+                    radians+=2*PI
+                NumericLiteral(DataType.UWORD, floor(radians/2.0/PI*256.0), func.position)
+            }
+            "diff" -> {
+                val n1 = args[0].number
+                val n2 = args[1].number
+                val value = if(n1>n2) n1-n2 else n2-n1
+                NumericLiteral(DataType.UBYTE, value, func.position)
+            }
+            "diffw" -> {
+                val n1 = args[0].number
+                val n2 = args[1].number
+                val value = if(n1>n2) n1-n2 else n2-n1
+                NumericLiteral(DataType.UWORD, value, func.position)
+            }
+            else -> null
+        }
+    }
+
+    private fun evalString(func: FunctionCallExpression, args: List<NumericLiteral>): NumericLiteral? {
+        return when(func.target.nameInSource[1]) {
+            "isdigit" -> {
+                val char = args[0].number.toInt()
+                NumericLiteral.fromBoolean(char in 48..57, func.position)
+            }
+            "isupper" -> {
+                // shifted petscii has 2 ranges that contain the upper case letters... 97-122 and 193-218
+                val char = args[0].number.toInt()
+                NumericLiteral.fromBoolean(char in 97..122 || char in 193..218, func.position)
+            }
+            "islower" -> {
+                val char = args[0].number.toInt()
+                NumericLiteral.fromBoolean(char in 65..90, func.position)
+            }
+            "isletter" -> {
+                val char = args[0].number.toInt()
+                NumericLiteral.fromBoolean(char in 65..90 || char in 97..122 || char in 193..218, func.position)
+            }
+            "isspace" -> {
+                val char = args[0].number.toInt()
+                NumericLiteral.fromBoolean(char in arrayOf(32, 13, 9, 10, 141, 160), func.position)
+            }
+            "isprint" -> {
+                val char = args[0].number.toInt()
+                NumericLiteral.fromBoolean(char in 32..127 || char>=160, func.position)
+            }
+            else -> null
+        }
+    }
 }

codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -2,28 +2,37 @@ package prog8.optimizer
 
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.FatalAstException
-import prog8.ast.base.UndefinedSymbolError
 import prog8.ast.expressions.*
 import prog8.ast.maySwapOperandOrder
 import prog8.ast.statements.ForLoop
+import prog8.ast.statements.RepeatLoop
 import prog8.ast.statements.VarDecl
 import prog8.ast.statements.VarDeclType
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.AssociativeOperators
 import prog8.code.core.DataType
+import prog8.code.core.IErrorReporter
+import kotlin.math.floor
 
 
-class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
+class ConstantFoldingOptimizer(private val program: Program, private val errors: IErrorReporter) : AstWalker() {
+
+    private val evaluator = ConstExprEvaluator()
+
+    override fun after(addressOf: AddressOf, parent: Node): Iterable<IAstModification> {
+        val constAddr = addressOf.constValue(program) ?: return noModifications
+        return listOf(IAstModification.ReplaceNode(addressOf, constAddr, parent))
+    }
 
     override fun before(memread: DirectMemoryRead, parent: Node): Iterable<IAstModification> {
-        // @( &thing )  -->  thing
+        // @( &thing )  -->  thing  (but only if thing is a byte type!)
         val addrOf = memread.addressExpression as? AddressOf
-        return if(addrOf!=null)
-            listOf(IAstModification.ReplaceNode(memread, addrOf.identifier, parent))
-        else
-            noModifications
+        if(addrOf!=null) {
+            if(addrOf.identifier.inferType(program).isBytes)
+                return listOf(IAstModification.ReplaceNode(memread, addrOf.identifier, parent))
+        }
+        return noModifications
     }
 
     override fun after(containment: ContainmentCheck, parent: Node): Iterable<IAstModification> {
@@ -78,6 +87,8 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
             else if(expr.operator=="*" && rightconst!=null && expr.left is StringLiteral) {
                 // mutiply a string.
                 val part = expr.left as StringLiteral
+                if(part.value.isEmpty())
+                    errors.warn("resulting string has length zero", part.position)
                 val newStr = StringLiteral(part.value.repeat(rightconst.number.toInt()), part.encoding, expr.position)
                 return listOf(IAstModification.ReplaceNode(expr, newStr, parent))
             }
@@ -85,7 +96,8 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
 
         if(expr.operator=="==" && rightconst!=null) {
             val leftExpr = expr.left as? BinaryExpression
-            if(leftExpr!=null) {
+            // only do this shuffling when the LHS is not a constant itself (otherwise problematic nested replacements)
+            if(leftExpr?.constValue(program) != null) {
                 val leftRightConst = leftExpr.right.constValue(program)
                 if(leftRightConst!=null) {
                     when (leftExpr.operator) {
@@ -132,9 +144,8 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
             }
         }
 
-        val evaluator = ConstExprEvaluator()
-
-        // const fold when both operands are a const
+        // const fold when both operands are a const.
+        // if in a chained comparison, that one has to be desugared first though.
         if(leftconst != null && rightconst != null) {
             val result = evaluator.evaluate(leftconst, expr.operator, rightconst)
             modifications += IAstModification.ReplaceNode(expr, result, parent)
@@ -182,18 +193,20 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                         val newExpr = BinaryExpression(leftBinExpr.left, "*", constants, expr.position)
                         return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
                     } else if (leftBinExpr.operator=="/") {
-                        //  (X / C2) * rightConst   -->  X * (rightConst/C2)
+                        if(expr.inferType(program).istype(DataType.FLOAT)) {
+                            //  (X / C2) * rightConst   -->  X * (rightConst/C2)    only valid for floating point
                             val constants = BinaryExpression(rightconst, "/", c2, c2.position)
                             val newExpr = BinaryExpression(leftBinExpr.left, "*", constants, expr.position)
                             return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
                         }
                     }
                 }
+            }
             else if(expr.operator=="/") {
                 val c2 = leftBinExpr.right.constValue(program)
                 if(c2!=null && leftBinExpr.operator=="/") {
                     // (X / C1) / C2   -->  X / (C1*C2)
-                    // NOTE: do not optimize  (X * C1) / C2   -->  X * (C1/C2)  because this causes precision loss on integers
+                    // NOTE: do not optimize  (X * C1) / C2  for integers,  -->  X * (C1/C2)  because this causes precision loss on integers
                     val constants = BinaryExpression(c2, "*", rightconst, c2.position)
                     val newExpr = BinaryExpression(leftBinExpr.left, "/", constants, expr.position)
                     return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
@@ -225,7 +238,10 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                 }
                 else if(leftBinExpr.operator=="*" && rightBinExpr.operator=="*"){
                     if (c1 != null && c2 != null && c1==c2) {
-                        //(X * C) <plusmin> (Y * C)  =>  (X <plusmin> Y) * C
+                        //(X * C) <plusmin> (Y * C)  =>  (X <plusmin> Y) * C    (only if types of X and Y are the same!)
+                        val xDt = leftBinExpr.left.inferType(program)
+                        val yDt = rightBinExpr.left.inferType(program)
+                        if(xDt==yDt) {
                             val xwithy = BinaryExpression(leftBinExpr.left, expr.operator, rightBinExpr.left, expr.position)
                             val newExpr = BinaryExpression(xwithy, "*", c1, expr.position)
                             modifications += IAstModification.ReplaceNode(expr, newExpr, parent)
@@ -233,7 +249,49 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                     }
                 }
             }
+        }
 
+        if(rightconst!=null && (expr.operator=="<<" || expr.operator==">>")) {
+            val dt = expr.left.inferType(program)
+            if(dt.isBytes && rightconst.number>=8) {
+                if(dt.istype(DataType.UBYTE)) {
+                    val zeroUB = NumericLiteral(DataType.UBYTE, 0.0, expr.position)
+                    modifications.add(IAstModification.ReplaceNode(expr, zeroUB, parent))
+                } else {
+                    if(leftconst!=null) {
+                        val zeroB = NumericLiteral(DataType.BYTE, 0.0, expr.position)
+                        val minusoneB = NumericLiteral(DataType.BYTE, -1.0, expr.position)
+                        if(leftconst.number<0.0) {
+                            if(expr.operator=="<<")
+                                modifications.add(IAstModification.ReplaceNode(expr, zeroB, parent))
+                            else
+                                modifications.add(IAstModification.ReplaceNode(expr, minusoneB, parent))
+                        } else {
+                            modifications.add(IAstModification.ReplaceNode(expr, zeroB, parent))
+                        }
+                    }
+                }
+            }
+            else if(dt.isWords && rightconst.number>=16) {
+                if(dt.istype(DataType.UWORD)) {
+                    val zeroUW = NumericLiteral(DataType.UWORD, 0.0, expr.position)
+                    modifications.add(IAstModification.ReplaceNode(expr, zeroUW, parent))
+                } else {
+                    if(leftconst!=null) {
+                        val zeroW = NumericLiteral(DataType.WORD, 0.0, expr.position)
+                        val minusoneW = NumericLiteral(DataType.WORD, -1.0, expr.position)
+                        if(leftconst.number<0.0) {
+                            if(expr.operator=="<<")
+                                modifications.add(IAstModification.ReplaceNode(expr, zeroW, parent))
+                            else
+                                modifications.add(IAstModification.ReplaceNode(expr, minusoneW, parent))
+                        } else {
+                            modifications.add(IAstModification.ReplaceNode(expr, zeroW, parent))
+                        }
+                    }
+                }
+            }
+        }
 
         return modifications
     }
@@ -268,9 +326,14 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
         val constvalue = functionCallExpr.constValue(program)
         return if(constvalue!=null)
             listOf(IAstModification.ReplaceNode(functionCallExpr, constvalue, parent))
+        else {
+            val const2 = evaluator.evaluate(functionCallExpr, program)
+            return if(const2!=null)
+                listOf(IAstModification.ReplaceNode(functionCallExpr, const2, parent))
             else
                 noModifications
         }
+    }
 
     override fun after(bfc: BuiltinFunctionCall, parent: Node): Iterable<IAstModification> {
         val constvalue = bfc.constValue(program)
@@ -307,7 +370,7 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
         val rangeTo = iterableRange.to as? NumericLiteral
         if(rangeFrom==null || rangeTo==null) return noModifications
 
-        val loopvar = forLoop.loopVar.targetVarDecl(program) ?: throw UndefinedSymbolError(forLoop.loopVar)
+        val loopvar = forLoop.loopVar.targetVarDecl(program) ?: return noModifications
 
         val stepLiteral = iterableRange.step as? NumericLiteral
         when(loopvar.datatype) {
@@ -343,7 +406,7 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                         return listOf(IAstModification.ReplaceNode(forLoop.iterable, newIter, forLoop))
                 }
             }
-            else -> throw FatalAstException("invalid loopvar datatype $loopvar")
+            else -> { /* nothing for floats, these are not allowed in for loops and will give an error elsewhere */ }
         }
 
         return noModifications
@@ -364,6 +427,21 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
         return noModifications
     }
 
+    override fun after(repeatLoop: RepeatLoop, parent: Node): Iterable<IAstModification> {
+        val count = (repeatLoop.iterations as? NumericLiteral)?.number
+        if(count!=null && floor(count)!=count) {
+            val integer = NumericLiteral.optimalInteger(count.toInt(), repeatLoop.position)
+            repeatLoop.iterations = integer
+            integer.linkParents(repeatLoop)
+        }
+        return noModifications
+    }
+
+    override fun after(typecast: TypecastExpression, parent: Node): Iterable<IAstModification> {
+        val constValue = typecast.constValue(program) ?: return noModifications
+        return listOf(IAstModification.ReplaceNode(typecast, constValue, parent))
+    }
+
     private class ShuffleOperands(val expr: BinaryExpression,
                                   val exprOperator: String?,
                                   val subExpr: BinaryExpression,
@@ -473,7 +551,8 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
                     return IAstModification.ReplaceNode(expr, change, expr.parent)
                 }
             }
-            else if(expr.operator=="*" && subExpr.operator=="/") {
+            else if(expr.operator=="*" && subExpr.operator=="/" && subExpr.inferType(program).istype(DataType.FLOAT)) {
+                // division optimizations only valid for floats
                 if(leftIsConst) {
                     val change = if(subleftIsConst) {
                         // C1*(C2/V) -> (C1*C2)/V
@@ -576,5 +655,4 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
             return null
         }
     }
-
 }

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -1,5 +1,7 @@
 package prog8.optimizer
 
+import prog8.ast.IFunctionCall
+import prog8.ast.IStatementContainer
 import prog8.ast.Node
 import prog8.ast.Program
 import prog8.ast.base.FatalAstException
@@ -9,10 +11,17 @@ import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.*
+import prog8.compiler.CallGraph
 
 // Fix up the literal value's type to match that of the vardecl
 //   (also check range literal operands types before they get expanded into arrays for instance)
-class VarConstantValueTypeAdjuster(private val program: Program, private val errors: IErrorReporter) : AstWalker() {
+class VarConstantValueTypeAdjuster(
+    private val program: Program,
+    private val options: CompilationOptions,
+    private val errors: IErrorReporter
+) : AstWalker() {
+
+    private val callGraph by lazy { CallGraph(program) }
 
     override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
 
@@ -25,9 +34,10 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err
                 && declConstValue.type != decl.datatype) {
                 // avoid silent float roundings
                 if(decl.datatype in IntegerDatatypes && declConstValue.type == DataType.FLOAT) {
-                    errors.err("refused rounding of float to avoid loss of precision", decl.value!!.position)
+                    errors.err("refused truncating of float to avoid loss of precision", decl.value!!.position)
                 } else {
                     // cast the numeric literal to the appropriate datatype of the variable
+                    declConstValue.linkParents(decl)
                     val cast = declConstValue.cast(decl.datatype)
                     if (cast.isValid)
                         return listOf(IAstModification.ReplaceNode(decl.value!!, cast.valueOrZero(), decl))
@@ -37,6 +47,73 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err
             errors.err(x.message, x.position)
         }
 
+        // replace variables by constants, if possible
+        if(options.optimize) {
+            if (decl.sharedWithAsm || decl.type != VarDeclType.VAR || decl.origin != VarDeclOrigin.USERCODE || decl.datatype !in NumericDatatypes)
+                return noModifications
+            if (decl.value != null && decl.value!!.constValue(program) == null)
+                return noModifications
+            val usages = callGraph.usages(decl)
+            val (writes, reads) = usages
+                .partition {
+                    it is InlineAssembly  // can't really tell if it's written to or only read, assume the worst
+                            || it.parent is AssignTarget
+                            || it.parent is ForLoop
+                            || it.parent is AddressOf
+                            || (it.parent as? IFunctionCall)?.target?.nameInSource?.singleOrNull() in InplaceModifyingBuiltinFunctions
+                }
+            val singleAssignment =
+                writes.singleOrNull()?.parent?.parent as? Assignment ?: writes.singleOrNull()?.parent as? Assignment
+            if (singleAssignment == null) {
+                if (writes.isEmpty()) {
+                    if(reads.isEmpty()) {
+                        // variable is never used AT ALL so we just remove it altogether
+                        if("ignore_unused" !in decl.definingBlock.options())
+                            errors.info("removing unused variable '${decl.name}'", decl.position)
+                        return listOf(IAstModification.Remove(decl, parent as IStatementContainer))
+                    }
+                    val declValue = decl.value?.constValue(program)
+                    if (declValue != null) {
+                        // variable is never written to, so it can be replaced with a constant, IF the value is a constant
+                        errors.info("variable is never written to and was replaced by a constant", decl.position)
+                        val const = VarDecl(VarDeclType.CONST, decl.origin, decl.datatype, decl.zeropage, decl.arraysize, decl.name, decl.names, declValue, decl.sharedWithAsm, decl.splitArray, decl.position)
+                        return listOf(
+                            IAstModification.ReplaceNode(decl, const, parent),
+                        )
+                    }
+                }
+            } else {
+                if (singleAssignment.origin == AssignmentOrigin.VARINIT && singleAssignment.value.constValue(program) != null) {
+                    if(reads.isEmpty()) {
+                        // variable is never used AT ALL so we just remove it altogether, including the single assignment
+                        if("ignore_unused" !in decl.definingBlock.options())
+                            errors.info("removing unused variable '${decl.name}'", decl.position)
+                        return listOf(
+                            IAstModification.Remove(decl, parent as IStatementContainer),
+                            IAstModification.Remove(singleAssignment, singleAssignment.parent as IStatementContainer)
+                        )
+                    }
+                    // variable only has a single write and it is the initialization value, so it can be replaced with a constant, IF the value is a constant
+                    errors.info("variable is never written to and was replaced by a constant", decl.position)
+                    val const = VarDecl(VarDeclType.CONST, decl.origin, decl.datatype, decl.zeropage, decl.arraysize, decl.name, decl.names, singleAssignment.value, decl.sharedWithAsm, decl.splitArray, decl.position)
+                    return listOf(
+                        IAstModification.ReplaceNode(decl, const, parent),
+                        IAstModification.Remove(singleAssignment, singleAssignment.parent as IStatementContainer)
+                    )
+                }
+            }
+            /*
+        TODO: need to check if there are no variable usages between the declaration and the assignment (because these rely on the original initialization value)
+        if(writes.size==2) {
+            val firstAssignment = writes[0].parent as? Assignment
+            val secondAssignment = writes[1].parent as? Assignment
+            if(firstAssignment?.origin==AssignmentOrigin.VARINIT && secondAssignment?.value?.constValue(program)!=null) {
+                errors.warn("variable is only assigned once here, consider using this as the initialization value in the declaration instead", secondAssignment.position)
+            }
+        }
+        */
+        }
+
         return noModifications
     }
 
@@ -53,7 +130,8 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err
         }
 
         if(to==null) {
-            if(!range.to.inferType(program).isInteger)
+            val toType = range.to.inferType(program)
+            if(toType.isKnown && !range.to.inferType(program).isInteger)
                 errors.err("range expression to value must be integer", range.to.position)
         } else if(to-to.toInt()>0) {
             errors.err("range expression to value must be integer", range.to.position)
@@ -68,6 +146,124 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err
 
         return noModifications
     }
+
+    override fun after(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
+        // choose specific builtin function for the given types
+        val func = functionCallExpr.target.nameInSource
+        if(func==listOf("clamp")) {
+            val t1 = functionCallExpr.args[0].inferType(program)
+            if(t1.isKnown) {
+                val replaceFunc: String
+                if(t1.isBytes) {
+                    replaceFunc = if(t1.istype(DataType.BYTE)) "clamp__byte" else "clamp__ubyte"
+                } else if(t1.isInteger) {
+                    replaceFunc = if(t1.istype(DataType.WORD)) "clamp__word" else "clamp__uword"
+                } else {
+                    errors.err("clamp builtin not supported for floats, use floats.clamp", functionCallExpr.position)
+                    return noModifications
+                }
+                return listOf(IAstModification.SetExpression({functionCallExpr.target = it as IdentifierReference},
+                    IdentifierReference(listOf(replaceFunc), functionCallExpr.target.position),
+                    functionCallExpr))
+            }
+        }
+        else if(func==listOf("min") || func==listOf("max")) {
+            val t1 = functionCallExpr.args[0].inferType(program)
+            val t2 = functionCallExpr.args[1].inferType(program)
+            if(t1.isKnown && t2.isKnown) {
+                val funcName = func[0]
+                val replaceFunc: String
+                if(t1.isBytes && t2.isBytes) {
+                    replaceFunc = if(t1.istype(DataType.BYTE) || t2.istype(DataType.BYTE))
+                        "${funcName}__byte"
+                    else
+                        "${funcName}__ubyte"
+                } else if(t1.isInteger && t2.isInteger) {
+                    replaceFunc = if(t1.istype(DataType.WORD) || t2.istype(DataType.WORD))
+                        "${funcName}__word"
+                    else
+                        "${funcName}__uword"
+                } else if(t1.isNumeric && t2.isNumeric) {
+                    errors.err("min/max not supported for floats", functionCallExpr.position)
+                    return noModifications
+                } else {
+                    errors.err("expected numeric arguments", functionCallExpr.args[0].position)
+                    return noModifications
+                }
+                return listOf(IAstModification.SetExpression({functionCallExpr.target = it as IdentifierReference},
+                    IdentifierReference(listOf(replaceFunc), functionCallExpr.target.position),
+                    functionCallExpr))
+            }
+        }
+        else if(func==listOf("abs")) {
+            val t1 = functionCallExpr.args[0].inferType(program)
+            if(t1.isKnown) {
+                val dt = t1.getOrElse { throw InternalCompilerException("invalid dt") }
+                val replaceFunc = when(dt) {
+                    DataType.BYTE -> "abs__byte"
+                    DataType.WORD -> "abs__word"
+                    DataType.FLOAT -> "abs__float"
+                    DataType.UBYTE, DataType.UWORD -> {
+                        return listOf(IAstModification.ReplaceNode(functionCallExpr, functionCallExpr.args[0], parent))
+                    }
+                    else -> {
+                        errors.err("expected numeric argument", functionCallExpr.args[0].position)
+                        return noModifications
+                    }
+                }
+                return listOf(IAstModification.SetExpression({functionCallExpr.target = it as IdentifierReference},
+                    IdentifierReference(listOf(replaceFunc), functionCallExpr.target.position),
+                    functionCallExpr))
+            }
+        }
+        else if(func==listOf("sqrt")) {
+            val t1 = functionCallExpr.args[0].inferType(program)
+            if(t1.isKnown) {
+                val dt = t1.getOrElse { throw InternalCompilerException("invalid dt") }
+                val replaceFunc = when(dt) {
+                    DataType.UBYTE -> "sqrt__ubyte"
+                    DataType.UWORD -> "sqrt__uword"
+                    DataType.FLOAT -> "sqrt__float"
+                    else -> {
+                        errors.err("expected unsigned or float numeric argument", functionCallExpr.args[0].position)
+                        return noModifications
+                    }
+                }
+                return listOf(IAstModification.SetExpression({functionCallExpr.target = it as IdentifierReference},
+                    IdentifierReference(listOf(replaceFunc), functionCallExpr.target.position),
+                    functionCallExpr))
+            }
+        }
+        return noModifications
+    }
+
+    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
+        // choose specific builtin function for the given types
+        val func = functionCallStatement.target.nameInSource
+        if(func==listOf("divmod")) {
+            val argTypes = functionCallStatement.args.map {it.inferType(program)}.toSet()
+            if(argTypes.size!=1) {
+                errors.err("expected all ubyte or all uword arguments", functionCallStatement.args[0].position)
+                return noModifications
+            }
+            val t1 = argTypes.single()
+            if(t1.isKnown) {
+                val dt = t1.getOrElse { throw InternalCompilerException("invalid dt") }
+                val replaceFunc = when(dt) {
+                    DataType.UBYTE -> "divmod__ubyte"
+                    DataType.UWORD -> "divmod__uword"
+                    else -> {
+                        errors.err("expected all ubyte or all uword arguments", functionCallStatement.args[0].position)
+                        return noModifications
+                    }
+                }
+                return listOf(IAstModification.SetExpression({functionCallStatement.target = it as IdentifierReference},
+                    IdentifierReference(listOf(replaceFunc), functionCallStatement.target.position),
+                    functionCallStatement))
+            }
+        }
+        return noModifications
+    }
 }
 
 
@@ -76,6 +272,14 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err
 // This is needed because further constant optimizations depend on those.
 internal class ConstantIdentifierReplacer(private val program: Program, private val errors: IErrorReporter, private val compTarget: ICompilationTarget) : AstWalker() {
 
+    override fun before(addressOf: AddressOf, parent: Node): Iterable<IAstModification> {
+        val constValue = addressOf.constValue(program)
+        if(constValue!=null) {
+            return listOf(IAstModification.ReplaceNode(addressOf, constValue, parent))
+        }
+        return noModifications
+    }
+
     override fun after(identifier: IdentifierReference, parent: Node): Iterable<IAstModification> {
         // replace identifiers that refer to const value, with the value itself
         // if it's a simple type and if it's not a left hand side variable
@@ -108,16 +312,20 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                     listOf(IAstModification.ReplaceNode(arrayIdx, memread, arrayIdx.parent))
                 }
             }
-            return when (cval.type) {
-                in NumericDatatypes -> listOf(
+            when (cval.type) {
+                in NumericDatatypes -> {
+                    if(parent is AddressOf)
+                        return noModifications      // cannot replace the identifier INSIDE the addr-of here, let's do it later.
+                    return listOf(
                         IAstModification.ReplaceNode(
                             identifier,
                             NumericLiteral(cval.type, cval.number, identifier.position),
                             identifier.parent
                         )
                     )
+                }
                 in PassByReferenceDatatypes -> throw InternalCompilerException("pass-by-reference type should not be considered a constant")
-                else -> noModifications
+                else -> return noModifications
             }
         } catch (x: UndefinedSymbolError) {
             errors.err(x.message, x.position)
@@ -125,14 +333,23 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
         }
     }
 
-    override fun before(decl: VarDecl, parent: Node): Iterable<IAstModification> {
+    override fun after(decl: VarDecl, parent: Node): Iterable<IAstModification> {
         // the initializer value can't refer to the variable itself (recursive definition)
         if(decl.value?.referencesIdentifier(listOf(decl.name)) == true || decl.arraysize?.indexExpr?.referencesIdentifier(listOf(decl.name)) == true) {
             errors.err("recursive var declaration", decl.position)
             return noModifications
         }
 
-        if(decl.type== VarDeclType.CONST || decl.type== VarDeclType.VAR) {
+        if(decl.isArray && decl.type==VarDeclType.MEMORY && decl.value !is IdentifierReference) {
+            val memaddr = decl.value?.constValue(program)
+            if(memaddr!=null && memaddr !== decl.value) {
+                return listOf(IAstModification.SetExpression(
+                    { decl.value = it }, memaddr, decl
+                ))
+            }
+        }
+
+        if(decl.type==VarDeclType.CONST || decl.type==VarDeclType.VAR) {
             if(decl.isArray){
                 val arraysize = decl.arraysize
                 if(arraysize==null) {
@@ -157,17 +374,43 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                         return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
                     }
                 }
-                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                in ArrayDatatypes -> {
+                    val replacedArrayInitializer = createConstArrayInitializerValue(decl)
+                    if(replacedArrayInitializer!=null)
+                        return listOf(IAstModification.ReplaceNode(decl.value!!, replacedArrayInitializer, decl))
+                }
+                else -> {
+                    // nothing to do for this type
+                }
+            }
+        }
+
+        return noModifications
+    }
+
+    private fun createConstArrayInitializerValue(decl: VarDecl): ArrayLiteral? {
+
+        if(decl.type==VarDeclType.MEMORY)
+            return null     // memory mapped arrays can never have an initializer value other than the address where they're mapped.
+
+        // convert the initializer range expression from a range or int, to an actual array.
+        when(decl.datatype) {
+            DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_W_SPLIT, DataType.ARRAY_UW_SPLIT -> {
                 val rangeExpr = decl.value as? RangeExpression
                 if(rangeExpr!=null) {
-                        // convert the initializer range expression to an actual array
+                    val constRange = rangeExpr.toConstantIntegerRange()
+                    if(constRange?.isEmpty()==true) {
+                        if(constRange.first>constRange.last && constRange.step>=0)
+                            errors.err("descending range with positive step", decl.value?.position!!)
+                        else if(constRange.first<constRange.last && constRange.step<=0)
+                            errors.err("ascending range with negative step", decl.value?.position!!)
+                    }
                     val declArraySize = decl.arraysize?.constIndex()
                     if(declArraySize!=null && declArraySize!=rangeExpr.size())
                         errors.err("range expression size (${rangeExpr.size()}) doesn't match declared array size ($declArraySize)", decl.value?.position!!)
-                        val constRange = rangeExpr.toConstantIntegerRange()
                     if(constRange!=null) {
                         val eltType = rangeExpr.inferType(program).getOr(DataType.UBYTE)
-                            val newValue = if(eltType in ByteDatatypes) {
+                        return if(eltType in ByteDatatypes) {
                             ArrayLiteral(InferredTypes.InferredType.known(decl.datatype),
                                 constRange.map { NumericLiteral(eltType, it.toDouble(), decl.value!!.position) }.toTypedArray(),
                                 position = decl.value!!.position)
@@ -176,13 +419,12 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                                 constRange.map { NumericLiteral(eltType, it.toDouble(), decl.value!!.position) }.toTypedArray(),
                                 position = decl.value!!.position)
                         }
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
                     }
                 }
                 val numericLv = decl.value as? NumericLiteral
                 if(numericLv!=null && numericLv.type== DataType.FLOAT)
                     errors.err("arraysize requires only integers here", numericLv.position)
-                    val size = decl.arraysize?.constIndex() ?: return noModifications
+                val size = decl.arraysize?.constIndex() ?: return null
                 if (rangeExpr==null && numericLv!=null) {
                     // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
                     val fillvalue = numericLv.number.toInt()
@@ -207,8 +449,7 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                     }
                     // create the array itself, filled with the fillvalue.
                     val array = Array(size) {fillvalue}.map { NumericLiteral(ArrayToElementTypes.getValue(decl.datatype), it.toDouble(), numericLv.position) }.toTypedArray<Expression>()
-                        val refValue = ArrayLiteral(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
-                        return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
+                    return ArrayLiteral(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
                 }
             }
             DataType.ARRAY_F -> {
@@ -220,15 +461,14 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                         errors.err("range expression size (${rangeExpr.size()}) doesn't match declared array size ($declArraySize)", decl.value?.position!!)
                     val constRange = rangeExpr.toConstantIntegerRange()
                     if(constRange!=null) {
-                            val newValue = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_F),
+                        return ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_F),
                             constRange.map { NumericLiteral(DataType.FLOAT, it.toDouble(), decl.value!!.position) }.toTypedArray(),
                             position = decl.value!!.position)
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, newValue, decl))
                     }
                 }
 
                 val numericLv = decl.value as? NumericLiteral
-                    val size = decl.arraysize?.constIndex() ?: return noModifications
+                val size = decl.arraysize?.constIndex() ?: return null
                 if(rangeExpr==null && numericLv!=null) {
                     // arraysize initializer is a single int, and we know the size.
                     val fillvalue = numericLv.number
@@ -237,28 +477,22 @@ internal class ConstantIdentifierReplacer(private val program: Program, private
                     else {
                         // create the array itself, filled with the fillvalue.
                         val array = Array(size) {fillvalue}.map { NumericLiteral(DataType.FLOAT, it, numericLv.position) }.toTypedArray<Expression>()
-                            val refValue = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = numericLv.position)
-                            return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
+                        return ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = numericLv.position)
                     }
                 }
             }
             DataType.ARRAY_BOOL -> {
                 val numericLv = decl.value as? NumericLiteral
-                    val size = decl.arraysize?.constIndex() ?: return noModifications
+                val size = decl.arraysize?.constIndex() ?: return null
                 if(numericLv!=null) {
                     // arraysize initializer is a single int, and we know the size.
                     val fillvalue = if(numericLv.number==0.0) 0.0 else 1.0
                     val array = Array(size) {fillvalue}.map { NumericLiteral(DataType.UBYTE, fillvalue, numericLv.position) }.toTypedArray<Expression>()
-                        val refValue = ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_BOOL), array, position = numericLv.position)
-                        return listOf(IAstModification.ReplaceNode(decl.value!!, refValue, decl))
+                    return ArrayLiteral(InferredTypes.InferredType.known(DataType.ARRAY_BOOL), array, position = numericLv.position)
                 }
             }
-                else -> {
-                    // nothing to do for this type
+            else -> return null
         }
-            }
-        }
-
-        return noModifications
+        return null
     }
 }

codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -13,12 +13,11 @@ import prog8.ast.statements.Jump
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.*
-import prog8.code.target.VMTarget
 import kotlin.math.abs
 import kotlin.math.log2
 import kotlin.math.pow
 
-// TODO add more peephole expression optimizations? Investigate what optimizations binaryen has
+// TODO add more peephole expression optimizations? Investigate what optimizations binaryen has?
 
 class ExpressionSimplifier(private val program: Program,
                            private val errors: IErrorReporter,
@@ -66,8 +65,7 @@ class ExpressionSimplifier(private val program: Program,
                 )
             }
             if(elsepart.statements.singleOrNull() is Jump) {
-                val invertedCondition = invertCondition(ifElse.condition)
-                if(invertedCondition!=null) {
+                val invertedCondition = invertCondition(ifElse.condition, program)
                 return listOf(
                     IAstModification.ReplaceNode(ifElse.condition, invertedCondition, ifElse),
                     IAstModification.InsertAfter(ifElse, truepart, parent as IStatementContainer),
@@ -76,20 +74,27 @@ class ExpressionSimplifier(private val program: Program,
                 )
             }
         }
-        }
 
-        if(compTarget.name!=VMTarget.NAME) {
         val booleanCondition = ifElse.condition as? BinaryExpression
         if(booleanCondition!=null && booleanCondition.operator=="&") {
-                // special optimization of WORD & $ff00  ->  just and the msb of WORD with $ff
             val rightNum = booleanCondition.right as? NumericLiteral
-                if(rightNum!=null && rightNum.type==DataType.UWORD && (rightNum.number.toInt() and 0x00ff)==0) {
+            if (rightNum!=null && rightNum.type==DataType.UWORD) {
+                if ((rightNum.number.toInt() and 0x00ff) == 0) {
+                    // if WORD & $xx00  ->  if msb(WORD) & $xx
                     val msb = BuiltinFunctionCall(IdentifierReference(listOf("msb"), booleanCondition.left.position), mutableListOf(booleanCondition.left), booleanCondition.left.position)
                     val bytevalue = NumericLiteral(DataType.UBYTE, (rightNum.number.toInt() shr 8).toDouble(), booleanCondition.right.position)
                     return listOf(
                         IAstModification.ReplaceNode(booleanCondition.left, msb, booleanCondition),
                         IAstModification.ReplaceNode(booleanCondition.right, bytevalue, booleanCondition))
                 }
+                else if ((rightNum.number.toInt() and 0xff00) == 0) {
+                    // if WORD & $00ff  ->  if lsb(WORD) & $ff
+                    val lsb = BuiltinFunctionCall(IdentifierReference(listOf("lsb"), booleanCondition.left.position), mutableListOf(booleanCondition.left), booleanCondition.left.position)
+                    val bytevalue = NumericLiteral(DataType.UBYTE, rightNum.number, booleanCondition.right.position)
+                    return listOf(
+                        IAstModification.ReplaceNode(booleanCondition.left, lsb, booleanCondition),
+                        IAstModification.ReplaceNode(booleanCondition.right, bytevalue, booleanCondition))
+                }
             }
         }
 
@@ -97,6 +102,10 @@ class ExpressionSimplifier(private val program: Program,
     }
 
     override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+        val newExpr = applyAbsorptionLaws(expr)
+        if(newExpr!=null)
+            return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+
         val leftVal = expr.left.constValue(program)
         val rightVal = expr.right.constValue(program)
 
@@ -158,8 +167,8 @@ class ExpressionSimplifier(private val program: Program,
                     val y = determineY(x, leftBinExpr)
                     if (y != null) {
                         val yPlus1 = BinaryExpression(y, "+", NumericLiteral(leftDt, 1.0, y.position), y.position)
-                        val newExpr = BinaryExpression(x, "*", yPlus1, x.position)
-                        return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                        val replacement = BinaryExpression(x, "*", yPlus1, x.position)
+                        return listOf(IAstModification.ReplaceNode(expr, replacement, parent))
                     }
                 } else {
                     // Y*X - X  ->  X*(Y - 1)
@@ -168,8 +177,8 @@ class ExpressionSimplifier(private val program: Program,
                     val y = determineY(x, leftBinExpr)
                     if (y != null) {
                         val yMinus1 = BinaryExpression(y, "-", NumericLiteral(leftDt, 1.0, y.position), y.position)
-                        val newExpr = BinaryExpression(x, "*", yMinus1, x.position)
-                        return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                        val replacement = BinaryExpression(x, "*", yMinus1, x.position)
+                        return listOf(IAstModification.ReplaceNode(expr, replacement, parent))
                     }
                 }
             } else if (rightBinExpr?.operator == "*") {
@@ -180,8 +189,8 @@ class ExpressionSimplifier(private val program: Program,
                     val y = determineY(x, rightBinExpr)
                     if (y != null) {
                         val yPlus1 = BinaryExpression(y, "+", NumericLiteral.optimalInteger(1, y.position), y.position)
-                        val newExpr = BinaryExpression(x, "*", yPlus1, x.position)
-                        return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+                        val replacement = BinaryExpression(x, "*", yPlus1, x.position)
+                        return listOf(IAstModification.ReplaceNode(expr, replacement, parent))
                     }
                 }
             }
@@ -270,7 +279,7 @@ class ExpressionSimplifier(private val program: Program,
 
         // simplify when a term is constant and directly determines the outcome
         val constFalse = NumericLiteral.fromBoolean(false, expr.position)
-        val newExpr: Expression? = when (expr.operator) {
+        val newExpr2 = when (expr.operator) {
             "|" -> {
                 when {
                     leftVal?.number==0.0 -> expr.right
@@ -315,33 +324,102 @@ class ExpressionSimplifier(private val program: Program,
         }
 
         if(rightVal!=null && leftDt==DataType.BOOL) {
-            // see if we can replace comparison against true/1 with simpler comparison against zero
-            if (expr.operator == "==") {
-                if (rightVal.number == 1.0) {
-                    val zero = NumericLiteral(DataType.UBYTE, 0.0, expr.right.position)
-                    return listOf(
-                        IAstModification.SetExpression({expr.operator="!="}, expr, parent),
-                        IAstModification.ReplaceNode(expr.right, zero, expr)
-                    )
-                }
-            }
-            if (expr.operator == "!=") {
-                if (rightVal.number == 1.0) {
-                    val zero = NumericLiteral(DataType.UBYTE, 0.0, expr.right.position)
-                    return listOf(
-                        IAstModification.SetExpression({expr.operator="=="}, expr, parent),
-                        IAstModification.ReplaceNode(expr.right, zero, expr)
-                    )
+            // boolean compare against a number -> just keep the boolean, no compare
+            if(expr.operator=="==" || expr.operator=="!=") {
+                val test = if (expr.operator == "==") rightVal.asBooleanValue else !rightVal.asBooleanValue
+                return if (test) {
+                    listOf(IAstModification.ReplaceNode(expr, expr.left, parent))
+                } else {
+                    listOf(IAstModification.ReplaceNode(expr, invertCondition(expr.left, program), parent))
                 }
             }
         }
 
-        if(newExpr != null)
-            return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))
+        if(newExpr2 != null)
+            return listOf(IAstModification.ReplaceNode(expr, newExpr2, parent))
+
+        if (rightVal!=null && (expr.operator == "==" || expr.operator == "!=")) {
+            val bitwise = expr.left as? BinaryExpression
+            if(bitwise!=null && bitwise.operator=="&" && bitwise.inferType(program).isWords) {
+                val andNum = (bitwise.right as? NumericLiteral)?.number?.toInt()
+                if (andNum!=null) {
+                    if ((andNum and 0x00ff) == 0) {
+                        // (WORD & $xx00)==y  ->  (msb(WORD) & $xx)==y
+                        val msb = BuiltinFunctionCall(IdentifierReference(listOf("msb"), bitwise.left.position), mutableListOf(bitwise.left), bitwise.left.position)
+                        val bytevalue = NumericLiteral(DataType.UBYTE, (andNum shr 8).toDouble(), bitwise.right.position)
+                        val rightvalByte = NumericLiteral(DataType.UBYTE, (rightVal.number.toInt() shr 8).toDouble(), rightVal.position)
+                        return listOf(
+                            IAstModification.ReplaceNode(bitwise.left, msb, bitwise),
+                            IAstModification.ReplaceNode(bitwise.right, bytevalue, bitwise),
+                            IAstModification.ReplaceNode(expr.right, rightvalByte, expr)
+                        )
+                    }
+                    else if((andNum and 0xff00) == 0) {
+                        // (WORD & $00xx)==y  ->  (lsb(WORD) & $xx)==y
+                        val lsb = BuiltinFunctionCall(IdentifierReference(listOf("lsb"), bitwise.left.position), mutableListOf(bitwise.left), bitwise.left.position)
+                        val bytevalue = NumericLiteral(DataType.UBYTE, andNum.toDouble(), bitwise.right.position)
+                        val rightvalByte = NumericLiteral(DataType.UBYTE, (rightVal.number.toInt() and 255).toDouble(), rightVal.position)
+                        return listOf(
+                            IAstModification.ReplaceNode(bitwise.left, lsb, bitwise),
+                            IAstModification.ReplaceNode(bitwise.right, bytevalue, bitwise),
+                            IAstModification.ReplaceNode(expr.right, rightvalByte, expr)
+                        )
+                    }
+                }
+            }
+        }
 
         return noModifications
     }
 
+    override fun after(expr: PrefixExpression, parent: Node): Iterable<IAstModification> {
+        if(expr.operator=="not") {
+            // not  X <compare> Y  ->   X <invertedcompare> Y
+            val binExpr = expr.expression as? BinaryExpression
+            if(binExpr!=null) {
+                val invertedOperator = invertedComparisonOperator(binExpr.operator)
+                if(invertedOperator!=null) {
+                    val inverted = BinaryExpression(binExpr.left, invertedOperator, binExpr.right, binExpr.position)
+                    return listOf(IAstModification.ReplaceNode(expr, inverted, parent))
+                }
+            }
+        }
+        return noModifications
+    }
+
+
+    private fun applyAbsorptionLaws(expr: BinaryExpression): Expression? {
+        val rightB = expr.right as? BinaryExpression
+        if(rightB!=null) {
+            // absorption laws:  a or (a and b) --> a,  a and (a or b) --> a
+            if(expr.operator=="or" && rightB.operator=="and") {
+                if(expr.left isSameAs rightB.left || expr.left isSameAs rightB.right) {
+                    return expr.left
+                }
+            }
+            else if(expr.operator=="and" && rightB.operator=="or") {
+                if(expr.left isSameAs rightB.left || expr.left isSameAs rightB.right) {
+                    return expr.left
+                }
+            }
+        }
+        val leftB = expr.left as? BinaryExpression
+        if(leftB!=null) {
+            // absorption laws:  (a and b) or a --> a,  (a or b) and a --> a
+            if(expr.operator=="or" && leftB.operator=="and") {
+                if(expr.right isSameAs leftB.left || expr.left isSameAs leftB.right) {
+                    return expr.right
+                }
+            }
+            else if(expr.operator=="and" && leftB.operator=="or") {
+                if(expr.right isSameAs leftB.left || expr.right isSameAs leftB.right) {
+                    return expr.right
+                }
+            }
+        }
+        return null
+    }
+
     override fun after(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
         if(functionCallExpr.target.nameInSource == listOf("lsb")) {
             if(functionCallExpr.args.isEmpty())
@@ -349,10 +427,15 @@ class ExpressionSimplifier(private val program: Program,
             val arg = functionCallExpr.args[0]
             if(arg is TypecastExpression) {
                 val valueDt = arg.expression.inferType(program)
-                if (valueDt istype DataType.BYTE || valueDt istype DataType.UBYTE) {
-                    // useless lsb() of byte value that was typecasted to word
+                if (valueDt istype DataType.UBYTE) {
+                    // useless lsb() of ubyte value
                     return listOf(IAstModification.ReplaceNode(functionCallExpr, arg.expression, parent))
                 }
+                else if (valueDt istype DataType.BYTE) {
+                    // useless lsb() of byte value, but as lsb() returns unsigned, we have to cast now.
+                    val cast = TypecastExpression(arg.expression, DataType.UBYTE, true, arg.position)
+                    return listOf(IAstModification.ReplaceNode(functionCallExpr, cast, parent))
+                }
             } else {
                 if(arg is IdentifierReference && arg.nameInSource.size==2
                     && arg.nameInSource[0]=="cx16" && arg.nameInSource[1].uppercase() in RegisterOrPair.names) {
@@ -361,10 +444,15 @@ class ExpressionSimplifier(private val program: Program,
                     return listOf(IAstModification.ReplaceNode(functionCallExpr, highReg, parent))
                 }
                 val argDt = arg.inferType(program)
-                if (argDt istype DataType.BYTE || argDt istype DataType.UBYTE) {
+                if (argDt istype DataType.UBYTE) {
                     // useless lsb() of byte value
                     return listOf(IAstModification.ReplaceNode(functionCallExpr, arg, parent))
                 }
+                else if (argDt istype DataType.BYTE) {
+                    // useless lsb() of byte value, but as lsb() returns unsigned, we have to cast now.
+                    val cast = TypecastExpression(arg, DataType.UBYTE, true, arg.position)
+                    return listOf(IAstModification.ReplaceNode(functionCallExpr, cast, parent))
+                }
             }
         }
         else if(functionCallExpr.target.nameInSource == listOf("msb")) {
@@ -405,6 +493,14 @@ class ExpressionSimplifier(private val program: Program,
                 return listOf(IAstModification.ReplaceNode(functionCallExpr, cast, parent))
             }
         }
+        else if(functionCallExpr.target.nameInSource == listOf("string", "contains")) {
+            val target = (functionCallExpr.args[0] as? IdentifierReference)?.targetVarDecl(program)
+            if(target?.value is StringLiteral) {
+                errors.info("for actual strings, use a regular containment check instead: 'char in string'", functionCallExpr.position)
+                val contains = ContainmentCheck(functionCallExpr.args[1], functionCallExpr.args[0], functionCallExpr.position)
+                return listOf(IAstModification.ReplaceNode(functionCallExpr as Node, contains, parent))
+            }
+        }
 
         return noModifications
     }
@@ -540,10 +636,25 @@ class ExpressionSimplifier(private val program: Program,
                         return expr.left
                     }
                 }
+                256.0 -> {
+                    when(leftDt) {
+                        DataType.UBYTE -> return NumericLiteral(DataType.UBYTE, 0.0, expr.position)
+                        DataType.BYTE -> return null        // is either 0 or -1 we cannot tell here
+                        DataType.UWORD, DataType.WORD -> {
+                            // just use:  msb(value) as type
+                            val msb = BuiltinFunctionCall(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position)
+                            return if(leftDt==DataType.WORD)
+                                TypecastExpression(msb, DataType.BYTE, true, expr.position)
+                            else
+                                TypecastExpression(msb, DataType.UWORD, true, expr.position)
+                        }
+                        else -> return null
+                    }
+                }
                 in powersOfTwo -> {
                     if (leftDt==DataType.UBYTE || leftDt==DataType.UWORD) {
                         // Unsigned number divided by a power of two => shift right
-                        // Signed number can't simply be bitshifted in this case (due to rounding issues for negative values),
+                        // Signed number can't simply be bitshifted in this case (due to rounding issues for negative values),  TODO is this correct???
                         // so we leave that as is and let the code generator deal with it.
                         val numshifts = log2(cv).toInt()
                         return BinaryExpression(expr.left, ">>", NumericLiteral.optimalInteger(numshifts, expr.position), expr.position)
@@ -705,8 +816,8 @@ class ExpressionSimplifier(private val program: Program,
             }
             DataType.UWORD -> {
                 if (amount >= 16) {
-                    errors.warn("shift always results in 0", expr.position)
-                    return NumericLiteral.optimalInteger(0, expr.position)
+                    errors.err("useless to shift by more than 15 bits", expr.position)
+                    return null
                 }
                 else if(amount==8) {
                     // shift right by 8 bits is just a byte operation: msb(X) as uword
@@ -720,11 +831,21 @@ class ExpressionSimplifier(private val program: Program,
                 }
             }
             DataType.WORD -> {
-                // bit-shifting a signed value shouldn't be allowed by the compiler but here we go...
-                if (amount > 16) {
-                    expr.right = NumericLiteral.optimalInteger(16, expr.right.position)
+                if (amount >= 16) {
+                    errors.err("useless to shift by more than 15 bits", expr.position)
                     return null
                 }
+                else if(amount == 8) {
+                    // shift right by 8 bits is just a byte operation: msb(X) as byte  (will get converted to word later)
+                    val msb = FunctionCallExpression(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position)
+                    return TypecastExpression(msb, DataType.BYTE, true, expr.position)
+                }
+                else if(amount > 8) {
+                    // same as above but with residual shifts. Take care to do signed shift.
+                    val msb = FunctionCallExpression(IdentifierReference(listOf("msb"), expr.position), mutableListOf(expr.left), expr.position)
+                    val signed = TypecastExpression(msb, DataType.BYTE, true, expr.position)
+                    return BinaryExpression(signed, ">>", NumericLiteral.optimalInteger(amount - 8, expr.position), expr.position)
+                }
             }
             else -> {
             }

codeOptimizers/src/prog8/optimizer/Extensions.kt

@@ -7,13 +7,13 @@ import prog8.code.core.ICompilationTarget
 import prog8.code.core.IErrorReporter
 
 
-fun Program.constantFold(errors: IErrorReporter, compTarget: ICompilationTarget) {
-    val valuetypefixer = VarConstantValueTypeAdjuster(this, errors)
+fun Program.constantFold(errors: IErrorReporter, options: CompilationOptions) {
+    val valuetypefixer = VarConstantValueTypeAdjuster(this, options, errors)
     valuetypefixer.visit(this)
     if(errors.noErrors()) {
         valuetypefixer.applyModifications()
 
-        val replacer = ConstantIdentifierReplacer(this, errors, compTarget)
+        val replacer = ConstantIdentifierReplacer(this, errors, options.compTarget)
         replacer.visit(this)
         if (errors.noErrors()) {
             replacer.applyModifications()
@@ -22,7 +22,7 @@ fun Program.constantFold(errors: IErrorReporter, compTarget: ICompilationTarget)
             if(errors.noErrors()) {
                 valuetypefixer.applyModifications()
 
-                val optimizer = ConstantFoldingOptimizer(this)
+                val optimizer = ConstantFoldingOptimizer(this, errors)
                 optimizer.visit(this)
                 while (errors.noErrors() && optimizer.applyModifications() > 0) {
                     optimizer.visit(this)
@@ -43,9 +43,9 @@ fun Program.constantFold(errors: IErrorReporter, compTarget: ICompilationTarget)
 
 fun Program.optimizeStatements(errors: IErrorReporter,
                                functions: IBuiltinFunctions,
-                               compTarget: ICompilationTarget
+                               options: CompilationOptions
 ): Int {
-    val optimizer = StatementOptimizer(this, errors, functions, compTarget)
+    val optimizer = StatementOptimizer(this, errors, functions, options)
     optimizer.visit(this)
     val optimizationCount = optimizer.applyModifications()
 
@@ -54,8 +54,8 @@ fun Program.optimizeStatements(errors: IErrorReporter,
     return optimizationCount
 }
 
-fun Program.inlineSubroutines(): Int {
-    val inliner = Inliner(this)
+fun Program.inlineSubroutines(options: CompilationOptions): Int {
+    val inliner = Inliner(this, options)
     inliner.visit(this)
     return inliner.applyModifications()
 }
@@ -65,9 +65,3 @@ fun Program.simplifyExpressions(errors: IErrorReporter, target: ICompilationTarg
     opti.visit(this)
     return opti.applyModifications()
 }
-
-fun Program.splitBinaryExpressions(options: CompilationOptions) : Int {
-    val opti = BinExprSplitter(this, options)
-    opti.visit(this)
-    return opti.applyModifications()
-}

codeOptimizers/src/prog8/optimizer/Inliner.kt

@@ -8,7 +8,9 @@ import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.ast.walk.IAstVisitor
+import prog8.code.core.CompilationOptions
 import prog8.code.core.InternalCompilerException
+import prog8.code.target.VMTarget
 
 
 private  fun isEmptyReturn(stmt: Statement): Boolean = stmt is Return && stmt.value==null
@@ -16,7 +18,7 @@ private  fun isEmptyReturn(stmt: Statement): Boolean = stmt is Return && stmt.va
 
 // inliner potentially enables *ONE LINED* subroutines, wihtout to be inlined.
 
-class Inliner(val program: Program): AstWalker() {
+class Inliner(private val program: Program, private val options: CompilationOptions): AstWalker() {
 
     class DetermineInlineSubs(val program: Program): IAstVisitor {
         private val modifications = mutableListOf<IAstModification>()
@@ -32,50 +34,54 @@ class Inliner(val program: Program): AstWalker() {
                 val containsSubsOrVariables = subroutine.statements.any { it is VarDecl || it is Subroutine}
                 if(!containsSubsOrVariables) {
                     if(subroutine.statements.size==1 || (subroutine.statements.size==2 && isEmptyReturn(subroutine.statements[1]))) {
+                        if(subroutine !== program.entrypoint) {
                             // subroutine is possible candidate to be inlined
                             subroutine.inline =
-                            when(val stmt=subroutine.statements[0]) {
+                                when (val stmt = subroutine.statements[0]) {
                                     is Return -> {
-                                    if(stmt.value is NumericLiteral)
+                                        if (stmt.value is NumericLiteral)
                                             true
-                                    else if(stmt.value==null)
+                                        else if (stmt.value == null)
                                             true
                                         else if (stmt.value is IdentifierReference) {
                                             makeFullyScoped(stmt.value as IdentifierReference)
                                             true
-                                    } else if(stmt.value!! is IFunctionCall && (stmt.value as IFunctionCall).args.size<=1 && (stmt.value as IFunctionCall).args.all { it is NumericLiteral || it is IdentifierReference }) {
+                                        } else if (stmt.value!! is IFunctionCall && (stmt.value as IFunctionCall).args.size <= 1 && (stmt.value as IFunctionCall).args.all { it is NumericLiteral || it is IdentifierReference }) {
                                             when (stmt.value) {
                                                 is BuiltinFunctionCall -> {
                                                     makeFullyScoped(stmt.value as BuiltinFunctionCall)
                                                     true
                                                 }
+
                                                 is FunctionCallExpression -> {
                                                     makeFullyScoped(stmt.value as FunctionCallExpression)
                                                     true
                                                 }
+
                                                 else -> false
                                             }
                                         } else
                                             false
                                     }
+
                                     is Assignment -> {
-                                    if(stmt.value.isSimple) {
+                                        if (stmt.value.isSimple) {
                                             val targetInline =
-                                            if(stmt.target.identifier!=null) {
+                                                if (stmt.target.identifier != null) {
                                                     makeFullyScoped(stmt.target.identifier!!)
                                                     true
-                                            } else if(stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
-                                                if(stmt.target.memoryAddress?.addressExpression is IdentifierReference)
+                                                } else if (stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
+                                                    if (stmt.target.memoryAddress?.addressExpression is IdentifierReference)
                                                         makeFullyScoped(stmt.target.memoryAddress?.addressExpression as IdentifierReference)
                                                     true
                                                 } else
                                                     false
                                             val valueInline =
-                                            if(stmt.value is IdentifierReference) {
+                                                if (stmt.value is IdentifierReference) {
                                                     makeFullyScoped(stmt.value as IdentifierReference)
                                                     true
-                                            } else if((stmt.value as? DirectMemoryRead)?.addressExpression is NumericLiteral || (stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference) {
-                                                if((stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference)
+                                                } else if ((stmt.value as? DirectMemoryRead)?.addressExpression is NumericLiteral || (stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference) {
+                                                    if ((stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference)
                                                         makeFullyScoped((stmt.value as? DirectMemoryRead)?.addressExpression as IdentifierReference)
                                                     true
                                                 } else
@@ -84,35 +90,46 @@ class Inliner(val program: Program): AstWalker() {
                                         } else
                                             false
                                     }
+
                                     is BuiltinFunctionCallStatement -> {
-                                    val inline = stmt.args.size<=1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
-                                    if(inline)
+                                        val inline =
+                                            stmt.args.size <= 1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
+                                        if (inline)
                                             makeFullyScoped(stmt)
                                         inline
                                     }
+
                                     is FunctionCallStatement -> {
-                                    val inline = stmt.args.size<=1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
-                                    if(inline)
+                                        val inline =
+                                            stmt.args.size <= 1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
+                                        if (inline)
                                             makeFullyScoped(stmt)
                                         inline
                                     }
+
                                     is PostIncrDecr -> {
-                                    if(stmt.target.identifier!=null) {
+                                        if (stmt.target.identifier != null) {
                                             makeFullyScoped(stmt.target.identifier!!)
                                             true
-                                    }
-                                    else if(stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
-                                        if(stmt.target.memoryAddress?.addressExpression is IdentifierReference)
+                                        } else if (stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
+                                            if (stmt.target.memoryAddress?.addressExpression is IdentifierReference)
                                                 makeFullyScoped(stmt.target.memoryAddress?.addressExpression as IdentifierReference)
                                             true
                                         } else
                                             false
                                     }
+
                                     is Jump -> true
                                     else -> false
                                 }
                         }
                     }
+
+                    if(subroutine.inline && subroutine.statements.size>1) {
+                        require(subroutine.statements.size==2 && isEmptyReturn(subroutine.statements[1]))
+                        subroutine.statements.removeLast()      // get rid of the Return, to be able to inline the (single) statement preceding it.
+                    }
+                }
             }
             super.visit(subroutine)
         }
@@ -127,43 +144,52 @@ class Inliner(val program: Program): AstWalker() {
 
         private fun makeFullyScoped(call: BuiltinFunctionCallStatement) {
             val scopedArgs = makeScopedArgs(call.args)
+            if(scopedArgs.any()) {
                 val scopedCall = BuiltinFunctionCallStatement(call.target.copy(), scopedArgs.toMutableList(), call.position)
                 modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
             }
+        }
 
         private fun makeFullyScoped(call: FunctionCallStatement) {
             call.target.targetSubroutine(program)?.let { sub ->
                 val scopedName = IdentifierReference(sub.scopedName, call.target.position)
                 val scopedArgs = makeScopedArgs(call.args)
+                if(scopedArgs.any()) {
                     val scopedCall = FunctionCallStatement(scopedName, scopedArgs.toMutableList(), call.void, call.position)
                     modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
                 }
             }
+        }
 
         private fun makeFullyScoped(call: BuiltinFunctionCall) {
             call.target.targetSubroutine(program)?.let { sub ->
                 val scopedName = IdentifierReference(sub.scopedName, call.target.position)
                 val scopedArgs = makeScopedArgs(call.args)
+                if(scopedArgs.any()) {
                     val scopedCall = BuiltinFunctionCall(scopedName, scopedArgs.toMutableList(), call.position)
                     modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
                 }
             }
+        }
 
         private fun makeFullyScoped(call: FunctionCallExpression) {
             call.target.targetSubroutine(program)?.let { sub ->
                 val scopedName = IdentifierReference(sub.scopedName, call.target.position)
                 val scopedArgs = makeScopedArgs(call.args)
+                if(scopedArgs.any()) {
                     val scopedCall = FunctionCallExpression(scopedName, scopedArgs.toMutableList(), call.position)
                     modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
                 }
             }
+        }
 
         private fun makeScopedArgs(args: List<Expression>): List<Expression> {
             return args.map {
                 when (it) {
                     is NumericLiteral -> it.copy()
                     is IdentifierReference -> {
-                        val scoped = (it.targetStatement(program)!! as INamedStatement).scopedName
+                        val target = it.targetStatement(program) ?: return emptyList()
+                        val scoped = (target as INamedStatement).scopedName
                         IdentifierReference(scoped, it.position)
                     }
                     else -> throw InternalCompilerException("expected only number or identifier arg, otherwise too complex")
@@ -211,7 +237,7 @@ class Inliner(val program: Program): AstWalker() {
 
     override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification>  {
         val sub = functionCallStatement.target.targetStatement(program) as? Subroutine
-        return if(sub==null)
+        return if(sub==null || !canInline(sub, functionCallStatement))
             noModifications
         else
             possibleInlineFcallStmt(sub, functionCallStatement, parent)
@@ -219,7 +245,7 @@ class Inliner(val program: Program): AstWalker() {
 
     override fun before(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
         val sub = functionCallExpr.target.targetStatement(program) as? Subroutine
-        if(sub!=null && sub.inline && sub.parameters.isEmpty()) {
+        if(sub!=null && sub.inline && sub.parameters.isEmpty() && canInline(sub, functionCallExpr)) {
             require(sub.statements.size == 1 || (sub.statements.size == 2 && isEmptyReturn(sub.statements[1]))) {
                 "invalid inline sub at ${sub.position}"
             }
@@ -246,5 +272,17 @@ class Inliner(val program: Program): AstWalker() {
         return noModifications
     }
 
+    private fun canInline(sub: Subroutine, fcall: IFunctionCall): Boolean {
+        if(!sub.inline)
+            return false
+        if(options.compTarget.name!=VMTarget.NAME) {
+            val stmt = sub.statements.single()
+            if (stmt is IFunctionCall) {
+                val existing = (fcall as Node).definingScope.lookup(stmt.target.nameInSource.take(1))
+                return existing !is VarDecl
+            }
+        }
+        return true
+    }
 }
 

codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt

@@ -13,7 +13,7 @@ import kotlin.math.floor
 class StatementOptimizer(private val program: Program,
                          private val errors: IErrorReporter,
                          private val functions: IBuiltinFunctions,
-                         private val compTarget: ICompilationTarget
+                         private val options: CompilationOptions
 ) : AstWalker() {
 
     override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
@@ -30,7 +30,7 @@ class StatementOptimizer(private val program: Program,
         if(functionCallStatement.target.nameInSource==listOf("txt", "print")) {
             val arg = functionCallStatement.args.single()
             val stringVar: IdentifierReference? = if(arg is AddressOf) {
-                arg.identifier
+                if(arg.arrayIndex==null) arg.identifier else null
             } else {
                 arg as? IdentifierReference
             }
@@ -39,19 +39,15 @@ class StatementOptimizer(private val program: Program,
                 if(string!=null) {
                     val pos = functionCallStatement.position
                     if (string.value.length == 1) {
-                        val firstCharEncoded = compTarget.encodeString(string.value, string.encoding)[0]
+                        val firstCharEncoded = options.compTarget.encodeString(string.value, string.encoding)[0]
                         val chrout = FunctionCallStatement(
                             IdentifierReference(listOf("txt", "chrout"), pos),
                             mutableListOf(NumericLiteral(DataType.UBYTE, firstCharEncoded.toDouble(), pos)),
                             functionCallStatement.void, pos
                         )
-                        val stringDecl = string.parent as VarDecl
-                        return listOf(
-                            IAstModification.ReplaceNode(functionCallStatement, chrout, parent),
-                            IAstModification.Remove(stringDecl, stringDecl.parent as IStatementContainer)
-                        )
+                        return listOf(IAstModification.ReplaceNode(functionCallStatement, chrout, parent))
                     } else if (string.value.length == 2) {
-                        val firstTwoCharsEncoded = compTarget.encodeString(string.value.take(2), string.encoding)
+                        val firstTwoCharsEncoded = options.compTarget.encodeString(string.value.take(2), string.encoding)
                         val chrout1 = FunctionCallStatement(
                             IdentifierReference(listOf("txt", "chrout"), pos),
                             mutableListOf(NumericLiteral(DataType.UBYTE, firstTwoCharsEncoded[0].toDouble(), pos)),
@@ -62,11 +58,9 @@ class StatementOptimizer(private val program: Program,
                             mutableListOf(NumericLiteral(DataType.UBYTE, firstTwoCharsEncoded[1].toDouble(), pos)),
                             functionCallStatement.void, pos
                         )
-                        val stringDecl = string.parent as VarDecl
                         return listOf(
                             IAstModification.InsertBefore(functionCallStatement, chrout1, parent as IStatementContainer),
-                            IAstModification.ReplaceNode(functionCallStatement, chrout2, parent),
-                            IAstModification.Remove(stringDecl, stringDecl.parent as IStatementContainer)
+                            IAstModification.ReplaceNode(functionCallStatement, chrout2, parent)
                         )
                     }
                 }
@@ -77,6 +71,11 @@ class StatementOptimizer(private val program: Program,
     }
 
     override fun after(ifElse: IfElse, parent: Node): Iterable<IAstModification> {
+        val constvalue = ifElse.condition.constValue(program)
+        if(constvalue!=null) {
+            errors.warn("condition is always ${constvalue.asBooleanValue}", ifElse.condition.position)
+        }
+
         // remove empty if statements
         if(ifElse.truepart.isEmpty() && ifElse.elsepart.isEmpty())
             return listOf(IAstModification.Remove(ifElse, parent as IStatementContainer))
@@ -93,27 +92,45 @@ class StatementOptimizer(private val program: Program,
             )
         }
 
-        val constvalue = ifElse.condition.constValue(program)
         if(constvalue!=null) {
             return if(constvalue.asBooleanValue){
                 // always true -> keep only if-part
-                if(!ifElse.definingModule.isLibrary)
-                    errors.warn("condition is always true", ifElse.condition.position)
                 listOf(IAstModification.ReplaceNode(ifElse, ifElse.truepart, parent))
             } else {
                 // always false -> keep only else-part
-                if(!ifElse.definingModule.isLibrary)
-                    errors.warn("condition is always false", ifElse.condition.position)
                 listOf(IAstModification.ReplaceNode(ifElse, ifElse.elsepart, parent))
             }
         }
 
+        // remove obvious dangling elses (else after a return)
+        if(ifElse.elsepart.isNotEmpty() && ifElse.truepart.statements.singleOrNull() is Return) {
+            val elsePart = AnonymousScope(ifElse.elsepart.statements, ifElse.elsepart.position)
+            return listOf(
+                IAstModification.ReplaceNode(ifElse.elsepart, AnonymousScope(mutableListOf(), ifElse.elsepart.position), ifElse),
+                IAstModification.InsertAfter(ifElse, elsePart, parent as IStatementContainer)
+            )
+        }
+
+        // switch if/else around if the else is just a jump or branch
+        if(ifElse.elsepart.isNotEmpty() && ifElse.elsepart.statements.size==1) {
+            val jump = ifElse.elsepart.statements[0]
+            if(jump is Jump) {
+                val newTruePart = AnonymousScope(mutableListOf(jump), ifElse.elsepart.position)
+                val newElsePart = AnonymousScope(ifElse.truepart.statements, ifElse.truepart.position)
+                return listOf(
+                    IAstModification.ReplaceNode(ifElse.elsepart, newElsePart, ifElse),
+                    IAstModification.ReplaceNode(ifElse.truepart, newTruePart, ifElse),
+                    IAstModification.ReplaceNode(ifElse.condition, invertCondition(ifElse.condition, program), ifElse)
+                )
+            }
+        }
+
         return noModifications
     }
 
     override fun after(forLoop: ForLoop, parent: Node): Iterable<IAstModification> {
         if(forLoop.body.isEmpty()) {
-            errors.warn("removing empty for loop", forLoop.position)
+            errors.info("removing empty for loop", forLoop.position)
             return listOf(IAstModification.Remove(forLoop, parent as IStatementContainer))
         } else if(forLoop.body.statements.size==1) {
             val loopvar = forLoop.body.statements[0] as? VarDecl
@@ -141,7 +158,7 @@ class StatementOptimizer(private val program: Program,
                 val size = sv.value.length
                 if(size==1) {
                     // loop over string of length 1 -> just assign the single character
-                    val character = compTarget.encodeString(sv.value, sv.encoding)[0]
+                    val character = options.compTarget.encodeString(sv.value, sv.encoding)[0]
                     val byte = NumericLiteral(DataType.UBYTE, character.toDouble(), iterable.position)
                     val scope = AnonymousScope(mutableListOf(), forLoop.position)
                     scope.statements.add(Assignment(AssignTarget(forLoop.loopVar, null, null, forLoop.position), byte, AssignmentOrigin.OPTIMIZER, forLoop.position))
@@ -149,7 +166,7 @@ class StatementOptimizer(private val program: Program,
                     return listOf(IAstModification.ReplaceNode(forLoop, scope, parent))
                 }
             }
-            else if(iterable.datatype in ArrayDatatypes) {
+            else if(iterable.isArray) {
                 val size = iterable.arraysize!!.constIndex()
                 if(size==1) {
                     // loop over array of length 1 -> just assign the single value
@@ -166,13 +183,67 @@ 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))
+        val loopvarDt = forLoop.loopVarDt(program)
+        if(loopvarDt.istype(DataType.UWORD) || loopvarDt.istype(DataType.UBYTE)) {
+            if (range != null && range.from.constValue(program)?.number == 0.0 && range.step.constValue(program)?.number==1.0) {
+                val toBinExpr = range.to as? BinaryExpression
+                if(toBinExpr!=null && toBinExpr.operator=="-" && toBinExpr.right.constValue(program)?.number==1.0) {
+                    // FOR var IN 0 TO X-1 .... ---> var=0, DO {... , var++} UNTIL var==X
+                    val pos = forLoop.position
+                    val condition = BinaryExpression(forLoop.loopVar.copy(), "==", toBinExpr.left, pos)
+                    val incOne = PostIncrDecr(AssignTarget(forLoop.loopVar.copy(), null, null, pos), "++", pos)
+                    forLoop.body.statements.add(incOne)
+                    val replacement = AnonymousScope(mutableListOf(
+                        Assignment(AssignTarget(forLoop.loopVar.copy(), null, null, pos),
+                            NumericLiteral.optimalNumeric(0.0, pos),
+                            AssignmentOrigin.OPTIMIZER, pos),
+                        UntilLoop(forLoop.body, condition, pos)
+                    ), pos)
+                    return listOf(IAstModification.ReplaceNode(forLoop, replacement, parent))
+                }
+
+                if(options.compTarget.name!=VMTarget.NAME) {
+                    // this optimization is not effective for the VM target.
+                    val toConst = range.to.constValue(program)
+                    if (toConst == null) {
+                        // FOR var in 0 TO X ... --->  var=0, REPEAT { ... , IF var==X break , var++ }
+                        val pos = forLoop.position
+                        val incOne = PostIncrDecr(AssignTarget(forLoop.loopVar.copy(), null, null, pos), "++", pos)
+                        val breakCondition = IfElse(
+                            BinaryExpression(forLoop.loopVar, "==", range.to, pos),
+                            AnonymousScope(mutableListOf(Break(pos)), pos),
+                            AnonymousScope(mutableListOf(), pos),
+                            pos
+                        )
+                        forLoop.body.statements.add(breakCondition)
+                        forLoop.body.statements.add(incOne)
+                        val replacement = AnonymousScope(mutableListOf(
+                            Assignment(AssignTarget(forLoop.loopVar.copy(), null, null, pos),
+                                NumericLiteral.optimalNumeric(0.0, pos),
+                                AssignmentOrigin.OPTIMIZER, pos),
+                            RepeatLoop(null, forLoop.body, pos)
+                        ), pos)
+                        return listOf(IAstModification.ReplaceNode(forLoop, replacement, parent))
+                    }
+                }
+            }
+
+            if (range != null && range.to.constValue(program)?.number == 0.0 && range.step.constValue(program)?.number==-1.0) {
+                val fromExpr = range.from
+                if(fromExpr.constValue(program)==null) {
+                    // FOR X = something DOWNTO 0 {...} -->  X=something,  DO { ... , X-- } UNTIL X=255 (or 65535 if uword)
+                    val pos = forLoop.position
+                    val checkValue = NumericLiteral(loopvarDt.getOr(DataType.UNDEFINED), if(loopvarDt.istype(DataType.UBYTE)) 255.0 else 65535.0, pos)
+                    val condition = BinaryExpression(forLoop.loopVar.copy(), "==", checkValue, pos)
+                    val decOne = PostIncrDecr(AssignTarget(forLoop.loopVar.copy(), null, null, pos), "--", pos)
+                    forLoop.body.statements.add(decOne)
+                    val replacement = AnonymousScope(mutableListOf(
+                        Assignment(AssignTarget(forLoop.loopVar.copy(), null, null, pos),
+                            fromExpr, AssignmentOrigin.OPTIMIZER, pos),
+                        UntilLoop(forLoop.body, condition, pos)
+                    ), pos)
+                    return listOf(IAstModification.ReplaceNode(forLoop, replacement, parent))
+                }
             }
         }
 
@@ -215,7 +286,7 @@ class StatementOptimizer(private val program: Program,
         val iter = repeatLoop.iterations
         if(iter!=null) {
             if(repeatLoop.body.isEmpty()) {
-                errors.warn("empty loop removed", repeatLoop.position)
+                errors.info("empty loop removed", repeatLoop.position)
                 return listOf(IAstModification.Remove(repeatLoop, parent as IStatementContainer))
             }
             val iterations = iter.constValue(program)?.number?.toInt()
@@ -326,7 +397,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..3.0 && compTarget.name!=VMTarget.NAME) {
+                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..3.0 && options.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()) {
@@ -340,7 +411,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..3.0 && compTarget.name!=VMTarget.NAME) {
+                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..3.0 && options.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()) {
@@ -386,9 +457,74 @@ class StatementOptimizer(private val program: Program,
     }
 
     override fun before(unrollLoop: UnrollLoop, parent: Node): Iterable<IAstModification> {
-        return if(unrollLoop.iterations<1)
+        val iterations = unrollLoop.iterations.constValue(program)?.number?.toInt()
+        return if(iterations!=null && iterations<1)
             listOf(IAstModification.Remove(unrollLoop, parent as IStatementContainer))
         else
             noModifications
     }
+
+    override fun after(whenStmt: When, parent: Node): Iterable<IAstModification> {
+
+        fun replaceWithIf(condition: Expression, trueBlock: AnonymousScope, elseBlock: AnonymousScope?): List<IAstModification> {
+            val ifStmt = IfElse(condition, trueBlock, elseBlock ?: AnonymousScope(mutableListOf(), whenStmt.position), whenStmt.position)
+            errors.info("for boolean condition a normal if statement is preferred", whenStmt.position)
+            return listOf(IAstModification.ReplaceNode(whenStmt, ifStmt, parent))
+        }
+
+        if(whenStmt.condition.inferType(program).isBool) {
+            if(whenStmt.choices.all { it.values?.size==1 }) {
+                if (whenStmt.choices.all { it.values!!.single().constValue(program)!!.number in arrayOf(0.0, 1.0) }) {
+                    // it's a when statement on booleans that can just be replaced by an if or if-else.
+                    if (whenStmt.choices.size == 1) {
+                        return if(whenStmt.choices[0].values!![0].constValue(program)!!.number==1.0) {
+                            replaceWithIf(whenStmt.condition, whenStmt.choices[0].statements, null)
+                        } else {
+                            val notCondition = BinaryExpression(whenStmt.condition, "==", NumericLiteral(DataType.UBYTE, 0.0, whenStmt.condition.position), whenStmt.condition.position)
+                            replaceWithIf(notCondition, whenStmt.choices[0].statements, null)
+                        }
+                    } else if (whenStmt.choices.size == 2) {
+                        var trueBlock: AnonymousScope? = null
+                        var elseBlock: AnonymousScope? = null
+                        if(whenStmt.choices[0].values!![0].constValue(program)!!.number==1.0) {
+                            trueBlock = whenStmt.choices[0].statements
+                        } else {
+                            elseBlock = whenStmt.choices[0].statements
+                        }
+                        if(whenStmt.choices[1].values!![0].constValue(program)!!.number==1.0) {
+                            trueBlock = whenStmt.choices[1].statements
+                        } else {
+                            elseBlock = whenStmt.choices[1].statements
+                        }
+                        if(trueBlock!=null && elseBlock!=null) {
+                            return replaceWithIf(whenStmt.condition, trueBlock, elseBlock)
+                        }
+                    }
+                }
+            }
+        }
+
+        val constantValue = whenStmt.condition.constValue(program)?.number
+        if(constantValue!=null) {
+            // when condition is a constant
+            var matchingChoice: WhenChoice? = null
+            loop@ for(choice in whenStmt.choices) {
+                for(value in choice.values ?: emptyList()) {
+                    if(value.constValue(program)?.number == constantValue) {
+                        matchingChoice = choice
+                        break@loop
+                    }
+                }
+            }
+            if(matchingChoice==null)
+                matchingChoice = whenStmt.choices.singleOrNull { it.values==null }
+            if(matchingChoice!=null) {
+                // get rid of the whole when-statement and just leave the matching choice
+                return listOf(IAstModification.ReplaceNode(whenStmt, matchingChoice.statements, parent))
+            }
+        }
+
+        return noModifications
+    }
+
 }

codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -66,16 +66,18 @@ class UnusedCodeRemover(private val program: Program,
             if (block.containsNoCodeNorVars) {
                 if(block.name != internedStringsModuleName) {
                     if(!block.statements.any { it is Subroutine && it.hasBeenInlined })
-                        errors.warn("removing unused block '${block.name}'", block.position)
+                        errors.info("removing unused block '${block.name}'", block.position)
                 }
                 return listOf(IAstModification.Remove(block, parent as IStatementContainer))
             }
             if(callgraph.unused(block)) {
                 if(block.statements.any{ it !is VarDecl || it.type== VarDeclType.VAR}) {
                     if(!block.statements.any { it is Subroutine && it.hasBeenInlined })
-                        errors.warn("removing unused block '${block.name}'", block.position)
+                        errors.info("removing unused block '${block.name}'", block.position)
                 }
+                if(!block.statements.any { it is Subroutine && it.hasBeenInlined }) {
                     program.removeInternedStringsFromRemovedBlock(block)
+                }
                 return listOf(IAstModification.Remove(block, parent as IStatementContainer))
             }
         }
@@ -88,8 +90,8 @@ class UnusedCodeRemover(private val program: Program,
         if (subroutine !== program.entrypoint && !forceOutput && !subroutine.isAsmSubroutine) {
             if(callgraph.unused(subroutine)) {
                 if(subroutine.containsNoCodeNorVars) {
-                    if(!subroutine.definingModule.isLibrary)
-                        errors.warn("removing empty subroutine '${subroutine.name}'", subroutine.position)
+                    if("ignore_unused" !in subroutine.definingBlock.options())
+                        errors.info("removing empty subroutine '${subroutine.name}'", subroutine.position)
                     val removals = mutableListOf(IAstModification.Remove(subroutine, parent as IStatementContainer))
                     callgraph.calledBy[subroutine]?.let {
                         for(node in it)
@@ -97,8 +99,8 @@ class UnusedCodeRemover(private val program: Program,
                     }
                     return removals
                 }
-                if(!subroutine.definingModule.isLibrary && !subroutine.hasBeenInlined) {
-                    errors.warn("unused subroutine '${subroutine.name}'", subroutine.position)
+                if(!subroutine.hasBeenInlined && "ignore_unused" !in subroutine.definingBlock.options()) {
+                    errors.info("unused subroutine '${subroutine.name}'", subroutine.position)
                 }
                 if(!subroutine.inline) {
                     program.removeInternedStringsFromRemovedSubroutine(subroutine)
@@ -117,8 +119,8 @@ 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)
-                        errors.warn("removing unused variable '${decl.name}'", decl.position)
+                    if("ignore_unused" !in decl.definingBlock.options())
+                        errors.info("removing unused variable '${decl.name}'", decl.position)
                     return listOf(IAstModification.Remove(decl, parent as IStatementContainer))
                 }
                 else {
@@ -129,23 +131,30 @@ class UnusedCodeRemover(private val program: Program,
                             if(assignment!=null && assignment.origin==AssignmentOrigin.VARINIT) {
                                 if(assignment.value.isSimple) {
                                     // remove the vardecl
-                                    if(!decl.definingModule.isLibrary)
-                                        errors.warn("removing unused variable '${decl.name}'", decl.position)
+                                    if("ignore_unused" !in decl.definingBlock.options())
+                                        errors.info("removing unused variable '${decl.name}'", decl.position)
                                     return listOf(
                                         IAstModification.Remove(decl, parent as IStatementContainer),
                                         IAstModification.Remove(assignment, assignment.parent as IStatementContainer)
                                     )
                                 } else if(assignment.value is IFunctionCall) {
                                     // replace the unused variable's initializer function call by a void
-                                    errors.warn("replaced unused variable '${decl.name}' with void call, maybe this can be removed altogether", decl.position)
+                                    // but only if the vardecl immediately precedes it!
+                                    if(singleUse.parent.parent === parent) {
+                                        val declIndex = (parent as IStatementContainer).statements.indexOf(decl)
+                                        val singleUseIndex = (parent as IStatementContainer).statements.indexOf(singleUse.parent)
+                                        if(declIndex==singleUseIndex-1) {
+                                            errors.info("replaced unused variable '${decl.name}' with void call, maybe this can be removed altogether", decl.position)
                                             val fcall = assignment.value as IFunctionCall
                                             val voidCall = FunctionCallStatement(fcall.target, fcall.args, true, fcall.position)
                                             return listOf(
                                                 IAstModification.ReplaceNode(decl, voidCall, parent),
                                                 IAstModification.Remove(assignment, assignment.parent as IStatementContainer)
                                             )
+                                        }
+                                    }
                                 } else {
-                                    errors.warn("variable '${decl.name}' is unused but has non-trivial initialization assignment. Leaving this in but maybe it can be removed altogether", decl.position)
+                                    errors.info("variable '${decl.name}' is unused but has non-trivial initialization assignment. Leaving this in but maybe it can be removed altogether", decl.position)
                                 }
                             }
                         }

compiler/build.gradle

@@ -1,9 +1,10 @@
 plugins {
     id 'java'
     id 'application'
-    id "org.jetbrains.kotlin.jvm"
+    id 'org.jetbrains.kotlin.jvm'
     id 'com.github.johnrengelman.shadow' version '7.1.2'
-    id "io.kotest" version "0.3.9"
+    id 'io.kotest' version '0.3.9'
+    id 'com.peterabeles.gversion' version '1.10.2'
 }
 
 java {
@@ -24,8 +25,6 @@ compileTestKotlin {
     }
 }
 
-def prog8version = rootProject.file('compiler/res/version.txt').text.trim()
-
 dependencies {
     implementation project(':codeCore')
     implementation project(':codeOptimizers')
@@ -34,14 +33,14 @@ dependencies {
     implementation project(':codeGenIntermediate')
     implementation project(':codeGenExperimental')
     implementation project(':virtualmachine')
-    implementation "org.antlr:antlr4-runtime:4.12.0"
+    implementation "org.antlr:antlr4-runtime:4.13.1"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.5'
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
+    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.6'
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.18"
 
     testImplementation project(':intermediate')
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.5.5'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
 }
 
 configurations.all {
@@ -60,10 +59,10 @@ configurations {
 sourceSets {
     main {
         java {
-            srcDirs = ["${project.projectDir}/src"]
+            srcDir "${project.projectDir}/src"
         }
         resources {
-            srcDirs = ["${project.projectDir}/res"]
+            srcDir "${project.projectDir}/res"
         }
     }
     test {
@@ -82,7 +81,7 @@ application {
 
 shadowJar {
     archiveBaseName = 'prog8compiler'
-    archiveVersion = prog8version
+    archiveVersion = version
     // minimize()
 }
 
@@ -100,4 +99,16 @@ test {
     }
 }
 
+gversion {
+    srcDir       = "src/"           // path is relative to the sub-project by default
+    classPackage = "prog8.buildversion"
+    className    = "BuildVersion"
+    language     = "kotlin"
+}
+
+
 build.finalizedBy installDist, installShadowDist
+
+compileKotlin.dependsOn createVersionFile    // , failDirtyNotSnapshot
+compileJava.dependsOn createVersionFile
+

compiler/res/prog8lib/atari/syslib.p8

@@ -1,17 +1,29 @@
 ; Prog8 definitions for the Atari800XL
 ; Including memory registers, I/O registers, Basic and Kernal subroutines.
 
+%option no_symbol_prefixing, ignore_unused
+
 atari {
 
         &uword  NMI_VEC         = $FFFA     ; 6502 nmi vector, determined by the kernal if banked in
         &uword  RESET_VEC       = $FFFC     ; 6502 reset vector, determined by the kernal if banked in
         &uword  IRQ_VEC         = $FFFE     ; 6502 interrupt vector, determined by the kernal if banked in
 
-; ---- kernal routines ----
-; TODO
+        &uword COLCRS = 85
+        &ubyte ROWCRS = 84
 
+    romsub $F24A = getchar() -> ubyte @A
+    romsub $F2B0 = outchar(ubyte character @ A)
+    romsub $F2FD = waitkey() -> ubyte @A
 
-asmsub  init_system()  {
+}
+
+sys {
+    ; ------- lowlevel system routines --------
+
+    const ubyte target = 8         ;  compilation target specifier.  64 = C64, 128 = C128,  16 = CommanderX16, 8 = atari800XL
+
+    asmsub  init_system()  {
         ; Initializes the machine to a sane starting state.
         ; Called automatically by the loader program logic.
         ; TODO
@@ -24,22 +36,13 @@ asmsub  init_system()  {
             cli
             rts
         }}
-}
+    }
 
-asmsub  init_system_phase2()  {
+    asmsub  init_system_phase2()  {
         %asm {{
             rts     ; no phase 2 steps on the Atari
         }}
-}
-
-}
-
-
-sys {
-    ; ------- lowlevel system routines --------
-
-    const ubyte target = 8         ;  compilation target specifier.  64 = C64, 128 = C128,  16 = CommanderX16, 8 = atari800XL
-
+    }
 
     asmsub  reset_system()  {
         ; Soft-reset the system back to initial power-on Basic prompt.
@@ -188,9 +191,70 @@ _longcopy
         }}
     }
 
-    inline asmsub exit(ubyte returnvalue @A) {
+    inline asmsub irqsafe_set_irqd() {
+        %asm {{
+        php
+        sei
+        }}
+    }
+
+    inline asmsub irqsafe_clear_irqd() {
+        %asm {{
+        plp
+        }}
+    }
+
+    sub disable_caseswitch() {
+        ; no-op
+    }
+
+    sub enable_caseswitch() {
+        ; no-op
+    }
+
+    asmsub save_prog8_internals() {
+        %asm {{
+            lda  P8ZP_SCRATCH_B1
+            sta  save_SCRATCH_ZPB1
+            lda  P8ZP_SCRATCH_REG
+            sta  save_SCRATCH_ZPREG
+            lda  P8ZP_SCRATCH_W1
+            sta  save_SCRATCH_ZPWORD1
+            lda  P8ZP_SCRATCH_W1+1
+            sta  save_SCRATCH_ZPWORD1+1
+            lda  P8ZP_SCRATCH_W2
+            sta  save_SCRATCH_ZPWORD2
+            lda  P8ZP_SCRATCH_W2+1
+            sta  save_SCRATCH_ZPWORD2+1
+            rts
+save_SCRATCH_ZPB1	.byte  0
+save_SCRATCH_ZPREG	.byte  0
+save_SCRATCH_ZPWORD1	.word  0
+save_SCRATCH_ZPWORD2	.word  0
+        }}
+    }
+
+    asmsub restore_prog8_internals() {
+        %asm {{
+            lda  save_prog8_internals.save_SCRATCH_ZPB1
+            sta  P8ZP_SCRATCH_B1
+            lda  save_prog8_internals.save_SCRATCH_ZPREG
+            sta  P8ZP_SCRATCH_REG
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1
+            sta  P8ZP_SCRATCH_W1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD1+1
+            sta  P8ZP_SCRATCH_W1+1
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2
+            sta  P8ZP_SCRATCH_W2
+            lda  save_prog8_internals.save_SCRATCH_ZPWORD2+1
+            sta  P8ZP_SCRATCH_W2+1
+            rts
+        }}
+    }
+
+    asmsub exit(ubyte returnvalue @A) {
         ; -- immediately exit the program with a return code in the A register
-        ;    TODO
+        ;    TODO where to store A as exit code?
         %asm {{
             ldx  prog8_lib.orig_stackpointer
             txs
@@ -205,10 +269,37 @@ _longcopy
         }}
     }
 
+    inline asmsub push(ubyte value @A) {
+        %asm {{
+            pha
+        }}
+    }
+
+    inline asmsub pushw(uword value @AY) {
+        %asm {{
+            pha
+            tya
+            pha
+        }}
+    }
+
+    inline asmsub pop() -> ubyte @A {
+        %asm {{
+            pla
+        }}
+    }
+
+    inline asmsub popw() -> uword @AY {
+        %asm {{
+            pla
+            tay
+            pla
+        }}
+    }
+
 }
 
 cx16 {
-
     ; the sixteen virtual 16-bit registers that the CX16 has defined in the zeropage
     ; they are simulated on the Atari as well but their location in memory is different
     ; TODO
@@ -313,4 +404,36 @@ cx16 {
     &byte r13sH = $1b1b
     &byte r14sH = $1b1d
     &byte r15sH = $1b1f
+
+    asmsub save_virtual_registers() clobbers(A,Y) {
+        %asm {{
+            ldy  #31
+    -       lda  cx16.r0,y
+            sta  _cx16_vreg_storage,y
+            dey
+            bpl  -
+            rts
+
+    _cx16_vreg_storage
+            .word 0,0,0,0,0,0,0,0
+            .word 0,0,0,0,0,0,0,0
+        }}
+    }
+
+    asmsub restore_virtual_registers() clobbers(A,Y) {
+        %asm {{
+            ldy  #31
+    -       lda  save_virtual_registers._cx16_vreg_storage,y
+            sta  cx16.r0,y
+            dey
+            bpl  -
+            rts
+        }}
+    }
+
+    sub cpu_is_65816() -> bool {
+        ; Returns true when you have a 65816 cpu, false when it's a 6502.
+        return false
+    }
+
 }

compiler/res/prog8lib/atari/textio.p8

@@ -1,4 +1,5 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the Atari 800XL
+; Reference:  https://www.atariarchives.org/mapping/appendix12.php
 
 %import syslib
 %import conv
@@ -6,6 +7,8 @@
 
 txt {
 
+    %option no_symbol_prefixing, ignore_unused
+
 const ubyte DEFAULT_WIDTH = 40
 const ubyte DEFAULT_HEIGHT = 24
 
@@ -22,15 +25,25 @@ sub spc() {
     txt.chrout(' ')
 }
 
-asmsub column(ubyte col @A) clobbers(A, X, Y) {
+sub column(ubyte col) {
     ; ---- set the cursor on the given column (starting with 0) on the current line
-    ;      TODO
-    %asm {{
-        rts
-    }}
+    atari.COLCRS = col
 }
 
-asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
+sub get_column() -> ubyte {
+    return atari.COLCRS as ubyte
+}
+
+sub row(ubyte rownum) {
+    ; ---- set the cursor on the given row (starting with 0) on the current line
+    atari.ROWCRS = rownum
+}
+
+sub get_row() -> ubyte {
+    return atari.ROWCRS
+}
+
+asmsub  fill_screen (ubyte character @ A, ubyte color @ Y) clobbers(A)  {
     ; ---- fill the character screen with the given fill character and character color.
     ;      (assumes screen and color matrix are at their default addresses)
     ;      TODO
@@ -40,7 +53,7 @@ asmsub  fill_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
     }}
 }
 
-asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
+asmsub  clear_screenchars (ubyte character @ A) clobbers(Y)  {
 	; ---- clear the character screen with the given fill character (leaves colors)
 	;      (assumes screen matrix is at the default address)
 	; TODO
@@ -70,7 +83,7 @@ sub uppercase() {
     ; TODO
 }
 
-asmsub  scroll_left  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
+asmsub  scroll_left  (bool alsocolors @ Pc) clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -81,7 +94,7 @@ asmsub  scroll_left  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
         }}
 }
 
-asmsub  scroll_right  (ubyte alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_right  (bool alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -91,7 +104,7 @@ asmsub  scroll_right  (ubyte alsocolors @ Pc) clobbers(A)  {
         }}
 }
 
-asmsub  scroll_up  (ubyte alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_up  (bool alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -101,7 +114,7 @@ asmsub  scroll_up  (ubyte alsocolors @ Pc) clobbers(A)  {
         }}
 }
 
-asmsub  scroll_down  (ubyte alsocolors @ Pc) clobbers(A)  {
+asmsub  scroll_down  (bool alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -112,25 +125,20 @@ asmsub  scroll_down  (ubyte alsocolors @ Pc) clobbers(A)  {
 }
 
 
-romsub $F2B0 = outchar(ubyte char @ A)
-romsub $F2Fd = waitkey()
-
-asmsub chrout(ubyte char @ A) {
+asmsub chrout(ubyte character @ A) {
 	%asm {{
 		sta  _tmp_outchar+1
-		pha
 		txa
 		pha
 		tya
 		pha
 _tmp_outchar
 		lda  #0
-		jsr  outchar
+		jsr  atari.outchar
 		pla
 		tay
 		pla
 		tax
-		pla
 		rts
 	}}
 }
@@ -153,10 +161,9 @@ asmsub  print (str text @ AY) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 		pha
 		tya
@@ -164,16 +171,13 @@ asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 		pla
 		jsr  chrout
 		txa
-		jsr  chrout
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  chrout
 	}}
 }
 
-asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
+asmsub  print_ub  (ubyte value @ A) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		jsr  conv.ubyte2decimal
 _print_byte_digits
 		pha
@@ -189,16 +193,13 @@ _print_byte_digits
         beq  _ones
         jsr  chrout
 _ones   txa
-		jsr  chrout
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  chrout
 	}}
 }
 
-asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
+asmsub  print_b  (byte value @ A) clobbers(A,X,Y)  {
 	; ---- print the byte in A in decimal form, without left padding 0s
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		pha
 		cmp  #0
 		bpl  +
@@ -210,10 +211,9 @@ asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_ubhex  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubhex  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		bcc  +
 		pha
 		lda  #'$'
@@ -222,16 +222,13 @@ asmsub  print_ubhex  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 +		jsr  conv.ubyte2hex
 		jsr  chrout
 		tya
-		jsr  chrout
-		ldx  P8ZP_SCRATCH_REG
-		rts
+		jmp  chrout
 	}}
 }
 
-asmsub  print_ubbin  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_ubbin  (ubyte value @ A, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
-		stx  P8ZP_SCRATCH_REG
 		sta  P8ZP_SCRATCH_B1
 		bcc  +
 		lda  #'%'
@@ -244,12 +241,11 @@ asmsub  print_ubbin  (ubyte value @ A, ubyte prefix @ Pc) clobbers(A,Y)  {
 +		jsr  chrout
 		dey
 		bne  -
-		ldx  P8ZP_SCRATCH_REG
 		rts
 	}}
 }
 
-asmsub  print_uwbin  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwbin  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		pha
@@ -261,7 +257,7 @@ asmsub  print_uwbin  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uwhex  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
+asmsub  print_uwhex  (uword value @ AY, bool prefix @ Pc) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in hexadecimal form (4 digits)
 	;      (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
@@ -274,10 +270,9 @@ asmsub  print_uwhex  (uword value @ AY, ubyte prefix @ Pc) clobbers(A,Y)  {
 	}}
 }
 
-asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw0  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
@@ -285,17 +280,14 @@ asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 		jsr  chrout
 		iny
 		bne  -
-+		ldx  P8ZP_SCRATCH_REG
-		rts
++		rts
 	}}
 }
 
-asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
+asmsub  print_uw  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
-	    stx  P8ZP_SCRATCH_REG
 		jsr  conv.uword2decimal
-		ldx  P8ZP_SCRATCH_REG
 		ldy  #0
 -		lda  conv.uword2decimal.decTenThousands,y
 		beq  _allzero
@@ -316,7 +308,7 @@ _allzero
 	}}
 }
 
-asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
+asmsub  print_w  (word value @ AY) clobbers(A,X,Y)  {
 	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
 	%asm {{
 		cpy  #0
@@ -380,7 +372,7 @@ asmsub  getclr  (ubyte col @A, ubyte row @Y) clobbers(Y) -> ubyte @ A {
         }}
 }
 
-sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
+sub  setcc  (ubyte col, ubyte row, ubyte char, ubyte charcolor)  {
 	; ---- set char+color at the given position on the screen
 	; TODO
 	%asm {{
@@ -388,11 +380,19 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
         }}
 }
 
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
-	; ---- set cursor at specific position
-	; TODO
+sub  plot(ubyte col, ubyte rownum) {
+    column(col)
+    row(rownum)
+}
+
+sub get_cursor(uword colptr, uword rowptr) {
+    @(colptr) = get_column()
+    @(rowptr) = get_row()
+}
+
+asmsub waitkey() -> ubyte @A {
     %asm {{
-	    rts
+        jmp  atari.waitkey
     }}
 }
 

compiler/res/prog8lib/c128/graphics.p8

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