first setup of LSP languageserver

added cx16/landscape.p8 example that draws procedurally generated landscapes.
found bug in signed byte comparisons with overflow.

.github/FUNDING.yml

@@ -2,7 +2,7 @@
 
 #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
+#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
@@ -11,3 +11,4 @@ ko_fi: irmen
 #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']
+custom: ['https://paypal.me/irmendejong']

.github/workflows/all-ci.yml

@@ -10,7 +10,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: build and install recent 64tass
         run: |
@@ -21,16 +21,21 @@ jobs:
           sudo make install          
 
       - name: Set up JDK 11
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
           java-version: 11
-          distribution: adopt
+          distribution: temurin
 
       - name: Build and test with Gradle
-        run: ./gradlew build shadowJar --no-daemon
+        run: |
+          ./gradlew build shadowJar --no-daemon
+          sha256sum -b compiler/build/libs/*-all.jar > compiler/build/libs/hash.txt
         
       - name: Create compiler shadowJar artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: prog8-compiler-jar-zipped
-          path: compiler/build/libs/*-all.jar
+          path: |
+            compiler/build/libs/*-all.jar
+            compiler/build/libs/hash.txt
+

.gitignore

@@ -1,8 +1,12 @@
 .idea/workspace.xml
 .idea/discord.xml
+.idea/developer-tools.xml
+.idea/usage.statistics.xml
+.idea/shelf/
 build/
 dist/
 output/
+out/
 .*cache/
 *.directory
 *.prg
@@ -11,7 +15,6 @@ output/
 *.vm.txt
 *.vice-mon-list
 docs/build
-out/
 parser/**/*.interp
 parser/**/*.tokens
 parser/**/*.java
@@ -22,6 +25,7 @@ compiler/src/prog8/buildversion/*
 .eggs/
 /MANIFEST
 .tox/
+.kotlin/
 __pycache__/
 parser.out
 parsetab.py
@@ -30,8 +34,6 @@ parsetab.py
 compiler/lib/
 
 .gradle
-**/BuildVersion.kt
-/prog8compiler.jar
 sd*.img
 *.d64
 

.idea/kotlinc.xml

@@ -1,9 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="Kotlin2JsCompilerArguments">
+    <option name="moduleKind" value="plain" />
+  </component>
   <component name="Kotlin2JvmCompilerArguments">
     <option name="jvmTarget" value="11" />
   </component>
+  <component name="KotlinCommonCompilerArguments">
+    <option name="apiVersion" value="2.1" />
+    <option name="languageVersion" value="2.1" />
+  </component>
+  <component name="KotlinCompilerSettings">
+    <option name="additionalArguments" value="-Xwhen-guards" />
+  </component>
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.9.20" />
+    <option name="version" value="2.1.10" />
   </component>
 </project>

.idea/libraries/KotlinJavaRuntime.xml

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

.idea/libraries/antlr_antlr4.xml

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

.idea/libraries/eclipse_lsp4j.xml

@@ -0,0 +1,13 @@
+<component name="libraryTable">
+  <library name="eclipse.lsp4j" type="repository">
+    <properties maven-id="org.eclipse.lsp4j:org.eclipse.lsp4j:0.24.0" />
+    <CLASSES>
+      <root url="jar://$MAVEN_REPOSITORY$/org/eclipse/lsp4j/org.eclipse.lsp4j/0.24.0/org.eclipse.lsp4j-0.24.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/eclipse/lsp4j/org.eclipse.lsp4j.jsonrpc/0.24.0/org.eclipse.lsp4j.jsonrpc-0.24.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/google/code/gson/gson/2.12.1/gson-2.12.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/google/errorprone/error_prone_annotations/2.36.0/error_prone_annotations-2.36.0.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/github_hypfvieh_dbus_java.xml

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

.idea/libraries/glassfish_javax_json.xml

@@ -1,10 +0,0 @@
-<component name="libraryTable">
-  <library name="glassfish.javax.json" type="repository">
-    <properties include-transitive-deps="false" maven-id="org.glassfish:javax.json:1.1.4" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/glassfish/javax.json/1.1.4/javax.json-1.1.4.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/libraries/io_kotest_assertions_core_jvm.xml

@@ -1,21 +1,18 @@
 <component name="libraryTable">
   <library name="io.kotest.assertions.core.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.8.0" />
+    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.9.1" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.8.0/kotest-assertions-core-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.8.10/kotlin-stdlib-jdk8-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.8.10/kotlin-stdlib-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.8.10/kotlin-stdlib-jdk7-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.8.0/kotest-assertions-shared-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.9.1/kotest-assertions-core-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.9.1/kotest-assertions-shared-jvm-5.9.1.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.8.10/kotlin-stdlib-common-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.7.0/kotlinx-coroutines-jdk8-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.8.10/kotlin-reflect-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.8.0/kotest-common-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.8.0/kotest-assertions-api-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.7.0/kotlinx-coroutines-core-jvm-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/23.0.0/annotations-23.0.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.23/kotlin-stdlib-1.9.23.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.8.0/kotlinx-coroutines-jdk8-1.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.9.23/kotlin-reflect-1.9.23.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.9.1/kotest-common-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.9.1/kotest-assertions-api-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.8.0/kotlinx-coroutines-core-jvm-1.8.0.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/io_kotest_framework_datatest.xml

@@ -0,0 +1,23 @@
+<component name="libraryTable">
+  <library name="io.kotest.framework.datatest" type="repository">
+    <properties maven-id="io.kotest:kotest-framework-datatest:5.9.1" />
+    <CLASSES>
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-datatest/5.9.1/kotest-framework-datatest-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-datatest-jvm/5.9.1/kotest-framework-datatest-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.23/kotlin-stdlib-1.9.23.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.8.0/kotlinx-coroutines-core-jvm-1.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.9.1/kotest-common-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.9.23/kotlin-reflect-1.9.23.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.9.1/kotest-framework-api-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.9.1/kotest-assertions-shared-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.9.1/kotest-assertions-api-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.8.0/kotlinx-coroutines-jdk8-1.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.3.0/opentest4j-1.3.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.8.0/kotlinx-coroutines-test-jvm-1.8.0.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/io_kotest_runner_junit5_jvm.xml

@@ -1,30 +1,30 @@
 <component name="libraryTable">
   <library name="io.kotest.runner.junit5.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.8.0" />
+    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.9.1" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.8.0/kotest-runner-junit5-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.8.0/kotest-framework-api-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.8.0/kotest-assertions-shared-jvm-5.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.9.1/kotest-runner-junit5-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.9.1/kotest-framework-api-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.9.1/kotest-assertions-shared-jvm-5.9.1.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.12/java-diff-utils-4.12.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.7.0/kotlinx-coroutines-test-jvm-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.8.0/kotest-common-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.8.0/kotest-framework-engine-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.162/classgraph-4.8.162.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.8.0/kotlinx-coroutines-test-jvm-1.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.9.1/kotest-common-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.9.1/kotest-framework-engine-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.172/classgraph-4.8.172.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/com/github/ajalt/mordant/1.2.1/mordant-1.2.1.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/com/github/ajalt/colormath/1.2.0/colormath-1.2.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.7.0/kotlinx-coroutines-debug-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.8.0/kotlinx-coroutines-debug-1.8.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna/5.9.0/jna-5.9.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna-platform/5.9.0/jna-platform-5.9.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.10.9/byte-buddy-1.10.9.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.10.9/byte-buddy-agent-1.10.9.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.8.0/kotest-framework-discovery-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.8.0/kotest-assertions-core-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.7.0/kotlinx-coroutines-jdk8-1.7.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.8.0/kotest-assertions-api-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.8.0/kotest-extensions-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.8.0/kotest-framework-concurrency-jvm-5.8.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.7.0/kotlinx-coroutines-core-jvm-1.7.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.9.1/kotest-framework-discovery-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.9.1/kotest-assertions-core-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.8.0/kotlinx-coroutines-jdk8-1.8.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.9.1/kotest-assertions-api-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.9.1/kotest-extensions-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.9.1/kotest-framework-concurrency-jvm-5.9.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.8.0/kotlinx-coroutines-core-jvm-1.8.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/23.0.0/annotations-23.0.0.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.8.2/junit-platform-engine-1.8.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.8.2/junit-platform-commons-1.8.2.jar!/" />
@@ -32,11 +32,8 @@
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-suite-api/1.8.2/junit-platform-suite-api-1.8.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-launcher/1.8.2/junit-platform-launcher-1.8.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.2/junit-jupiter-api-5.8.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.8.10/kotlin-stdlib-jdk8-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.8.10/kotlin-stdlib-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.8.10/kotlin-stdlib-jdk7-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.8.10/kotlin-stdlib-common-1.8.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.8.10/kotlin-reflect-1.8.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.9.23/kotlin-stdlib-1.9.23.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.9.23/kotlin-reflect-1.9.23.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/michael_bull_kotlin_result_jvm.xml

@@ -1,15 +1,20 @@
 <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.18" />
+    <properties maven-id="com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.1" />
     <CLASSES>
-      <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$/com/michael-bull/kotlin-result/kotlin-result-jvm/2.0.1/kotlin-result-jvm-2.0.1.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.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 />
+    <JAVADOC>
+      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/2.0.1/kotlin-result-jvm-2.0.1-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!/" />
+    </JAVADOC>
+    <SOURCES>
+      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/2.0.1/kotlin-result-jvm-2.0.1-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!/" />
+    </SOURCES>
   </library>
 </component>

.idea/libraries/slf4j_simple.xml

@@ -1,11 +0,0 @@
-<component name="libraryTable">
-  <library name="slf4j.simple" type="repository">
-    <properties maven-id="org.slf4j:slf4j-simple:2.0.11" />
-    <CLASSES>
-      <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 />
-  </library>
-</component>

.idea/libraries/takes.xml

@@ -1,18 +0,0 @@
-<component name="libraryTable">
-  <library name="takes" type="repository">
-    <properties maven-id="org.takes:takes:1.24.4" />
-    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/takes/takes/1.24.4/takes-1.24.4.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/cactoos/cactoos/0.54.0/cactoos-0.54.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/javax/xml/bind/jaxb-api/2.4.0-b180830.0359/jaxb-api-2.4.0-b180830.0359.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/javax/activation/javax.activation-api/1.2.0/javax.activation-api-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/sun/xml/bind/jaxb-core/4.0.0/jaxb-core-4.0.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/jakarta/xml/bind/jakarta.xml.bind-api/4.0.0/jakarta.xml.bind-api-4.0.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/jakarta/activation/jakarta.activation-api/2.1.0/jakarta.activation-api-2.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/eclipse/angus/angus-activation/1.0.0/angus-activation-1.0.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/sun/xml/bind/jaxb-impl/4.0.0/jaxb-impl-4.0.0.jar!/" />
-    </CLASSES>
-    <JAVADOC />
-    <SOURCES />
-  </library>
-</component>

.idea/misc.xml

@@ -4,13 +4,13 @@
     <option name="perGrammarGenerationSettings">
       <list>
         <PerGrammarGenerationSettings>
-          <option name="fileName" value="$PROJECT_DIR$/parser/antlr/Prog8ANTLR.g4" />
+          <option name="fileName" value="$PROJECT_DIR$/parser/src/main/antlr/Prog8ANTLR.g4" />
           <option name="autoGen" value="true" />
           <option name="outputDir" value="$PROJECT_DIR$/parser/src/prog8/parser" />
           <option name="libDir" value="" />
           <option name="encoding" value="" />
           <option name="pkg" value="" />
-          <option name="language" value="" />
+          <option name="language" value="Java" />
           <option name="generateListener" value="false" />
         </PerGrammarGenerationSettings>
       </list>
@@ -22,7 +22,7 @@
   <component name="FrameworkDetectionExcludesConfiguration">
     <type id="Python" />
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="openjdk-11" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="openjdk-21" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

.idea/modules.xml

@@ -2,6 +2,8 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
+      <module fileurl="file://$PROJECT_DIR$/beanshell/beanshell.iml" filepath="$PROJECT_DIR$/beanshell/beanshell.iml" />
+      <module fileurl="file://$PROJECT_DIR$/benchmark-program/benchmark-program.iml" filepath="$PROJECT_DIR$/benchmark-program/benchmark-program.iml" />
       <module fileurl="file://$PROJECT_DIR$/codeCore/codeCore.iml" filepath="$PROJECT_DIR$/codeCore/codeCore.iml" />
       <module fileurl="file://$PROJECT_DIR$/codeGenCpu6502/codeGenCpu6502.iml" filepath="$PROJECT_DIR$/codeGenCpu6502/codeGenCpu6502.iml" />
       <module fileurl="file://$PROJECT_DIR$/codeGenExperimental/codeGenExperimental.iml" filepath="$PROJECT_DIR$/codeGenExperimental/codeGenExperimental.iml" />
@@ -10,12 +12,13 @@
       <module fileurl="file://$PROJECT_DIR$/codeOptimizers/codeOptimizers.iml" filepath="$PROJECT_DIR$/codeOptimizers/codeOptimizers.iml" />
       <module fileurl="file://$PROJECT_DIR$/compiler/compiler.iml" filepath="$PROJECT_DIR$/compiler/compiler.iml" />
       <module fileurl="file://$PROJECT_DIR$/compilerAst/compilerAst.iml" filepath="$PROJECT_DIR$/compilerAst/compilerAst.iml" />
-      <module fileurl="file://$PROJECT_DIR$/dbusCompilerService/dbusCompilerService.iml" filepath="$PROJECT_DIR$/dbusCompilerService/dbusCompilerService.iml" />
       <module fileurl="file://$PROJECT_DIR$/docs/docs.iml" filepath="$PROJECT_DIR$/docs/docs.iml" />
       <module fileurl="file://$PROJECT_DIR$/examples/examples.iml" filepath="$PROJECT_DIR$/examples/examples.iml" />
-      <module fileurl="file://$PROJECT_DIR$/httpCompilerService/httpCompilerService.iml" filepath="$PROJECT_DIR$/httpCompilerService/httpCompilerService.iml" />
       <module fileurl="file://$PROJECT_DIR$/intermediate/intermediate.iml" filepath="$PROJECT_DIR$/intermediate/intermediate.iml" />
+      <module fileurl="file://$PROJECT_DIR$/languageServer/languageServer.iml" filepath="$PROJECT_DIR$/languageServer/languageServer.iml" />
       <module fileurl="file://$PROJECT_DIR$/parser/parser.iml" filepath="$PROJECT_DIR$/parser/parser.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/modules/prog8.iml" filepath="$PROJECT_DIR$/.idea/modules/prog8.iml" />
+      <module fileurl="file://$PROJECT_DIR$/simpleAst/simpleAst.iml" filepath="$PROJECT_DIR$/simpleAst/simpleAst.iml" />
       <module fileurl="file://$PROJECT_DIR$/virtualmachine/virtualmachine.iml" filepath="$PROJECT_DIR$/virtualmachine/virtualmachine.iml" />
     </modules>
   </component>

.readthedocs.yaml

@@ -9,17 +9,19 @@ version: 2
 build:
   os: ubuntu-22.04
   tools:
-    python: "3.11"
-
-# Build documentation in the docs/ directory with Sphinx
-sphinx:
-  configuration: docs/source/conf.py
-
-# If using Sphinx, optionally build your docs in additional formats such as PDF
-formats:
-  - pdf
+    python: "3.12"
 
 # Optionally declare the Python requirements required to build your docs
 python:
   install:
     - requirements: docs/requirements.txt
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/source/conf.py
+  fail_on_warning: true
+
+# If using Sphinx, optionally build your docs in additional formats such as PDF
+formats:
+  - pdf
+  - epub

Makefile

@@ -0,0 +1,12 @@
+# super simple Makefile to lauch the main gradle targets to build and/or test the prog8 compiler
+
+.PHONY: all test
+
+all:
+	gradle installdist installshadowdist
+	@echo "compiler launch script can be found here: compiler/build/install/compiler-shadow/bin/prog8c"
+
+test:
+	gradle build
+	@echo "compiler launch script can be found here: compiler/build/install/compiler-shadow/bin/prog8c"
+

README.md

@@ -1,4 +1,7 @@
 [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/H2H6S0FFF)
+
+PayPal: [![PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://paypal.me/irmendejong)
+
 [![Documentation](https://readthedocs.org/projects/prog8/badge/?version=latest)](https://prog8.readthedocs.io/)
 
 Prog8 - Structured Programming Language for 8-bit 6502/65c02 microprocessors
@@ -14,7 +17,7 @@ which aims to provide many conveniences over raw assembly code (even when using
 
 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). 
+you can help me out a little bit over at [ko-fi.com/irmen](https://ko-fi.com/irmen) or [PayPal](https://paypal.me/irmendejong)
 
 
 Documentation
@@ -29,6 +32,10 @@ How to get it/build it
 - 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).
+    Note that if you are not using *gradle* to build it, you might have to perform some manual
+    tasks once to make it compile fully. These are explained in the linked instructions. 
+- Alternatively, you can also install the compiler as a package on some linux distros:
+  - Arch (via AUR): [`prog8`](https://aur.archlinux.org/packages/prog8)
 
 Community
 ---------
@@ -49,26 +56,32 @@ GNU GPL 3.0 (see file LICENSE), with exception for generated code:
 What does Prog8 provide?
 ------------------------
 
-- reduction of source code length over raw assembly
-- fast execution speed due to compilation to native assembly code. It's possible to write certain raster interrupt 'demoscene' effects purely in Prog8.
-- modularity, symbol scoping, subroutines
+- all advantages of a higher level language over having to write assembly code manually
+- programs run very fast because it's compiled to native machine code
+- code often is smaller and faster than equivalent C code compiled with CC65 or even LLVM-MOS
+- modularity, symbol scoping, subroutines. No need for forward declarations.
 - various data types other than just bytes (16-bit words, floats, strings)
-- floating point math is supported if the target system provides floating point library routines (C64 and Cx16 both do)
+- floating point math is supported on certain targets
+- access to most Kernal ROM routines as external subroutine definitions you can call normally
+- tight control over Zeropage usage
+- programs can be run multiple times without reloading because of automatic variable (re)initializations.
+- programs can be configured to execute in ROM
 - strings can contain escaped characters but also many symbols directly if they have a petscii equivalent, such as "♠♥♣♦π▚●○╳". Characters like ^, _, \, {, } and | are also accepted and converted to the closest petscii equivalents.
 - automatic static variable allocations, automatic string and array variables and string sharing
-- subroutines with input parameters and result values
 - high-level program optimizations
-- small program boilerplate/compilersupport overhead
-- programs can be run multiple times without reloading because of automatic variable (re)initializations.
-- conditional branches
+- conditional branches that map 1:1 to cpu status flags
 - ``when`` statement to provide a concise jump table alternative to if/elseif chains
+- ``on .. goto`` statement for fast jump tables
 - ``in`` expression for concise and efficient multi-value/containment check 
-- many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``sort`` and ``reverse``
+- ``defer`` statement to help write concise and robust subroutine cleanup logic
+- several specialized built-in functions such as ``lsb``, ``msb``, ``min``, ``max``, ``rol``, ``ror``
 - various powerful built-in libraries to do I/O, number conversions, graphics and more  
-- convenience abstractions for low level aspects such as ZeroPage handling, program startup, explicit memory addresses
+- subroutines can return more than one result value
 - inline assembly allows you to have full control when every cycle or byte matters
-- supports the sixteen 'virtual' 16-bit registers R0 - R15 from the Commander X16, and provides them also on the C64.
-- encode strings and characters into petscii or screencodes as desired (C64/Cx16)
+- supports the sixteen 'virtual' 16-bit registers R0 - R15 from the Commander X16 (also available on other targets)
+- encode strings and characters into petscii or screencodes or even other encodings
+- Automatic ROM/RAM bank switching on certain compiler targets when calling routines in other banks
+- 50 Kb of available program RAM size on the C64 by default; because Basic ROM is banked out altogether 
 
 *Rapid edit-compile-run-debug cycle:*
 
@@ -79,11 +92,11 @@ What does Prog8 provide?
 
 *Multiple supported compiler targets* (contributions to improve these or to add support for other machines are welcome!):
 
+- "cx16": [CommanderX16](https://www.commanderx16.com)  (65c02 CPU)
 - "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)
+- "pet32": Commodore PET (limited support)
+- via external configurable targets: Atari 800 XL, Neo6502, NES, C64OS, ...
 - 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)
 
 
@@ -118,12 +131,11 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
     %zeropage basicsafe
 
     main {
-    
-        ubyte[256] sieve
+        bool[256] sieve
         ubyte candidate_prime = 2       ; is increased in the loop
     
         sub start() {
-            sys.memset(sieve, 256, false)   ; clear the sieve
+            sys.memset(sieve, 256, 0)   ; clear the sieve
             txt.print("prime numbers up to 255:\n\n")
             ubyte amount=0
             repeat {
@@ -159,9 +171,6 @@ This code calculates prime numbers using the Sieve of Eratosthenes algorithm::
         }
     }
 
-
-
-
 when compiled an ran on a C-64 you'll get:
 
 ![c64 screen](docs/source/_static/primes_example.png)

beanshell/beanshell.iml

@@ -10,8 +10,15 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
     <orderEntry type="library" name="jetbrains.kotlinx.cli.jvm" level="project" />
-    <orderEntry type="library" name="github.hypfvieh.dbus.java" level="project" />
-    <orderEntry type="library" name="slf4j.simple" level="project" />
-    <orderEntry type="module" module-name="codeCore" />
+    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
+    <orderEntry type="module-library">
+      <library>
+        <CLASSES>
+          <root url="jar://$MODULE_DIR$/lib/bsh-3.0.0-SNAPSHOT.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
   </component>
 </module>

beanshell/build.gradle.kts

@@ -0,0 +1,65 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("application")
+    kotlin("jvm")
+}
+
+val serverMainClassName = "prog8lsp.MainKt"
+val applicationName = "prog8-beanshell"
+
+application {
+    mainClass.set(serverMainClassName)
+    description = "Code completions, diagnostics and more for Prog8"
+    // applicationDefaultJvmArgs = listOf("-DkotlinLanguageServer.version=$version")
+    applicationDistribution.into("bin") {
+        filePermissions {
+            user {
+                read=true
+                execute=true
+                write=true
+            }
+            other.execute = true
+            group.execute = true
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation(files("lib/bsh-3.0.0-SNAPSHOT.jar"))
+}
+
+configurations.forEach { config ->
+    config.resolutionStrategy {
+        preferProjectModules()
+    }
+}
+
+sourceSets.main {
+    java.srcDir("src")
+    resources.srcDir("resources")
+}
+
+tasks.startScripts {
+    applicationName = "prog8-beanshell"
+}
+
+tasks.register<Exec>("fixFilePermissions") {
+    // When running on macOS or Linux the start script
+    // needs executable permissions to run.
+
+    onlyIf { !System.getProperty("os.name").lowercase().contains("windows") }
+    commandLine("chmod", "+x", "${tasks.installDist.get().destinationDir}/bin/prog8-beanshell")
+}
+
+tasks.installDist {
+    finalizedBy("fixFilePermissions")
+}
+
+tasks.build {
+    finalizedBy("installDist")
+}

beanshell/src/prog8beanshell/CommandLineReader.kt

@@ -0,0 +1,48 @@
+package prog8beanshell
+
+import java.io.FilterReader
+import java.io.Reader
+
+
+class CommandLineReader(val input: Reader): FilterReader(input)  {
+    private val normal = 0
+    private val lastCharNL = 1
+    private val sentSemi = 2
+    private var state = lastCharNL
+
+    override fun read(): Int {
+        if (state == sentSemi) {
+            this.state = lastCharNL
+            return 10
+        } else {
+            var b = input.read()
+            while(b==13) b = input.read()
+
+            if (b == 10) {
+                if (this.state == lastCharNL) {
+                    b = 59
+                    this.state = sentSemi
+                } else {
+                    this.state = lastCharNL
+                }
+            } else {
+                this.state = normal
+            }
+
+            return b
+        }
+
+    }
+
+    override fun read(buff: CharArray, off: Int, len: Int): Int {
+        val b = read()
+        if (b == -1) {
+            return -1
+        } else {
+            buff[off] = b.toChar()
+            return 1
+        }
+
+    }
+}
+

beanshell/src/prog8beanshell/Main.kt

@@ -0,0 +1,23 @@
+package prog8beanshell
+
+import bsh.FileReader
+import bsh.Interpreter
+
+
+class BeanshellInterpreter {
+
+    fun run(symbols: Map<String, Any>) {
+        val interpreter = Interpreter(CommandLineReader(FileReader(System.`in`)), System.out, System.err, true)
+        interpreter.setExitOnEOF(false)
+        symbols.forEach { (name, value) -> interpreter.set(name, value) }
+        interpreter.run()
+    }
+}
+
+fun main(args: Array<String>) {
+    val i = BeanshellInterpreter()
+    i.run(mapOf(
+        "env" to System.getenv(),
+        "args" to args
+    ))
+}

benchmark-program/Makefile

@@ -0,0 +1,10 @@
+.PHONY:  clean run
+
+run:
+	prog8c -target cx16 benchmark.p8
+	x16emu -run -prg benchmark.prg -warp
+
+clean:
+	rm -f *.prg *.PRG *.asm *.vice-* *.BIN *.PAL *.zip *.7z
+
+

benchmark-program/b_3d.p8

@@ -0,0 +1,109 @@
+%import textio
+%import math
+
+rotate3d {
+    const ubyte WIDTH = 40
+    const ubyte HEIGHT = 30
+
+    sub benchmark(uword max_time) -> uword {
+
+        uword anglex
+        uword angley
+        uword anglez
+        uword frames
+
+        txt.nl()
+        cbm.SETTIM(0,0,0)
+
+        while cbm.RDTIM16()<max_time {
+            matrix_math.rotate_vertices(msb(anglex), msb(angley), msb(anglez))
+            draw_edges()   ; doesn't really draw anything in the benchmark, but does do the screen calculations
+            anglex+=500
+            angley+=215
+            anglez+=453
+            frames++
+        }
+
+        return frames
+    }
+
+    sub draw_edges() {
+
+        ; plot the points of the 3d cube
+        ; first the points on the back, then the points on the front (painter algorithm)
+
+        ubyte @zp i
+        word @zp rz
+        word @zp persp
+        byte @shared sx
+        byte @shared sy
+
+        for i in 0 to len(matrix_math.xcoor)-1 {
+            rz = matrix_math.rotatedz[i]
+            if rz >= 10 {
+                persp = 600 + rz/64
+                sx = matrix_math.rotatedx[i] / persp as byte + WIDTH/2
+                sy = matrix_math.rotatedy[i] / persp as byte + HEIGHT/2
+                ;; txt.setcc(sx as ubyte, sy as ubyte, 46, 7)
+            }
+        }
+
+        for i in 0 to len(matrix_math.xcoor)-1 {
+            rz = matrix_math.rotatedz[i]
+            if rz < 10 {
+                persp = 600 + rz/64
+                sx = matrix_math.rotatedx[i] / persp as byte + WIDTH/2
+                sy = matrix_math.rotatedy[i] / persp as byte + HEIGHT/2
+                ;; txt.setcc(sx as ubyte, sy as ubyte, 81, 7)
+            }
+        }
+
+        txt.chrout('.')
+    }
+}
+
+matrix_math {
+    ; vertices
+    word[] xcoor = [ -40, -40, -40, -40,  40,  40,  40, 40 ]
+    word[] ycoor = [ -40, -40,  40,  40, -40, -40,  40, 40 ]
+    word[] zcoor = [ -40,  40, -40,  40, -40,  40, -40, 40 ]
+
+    ; storage for rotated coordinates
+    word[len(xcoor)] rotatedx
+    word[len(ycoor)] rotatedy
+    word[len(zcoor)] rotatedz
+
+    sub rotate_vertices(ubyte ax, ubyte ay, ubyte az) {
+        ; rotate around origin (0,0,0)
+
+        ; set up the 3d rotation matrix values
+        word wcosa = math.cos8(ax)
+        word wsina = math.sin8(ax)
+        word wcosb = math.cos8(ay)
+        word wsinb = math.sin8(ay)
+        word wcosc = math.cos8(az)
+        word wsinc = math.sin8(az)
+
+        word wcosa_sinb = wcosa*wsinb / 128
+        word wsina_sinb = wsina*wsinb / 128
+
+        word Axx = wcosa*wcosb / 128
+        word Axy = (wcosa_sinb*wsinc - wsina*wcosc) / 128
+        word Axz = (wcosa_sinb*wcosc + wsina*wsinc) / 128
+        word Ayx = wsina*wcosb / 128
+        word Ayy = (wsina_sinb*wsinc + wcosa*wcosc) / 128
+        word Ayz = (wsina_sinb*wcosc - wcosa*wsinc) / 128
+        word Azx = -wsinb
+        word Azy = wcosb*wsinc / 128
+        word Azz = wcosb*wcosc / 128
+
+        ubyte @zp i
+        for i in 0 to len(xcoor)-1 {
+            ; don't normalize by dividing by 128, instead keep some precision for perspective calc later
+            rotatedx[i] = Axx*xcoor[i] + Axy*ycoor[i] + Axz*zcoor[i]
+            rotatedy[i] = Ayx*xcoor[i] + Ayy*ycoor[i] + Ayz*zcoor[i]
+            rotatedz[i] = Azx*xcoor[i] + Azy*ycoor[i] + Azz*zcoor[i]
+        }
+    }
+
+}

benchmark-program/b_adpcm.p8

@@ -0,0 +1,89 @@
+adpcm {
+
+    sub decode_benchmark(uword max_time) -> uword {
+        uword num_blocks
+        txt.nl()
+        cbm.SETTIM(0,0,0)
+
+        while cbm.RDTIM16()<max_time {
+            adpcm.init(0,0)
+            uword @requirezp nibbles_ptr = $a000 ; for benchmark purposes, the exact nibbles don't really matter, so we just take the basic ROM as input
+            repeat 252/2 {
+                unroll 2 {
+                    ubyte @zp nibble = @(nibbles_ptr)
+                    adpcm.decode_nibble(nibble & 15)     ; first word  (note: upper nibble needs to be zero!)
+                    adpcm.decode_nibble(nibble>>4)       ; second word  (note: upper nibble is zero, after the shifts.)
+                    nibbles_ptr++
+                }
+            }
+            num_blocks++
+            txt.chrout('.')
+        }
+
+        return num_blocks
+    }
+
+    ; IMA ADPCM decoder.  Supports mono and stereo streams.
+
+    byte[] t_index = [ -1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8]
+    uword[] t_step = [
+            7, 8, 9, 10, 11, 12, 13, 14,
+            16, 17, 19, 21, 23, 25, 28, 31,
+            34, 37, 41, 45, 50, 55, 60, 66,
+            73, 80, 88, 97, 107, 118, 130, 143,
+            157, 173, 190, 209, 230, 253, 279, 307,
+            337, 371, 408, 449, 494, 544, 598, 658,
+            724, 796, 876, 963, 1060, 1166, 1282, 1411,
+            1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
+            3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
+            7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
+            15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
+            32767]
+
+    uword @requirezp predict       ; decoded 16 bit pcm sample for first channel.
+    ubyte @requirezp index
+    uword @requirezp pstep
+
+    sub init(uword startPredict, ubyte startIndex) {
+        ; initialize first decoding channel.
+        predict = startPredict
+        index = startIndex
+        pstep = t_step[index]
+    }
+
+    sub decode_nibble(ubyte @zp nibble) {
+        ; Decoder for a single nibble for the first channel. (value of 'nibble' needs to be strictly 0-15 !)
+        ; This is the hotspot of the decoder algorithm!
+        ; Note that the generated assembly from this is pretty efficient,
+        ; rewriting it by hand in asm seems to improve it only ~10%.
+        cx16.r0s = 0                ; difference
+        if nibble & %0100 !=0
+            cx16.r0s += pstep
+        pstep >>= 1
+        if nibble & %0010 !=0
+            cx16.r0s += pstep
+        pstep >>= 1
+        if nibble & %0001 !=0
+            cx16.r0s += pstep
+        pstep >>= 1
+        cx16.r0s += pstep
+        if nibble & %1000 !=0
+            predict -= cx16.r0
+        else
+            predict += cx16.r0
+
+        ; NOTE: the original C/Python code uses a 32 bits prediction value and clips it to a 16 bit word
+        ;       but for speed reasons we only work with 16 bit words here all the time (with possible clipping error)
+        ; if predicted > 32767:
+        ;    predicted = 32767
+        ; elif predicted < -32767:
+        ;    predicted = - 32767
+
+        index += t_index[nibble] as ubyte
+        if_neg
+            index = 0
+        else if index >= len(t_step)-1
+            index = len(t_step)-1
+        pstep = t_step[index]
+    }
+}

benchmark-program/b_circles.p8

@@ -0,0 +1,111 @@
+%import gfx_lores
+%import math
+
+circles {
+    const ubyte MAX_NUM_CIRCLES = 80
+    const ubyte GROWTH_RATE = 4
+    uword[MAX_NUM_CIRCLES] circle_x
+    uword[MAX_NUM_CIRCLES] circle_y
+    ubyte[MAX_NUM_CIRCLES] circle_radius
+    ubyte color
+    uword total_num_circles
+
+    sub draw(bool use_kernal, uword max_time) -> uword {
+        if use_kernal
+            cx16.set_screen_mode(128)
+        else
+            gfx_lores.graphics_mode()
+
+        math.rndseed(12345,6789)
+        cbm.SETTIM(0,0,0)
+
+        total_num_circles = 0
+        color = 16
+
+        while cbm.RDTIM16()<max_time {
+            if use_kernal {
+                cx16.GRAPH_set_colors(0,0,0)
+                cx16.GRAPH_clear()
+            }
+            else
+                gfx_lores.clear_screen(0)
+            total_num_circles += draw_circles(use_kernal, max_time)
+        }
+
+        if use_kernal
+            cx16.set_screen_mode(3)
+        else {
+            gfx_lores.text_mode()
+        }
+
+        return total_num_circles
+    }
+
+    sub draw_circles(bool use_kernal, uword max_time) -> uword {
+        uword @zp x
+        uword @zp y
+        ubyte @zp radius
+
+        ubyte num_circles
+
+        while num_circles<MAX_NUM_CIRCLES and cbm.RDTIM16()<max_time {
+            x = math.rndw() % 320
+            y = math.rndw() % 240
+            radius = GROWTH_RATE
+            if not_colliding() {
+                while not_edge() and not_colliding() {
+                    radius += GROWTH_RATE
+                }
+                radius -= GROWTH_RATE
+                if radius>0 {
+                    color++
+                    if color==0
+                        color=16
+                    if use_kernal {
+                        cx16.GRAPH_set_colors(color, 255-color, 0)
+                        cx16.GRAPH_draw_oval(x-radius, y-radius, radius*2, radius*2, true)
+                    }
+                    else
+                        gfx_lores.disc(x, y as ubyte, radius, color)
+                    circle_x[num_circles] = x
+                    circle_y[num_circles] = y
+                    circle_radius[num_circles] = radius
+                    num_circles++
+                }
+            }
+        }
+
+        return num_circles
+
+        sub not_colliding() -> bool {
+            if num_circles==0
+                return true
+            ubyte @zp c
+            for c in 0 to num_circles-1 {
+                if distance(c) < (radius as uword) + circle_radius[c]
+                    return false
+            }
+            return true
+        }
+
+        sub distance(ubyte cix) -> uword {
+            word dx = x as word - circle_x[cix]
+            word dy = y as word - circle_y[cix]
+            uword sqx = dx*dx as uword
+            uword sqy = dy*dy as uword
+            return sqrt(sqx + sqy)
+        }
+
+        sub not_edge() -> bool {
+            if x as word - radius < 0
+                return false
+            if x + radius >= 320
+                return false
+            if y as word - radius < 0
+                return false
+            if y + radius >= 240
+                return false
+            return true
+        }
+    }
+}

benchmark-program/b_life.p8

@@ -0,0 +1,123 @@
+; conway's game of life.
+
+%import math
+%import textio
+
+life {
+    const ubyte WIDTH = 40
+    const ubyte HEIGHT = 30
+    const uword STRIDE = $0002+WIDTH
+    uword world1 = memory("world1", (WIDTH+2)*(HEIGHT+2), 0)
+    uword world2 = memory("world2", (WIDTH+2)*(HEIGHT+2), 0)
+    uword @requirezp active_world = world1
+
+   sub benchmark(uword max_time) -> uword {
+        txt.clear_screen()
+        sys.memset(world1, (WIDTH+2)*(HEIGHT+2), 0)
+        sys.memset(world2, (WIDTH+2)*(HEIGHT+2), 0)
+
+        set_start_gen()
+
+        uword gen
+        cbm.SETTIM(0,0,0)
+
+        while cbm.RDTIM16()<max_time {
+            next_gen()
+            gen++
+        }
+
+        return gen
+    }
+
+    sub set_start_gen() {
+
+; some way to set a custom start generation:
+;        str start_gen = "                " +
+;                        "                " +
+;                        "                " +
+;                        "          **    " +
+;                        "        *    *  " +
+;                        "       *        " +
+;                        "       *     *  " +
+;                        "       ******   " +
+;                        "                " +
+;                        "                " +
+;                        "                " +
+;                        "                " +
+;                        "                " +
+;                        "                " +
+;                        "                " +
+;                        "               "
+;
+;        for y in 0 to 15 {
+;            for x in 0 to 15 {
+;                if start_gen[y*16 + x]=='*'
+;                    active_world[offset + x] = 1
+;            }
+;            offset += STRIDE
+;        }
+
+        ; randomize whole world
+        math.rndseed(12345,9999)
+        uword offset = STRIDE+1
+        ubyte x
+        ubyte y
+        for y in 0 to HEIGHT-1 {
+            for x in 0 to WIDTH-1 {
+                active_world[offset+x] = math.rnd() & 1
+            }
+            offset += STRIDE
+        }
+    }
+
+    sub next_gen() {
+        const ubyte DXOFFSET = 0
+        const ubyte DYOFFSET = 0
+        ubyte[2] cell_chars = [sc:' ', sc:'●']
+
+        uword @requirezp new_world = world1
+        if active_world == world1
+            new_world = world2
+
+        ; To avoid re-calculating word index lookups into the new- and active world arrays,
+        ; we calculate the required pointer values upfront.
+        ; Inside the loop we can use ptr+x just fine (results in efficient LDA (ptr),Y instruction because x is a byte type),
+        ; and for each row we simply add the stride to the pointer.
+        ; It's more readable to use active_world[offset] etc, but offset is a word value, and this produces
+        ; inefficient assembly code because we can't use a register indexed mode in this case. Costly inside a loop.
+
+        uword @requirezp new_world_ptr = new_world + STRIDE+1-DXOFFSET
+        uword @requirezp active_world_ptr = active_world + STRIDE+1-DXOFFSET
+
+        ubyte x
+        ubyte y
+        for y in DYOFFSET to HEIGHT+DYOFFSET-1 {
+
+            cx16.vaddr_autoincr(1, $b000 + 256*y, 0, 2)     ;  allows us to use simple Vera data byte assigns later instead of setchr() calls
+
+            for x in DXOFFSET to WIDTH+DXOFFSET-1 {
+                ; count the living neighbors
+                ubyte cell = @(active_world_ptr + x)
+                uword @requirezp ptr = active_world_ptr + x - STRIDE - 1
+                ubyte neighbors = @(ptr) + @(ptr+1) + @(ptr+2) +
+                                  @(ptr+STRIDE) + cell + @(ptr+STRIDE+2) +
+                                  @(ptr+STRIDE*2) + @(ptr+STRIDE*2+1) + @(ptr+STRIDE*2+2)
+
+                ; apply game of life rules
+                if neighbors==3
+                    cell=1
+                else if neighbors!=4
+                    cell=0
+                @(new_world_ptr + x) = cell
+
+                ; draw new cell
+                ; txt.setchr(x,y,cell_chars[cell])
+                cx16.VERA_DATA0 = cell_chars[cell]
+            }
+            active_world_ptr += STRIDE
+            new_world_ptr += STRIDE
+        }
+
+        active_world = new_world
+    }
+}

benchmark-program/b_mandelbrot.p8

@@ -0,0 +1,54 @@
+%import textio
+%import floats
+
+mandelbrot {
+    const ubyte width = 39
+    const ubyte height = 29
+    const ubyte max_iter = 15
+
+    sub calc(uword max_time) -> uword  {
+        uword num_pixels
+        ubyte pixelx
+        ubyte pixely
+
+        txt.home()
+        cbm.SETTIM(0,0,0)
+
+        while cbm.RDTIM16() < max_time {
+            for pixely in 0 to height-1 {
+                float yy = (pixely as float)/0.40/height - 1.3
+
+                for pixelx in 0 to width-1 {
+                    float xx = (pixelx as float)/0.32/width - 2.2
+
+                    float xsquared = 0.0
+                    float ysquared = 0.0
+                    float x = 0.0
+                    float y = 0.0
+                    ubyte iter = 0
+
+                    while iter<max_iter and xsquared+ysquared<4.0 {
+                        y = x*y*2.0 + yy
+                        x = xsquared - ysquared + xx
+                        xsquared = x*x
+                        ysquared = y*y
+                        iter++
+                    }
+                    txt.color2(1, max_iter-iter)
+                    txt.spc()
+                    num_pixels++
+
+                    if cbm.RDTIM16()>=max_time
+                        goto finished
+                }
+                txt.nl()
+            }
+
+            txt.clear_screen()
+        }
+
+finished:
+        txt.color2(1, 6)
+        return num_pixels
+    }
+}

benchmark-program/b_maze.p8

@@ -0,0 +1,343 @@
+%import textio
+%import math
+
+; Even though prog8 only has support for extremely limited recursion,
+; you can write recursive algorithms with a bit of extra work by building your own explicit stack structure.
+; This program shows a depth-first maze generation algorithm (1 possible path from start to finish),
+; and a depth-first maze solver algorithm, both using a stack to store the path taken.
+
+; Note: this program can be compiled for multiple target systems.
+
+maze {
+    uword score
+
+    sub bench(uword max_time) -> uword {
+        txt.nl()
+        score=0
+        math.rndseed(2345,44332)
+        cbm.SETTIM(0,0,0)
+        while cbm.RDTIM16()<max_time {
+            maze.initialize()
+            maze.drawStartFinish()
+            if maze.generate(max_time) {
+                maze.openpassages()
+                maze.drawStartFinish()
+                if maze.solve(max_time) {
+                    maze.drawStartFinish()
+                } else break
+            } else break
+        }
+
+        return score
+    }
+
+    const uword screenwidth = 40
+    const uword screenheight = 30
+
+    const ubyte numCellsHoriz = (screenwidth-1) / 2
+    const ubyte numCellsVert = (screenheight-1) / 2
+
+    ; maze start and finish cells
+    const ubyte startCx = 0
+    const ubyte startCy = 0
+    const ubyte finishCx = numCellsHoriz-1
+    const ubyte finishCy = numCellsVert-1
+
+    ; cell properties
+    const ubyte STONE = 128
+    const ubyte WALKED = 64
+    const ubyte BACKTRACKED = 32
+    const ubyte UP = 1
+    const ubyte RIGHT = 2
+    const ubyte DOWN = 4
+    const ubyte LEFT = 8
+    const ubyte WALLCOLOR = 12
+    const ubyte EMPTYCOLOR = 0
+
+    ; unfortunately on larger screens (cx16), the number of cells exceeds 256 and doesn't fit in a regular array anymore.
+    uword cells = memory("cells", numCellsHoriz*numCellsVert, 0)
+
+    ubyte[256] cx_stack
+    ubyte[256] cy_stack
+    ubyte stackptr
+
+    ubyte[4] directionflags = [LEFT,RIGHT,UP,DOWN]
+
+    sub generate(uword max_time) -> bool {
+        ubyte cx = startCx
+        ubyte cy = startCy
+
+        stackptr = 0
+        @(celladdr(cx,cy)) &= ~STONE
+        drawCell(cx, cy)
+        uword cells_to_carve = numCellsHoriz * numCellsVert - 1
+
+        while cbm.RDTIM16()<max_time {
+carve_restart_after_repath:
+            ubyte direction = choose_uncarved_direction()
+            if direction==0 {
+                ;backtrack
+                stackptr--
+                if stackptr==255 {
+                    ; stack empty.
+                    ; repath if we are not done yet. (this is a workaround for the prog8 256 array lenght limit)
+                    if cells_to_carve!=0 {
+                        if repath()
+                            goto carve_restart_after_repath
+                    }
+                    return true
+                }
+                cx = cx_stack[stackptr]
+                cy = cy_stack[stackptr]
+            } else {
+                cx_stack[stackptr] = cx
+                cy_stack[stackptr] = cy
+                stackptr++
+                if stackptr==0 {
+                    ; stack overflow, we can't track our path any longer.
+                    ; repath if we are not done yet. (this is a workaround for the prog8 256 array lenght limit)
+                    if cells_to_carve!=0 {
+                        if repath()
+                            goto carve_restart_after_repath
+                    }
+                    return true
+                }
+                @(celladdr(cx,cy)) |= direction
+                when direction {
+                    UP -> {
+                        cy--
+                        @(celladdr(cx,cy)) |= DOWN
+                    }
+                    RIGHT -> {
+                        cx++
+                        @(celladdr(cx,cy)) |= LEFT
+
+                        score++
+                    }
+                    DOWN -> {
+                        cy++
+                        @(celladdr(cx,cy)) |= UP
+                    }
+                    LEFT -> {
+                        cx--
+                        @(celladdr(cx,cy)) |= RIGHT
+                    }
+                }
+                @(celladdr(cx,cy)) &= ~STONE
+                cells_to_carve--
+                drawCell(cx, cy)
+            }
+        }
+        return false
+
+        sub repath() -> bool {
+            ; repath: try to find a new start cell with possible directions.
+            ; we limit our number of searches so that the algorith doesn't get stuck
+            ; for too long on bad rng... just accept a few unused cells in that case.
+            repeat 255 {
+                do {
+                    cx = math.rnd() % numCellsHoriz
+                    cy = math.rnd() % numCellsVert
+                } until @(celladdr(cx, cy)) & STONE ==0
+                if available_uncarved()!=0
+                    return true
+            }
+            return false
+        }
+
+        sub available_uncarved() -> ubyte {
+            ubyte candidates = 0
+            if cx>0 and @(celladdr(cx-1, cy)) & STONE !=0
+                candidates |= LEFT
+            if cx<numCellsHoriz-1 and @(celladdr(cx+1, cy)) & STONE !=0
+                candidates |= RIGHT
+            if cy>0 and @(celladdr(cx, cy-1)) & STONE !=0
+                candidates |= UP
+            if cy<numCellsVert-1 and @(celladdr(cx, cy+1)) & STONE !=0
+                candidates |= DOWN
+            return candidates
+        }
+
+        sub choose_uncarved_direction() -> ubyte {
+            ubyte candidates =  available_uncarved()
+            if candidates==0
+                return 0
+
+            repeat {
+                ubyte choice = candidates & directionflags[math.rnd() & 3]
+                if choice!=0
+                    return choice
+            }
+        }
+    }
+
+    sub openpassages() {
+        ; open just a few extra passages, so that multiple routes are possible in theory.
+        ubyte numpassages
+        ubyte cx
+        ubyte cy
+        do {
+            do {
+                cx = math.rnd() % (numCellsHoriz-2) + 1
+                cy = math.rnd() % (numCellsVert-2) + 1
+            } until @(celladdr(cx, cy)) & STONE ==0
+            ubyte direction = directionflags[math.rnd() & 3]
+            if @(celladdr(cx, cy)) & direction == 0 {
+                when direction {
+                    LEFT -> {
+                        if @(celladdr(cx-1,cy)) & STONE == 0 {
+                            @(celladdr(cx,cy)) |= LEFT
+                            drawCell(cx,cy)
+                            numpassages++
+                        }
+                    }
+                    RIGHT -> {
+                        if @(celladdr(cx+1,cy)) & STONE == 0 {
+                            @(celladdr(cx,cy)) |= RIGHT
+                            drawCell(cx,cy)
+                            numpassages++
+                        }
+                    }
+                    UP -> {
+                        if @(celladdr(cx,cy-1)) & STONE == 0 {
+                            @(celladdr(cx,cy)) |= UP
+                            drawCell(cx,cy)
+                            numpassages++
+                        }
+                    }
+                    DOWN -> {
+                        if @(celladdr(cx,cy+1)) & STONE == 0 {
+                            @(celladdr(cx,cy)) |= DOWN
+                            drawCell(cx,cy)
+                            numpassages++
+                        }
+                    }
+                }
+            }
+        } until numpassages==10
+    }
+
+    sub solve(uword max_time) -> bool {
+        ubyte cx = startCx
+        ubyte cy = startCy
+        const uword max_path_length = 1024
+
+        ; the path through the maze can be longer than 256 so doesn't fit in a regular array.... :(
+        uword pathstack = memory("pathstack", max_path_length, 0)
+        uword pathstackptr = 0
+
+        @(celladdr(cx,cy)) |= WALKED
+        ; txt.setcc(cx*2+1, cy*2+1, 81, 1)
+
+        while cbm.RDTIM16()<max_time {
+solve_loop:
+            if cx==finishCx and cy==finishCy {
+                ;txt.home()
+                txt.print("found! path length: ")
+                txt.print_uw(pathstackptr)
+                txt.nl()
+                return true
+            }
+
+            ubyte cell = @(celladdr(cx,cy))
+            if cell & UP!=0 and @(celladdr(cx,cy-1)) & (WALKED|BACKTRACKED) ==0 {
+                @(pathstack + pathstackptr) = UP
+                ;txt.setcc(cx*2+1, cy*2, 81, 3)
+                cy--
+            }
+            else if cell & DOWN !=0 and @(celladdr(cx,cy+1)) & (WALKED|BACKTRACKED) ==0 {
+                @(pathstack + pathstackptr) = DOWN
+                ;txt.setcc(cx*2+1, cy*2+2, 81, 3)
+                cy++
+            }
+            else if cell & LEFT !=0 and @(celladdr(cx-1,cy)) & (WALKED|BACKTRACKED) ==0 {
+                @(pathstack + pathstackptr) = LEFT
+                ;txt.setcc(cx*2, cy*2+1, 81, 3)
+                cx--
+            }
+            else if cell & RIGHT !=0 and @(celladdr(cx+1,cy)) & (WALKED|BACKTRACKED) ==0 {
+                @(pathstack + pathstackptr) = RIGHT
+                ;txt.setcc(cx*2+2, cy*2+1, 81, 3)
+                cx++
+            }
+            else {
+                ; dead end, pop stack
+                pathstackptr--
+                if pathstackptr==65535 {
+                    txt.print("no solution?!\n")
+                    return true
+                }
+                @(celladdr(cx,cy)) |= BACKTRACKED
+                ;txt.setcc(cx*2+1, cy*2+1, 81, 2)
+                when @(pathstack + pathstackptr) {
+                    UP -> {
+                        ;txt.setcc(cx*2+1, cy*2+2, 81, 9)
+                        cy++
+                    }
+                    DOWN -> {
+                        ;txt.setcc(cx*2+1, cy*2, 81, 9)
+                        cy--
+                    }
+                    LEFT -> {
+                        ;txt.setcc(cx*2+2, cy*2+1, 81, 9)
+                        cx++
+                    }
+                    RIGHT -> {
+                        ;txt.setcc(cx*2, cy*2+1, 81, 9)
+                        cx--
+
+                        score++
+                    }
+                }
+                goto solve_loop
+            }
+            pathstackptr++
+            if pathstackptr==max_path_length {
+                txt.print("stack overflow, path too long\n")
+                return true
+            }
+            @(celladdr(cx,cy)) |= WALKED
+            ;txt.setcc(cx*2+1, cy*2+1, 81, 1)
+        }
+        return false
+    }
+
+    sub celladdr(ubyte cx, ubyte cy) -> uword {
+        return cells+(numCellsHoriz as uword)*cy+cx
+    }
+
+    sub drawCell(ubyte cx, ubyte cy) {
+        return
+;        ubyte x = cx * 2 + 1
+;        ubyte y = cy * 2 + 1
+;        ubyte doors = @(celladdr(cx,cy))
+;        if doors & UP !=0
+;            txt.setcc(x, y-1, ' ', EMPTYCOLOR)
+;        if doors & RIGHT !=0
+;            txt.setcc(x+1, y, ' ', EMPTYCOLOR)
+;        if doors & DOWN !=0
+;            txt.setcc(x, y+1, ' ', EMPTYCOLOR)
+;        if doors & LEFT !=0
+;            txt.setcc(x-1, y, ' ', EMPTYCOLOR)
+;        if doors & STONE !=0
+;            txt.setcc(x, y, 160, WALLCOLOR)
+;        else
+;            txt.setcc(x, y, 32, EMPTYCOLOR)
+;
+;        if doors & WALKED !=0
+;            txt.setcc(x, y, 81, 1)
+;        if doors & BACKTRACKED !=0
+;            txt.setcc(x, y, 81, 2)
+    }
+
+    sub initialize() {
+        sys.memset(cells, numCellsHoriz*numCellsVert, STONE)
+        ; txt.fill_screen(160, WALLCOLOR)
+        drawStartFinish()
+    }
+
+    sub drawStartFinish() {
+        ; txt.setcc(startCx*2+1,startCy*2+1,sc:'s',5)
+        ; txt.setcc(finishCx*2+1, finishCy*2+1, sc:'f', 13)
+    }
+}

benchmark-program/b_queens.p8

@@ -0,0 +1,63 @@
+%import textio
+
+; Recursive N-Queens solver.
+; The problem is: find all possible ways to place 8 Queen chess pieces on a chess board, so that none of them attacks any other.
+; (this program prints all solutions without taking mirroring and flipping the chess board into account)
+; Note: this program can be compiled for multiple target systems.
+
+queens {
+    const ubyte NUMQUEENS=8
+    ubyte[NUMQUEENS] board
+
+    sub could_place(ubyte row, ubyte col) -> bool {
+        if row==0
+            return true
+        ubyte i
+        for i in 0 to row-1 {
+            if board[i]==col or board[i]-i==col-row or board[i]+i==col+row
+                return false
+        }
+        return true
+    }
+
+    uword solution_count
+    uword maximum_duration
+
+    sub place_queen(ubyte row) -> bool {
+        if row == NUMQUEENS {
+            solution_count++
+            txt.chrout('.')
+            return cbm.RDTIM16()<maximum_duration
+        }
+        bool continue_running=true
+        ubyte col
+        for col in 0 to NUMQUEENS-1 {
+            if could_place(row, col) {
+                board[row] = col
+                ; we need to save the local variables row and col.
+                sys.push(row)
+                sys.push(col)
+                continue_running = place_queen(row + 1)
+                ; restore the local variables after the recursive call.
+                col = sys.pop()
+                row = sys.pop()
+                board[row] = 0
+
+                if not continue_running
+                    break
+            }
+        }
+        return continue_running
+    }
+
+    sub bench(uword max_time) -> uword {
+        solution_count = 0
+        maximum_duration = max_time
+        txt.nl()
+        cbm.SETTIM(0,0,0)
+        while cbm.RDTIM16() < maximum_duration {
+            void place_queen(0)
+        }
+        return solution_count
+    }
+}

benchmark-program/b_sprites.p8

@@ -0,0 +1,69 @@
+%import sprites
+%import coroutines
+%import math
+
+
+animsprites {
+    uword num_iterations
+    ubyte[64] sx
+    ubyte[64] sy
+    ubyte[64] sc
+    ubyte[64] dx
+    ubyte[64] dy
+    uword maximum_duration
+
+    sub benchmark(uword max_duration) -> uword {
+        maximum_duration = max_duration
+        math.rndseed(1122,9876)
+        cx16.set_screen_mode(3)
+        cx16.mouse_config2(1)
+        sprites.set_mousepointer_hand()
+        repeat 64
+            void coroutines.add(animsprite, 0)
+        cx16.mouse_config2(0)
+
+        cbm.SETTIM(0,0,0)
+        coroutines.run(supervisor)
+
+        sprites.reset(0, 64)
+        return num_iterations
+    }
+
+    sub supervisor() -> bool {
+        if cbm.RDTIM16() >= maximum_duration {
+            coroutines.killall()
+            return false
+        }
+        return true
+    }
+
+    sub animsprite() {
+        num_iterations++
+        ; set up the sprite
+        ubyte sprnum = coroutines.current()
+        cx16.r6L, cx16.r7 = sprites.get_data_ptr(0)
+        sprites.init(sprnum, cx16.r6L, cx16.r7, sprites.SIZE_16, sprites.SIZE_16, sprites.COLORS_256, 0)
+        sx[sprnum] = math.rnd()
+        sy[sprnum] = math.rnd()
+        sc[sprnum] = math.rnd()
+        dx[sprnum] = if math.rnd()&1 == 1  1 else 255
+        dy[sprnum] = if math.rnd()&1 == 1  1 else 255
+
+        ; move the sprite around
+        while sc[sprnum]!=0 {
+            animate(sprnum)
+            void coroutines.yield()
+            sprnum = coroutines.current()
+        }
+
+        sub animate(ubyte spr) {
+            defer sc[spr]--
+            sprites.pos(spr, sx[spr], sy[spr])
+            sx[spr] += dx[spr]
+            sy[spr] += dy[spr]
+        }
+
+        ; end the task but replace it with a fresh animated sprite task
+        void coroutines.add(animsprite, 0)
+    }
+}

benchmark-program/b_textelite.p8

@@ -0,0 +1,989 @@
+%import textio
+%import conv
+%import strings
+
+
+textelite {
+
+    const ubyte numforLave = 7      ;  Lave is 7th generated planet in galaxy one
+    const ubyte numforZaonce = 129
+    const ubyte numforDiso = 147
+    const ubyte numforRiedquat = 46
+    uword num_commands
+
+    sub bench(uword max_time) -> uword {
+        num_commands = 0
+        txt.lowercase()
+        cbm.SETTIM(0,0,0)
+        while cbm.RDTIM16()<max_time {
+            reinit()
+            run_commands(max_time)
+        }
+        return num_commands
+    }
+
+    sub reinit() {
+        ;txt.clear_screen()
+        ;txt.print("\n --- TextElite v1.3 ---\n")
+        txt.print("\nnew game\n")
+        elite_planet.set_seed(0, 0)
+        elite_galaxy.travel_to(1, numforLave)
+        elite_market.init(0)  ;  Lave's market is seeded with 0
+        elite_ship.init()
+        elite_planet.display(false, 0)
+        input_index = 0
+    }
+
+    sub run_commands(uword max_time) {
+        while cbm.RDTIM16() < max_time {
+            str input = "????????"
+            ;txt.print("\nCash: ")
+            ;elite_util.print_10s(elite_ship.cash)
+            ;txt.print("\nCommand (?=help): ")
+            ubyte num_chars = next_input(input)
+            ;txt.nl()
+            if num_chars!=0 {
+                when input[0] {
+                    'q' -> {
+                        bool has_error = false
+                        if elite_galaxy.number != 2 {
+                            txt.print("\nERROR: galaxy is not 2: ")
+                            txt.print_ub(elite_galaxy.number)
+                            txt.nl()
+                            has_error=true
+                        }
+                        if elite_planet.number != 164 {
+                            txt.print("\nERROR: planet is not 164: ")
+                            txt.print_ub(elite_planet.number)
+                            txt.nl()
+                            has_error=true
+                        }
+                        if elite_planet.x != 116 {
+                            txt.print("\nERROR: planet.x is not 116: ")
+                            txt.print_ub(elite_planet.x)
+                            txt.nl()
+                            has_error=true
+                        }
+                        if elite_planet.y != 201 {
+                            txt.print("\nERROR: planet.y is not 201: ")
+                            txt.print_ub(elite_planet.y)
+                            txt.nl()
+                            has_error=true
+                        }
+                        if "ribeen" != elite_planet.name {
+                            txt.print("\nERROR: planet.name is not 'ribeen': ")
+                            txt.print(elite_planet.name)
+                            txt.nl()
+                            has_error=true
+                        }
+                        if elite_ship.cash != 1212 {
+                            txt.print("\nERROR: cash is not 1212: ")
+                            txt.print_uw(elite_ship.cash)
+                            txt.nl()
+                            has_error=true
+                        }
+                        if elite_ship.fuel != 50 {
+                            txt.print("\nERROR: fuel is not 50:")
+                            txt.print_ub(elite_ship.fuel)
+                            txt.nl()
+                            has_error=true
+                        }
+                        if elite_ship.cargohold[0] != 3 {
+                            txt.print("\nERROR: food is not 3:")
+                            txt.print_ub(elite_ship.cargohold[0])
+                            txt.nl()
+                            has_error=true
+                        }
+                        if elite_ship.cargohold[1] != 0 {
+                            txt.print("\nERROR: textiles is not 0:")
+                            txt.print_ub(elite_ship.cargohold[1])
+                            txt.nl()
+                            has_error=true
+                        }
+                        if has_error
+                            sys.exit(1)
+                        return
+                    }
+                    'b' -> elite_trader.do_buy()
+                    's' -> elite_trader.do_sell()
+                    'f' -> elite_trader.do_fuel()
+                    'j' -> elite_trader.do_jump()
+                    't' -> elite_trader.do_teleport()
+                    'g' -> elite_trader.do_next_galaxy()
+                    'i' -> elite_trader.do_info()
+                    'm' -> {
+                        if input[1]=='a' and input[2]=='p'
+                            elite_trader.do_map()
+                        else
+                            elite_trader.do_show_market()
+                    }
+                    'l' -> elite_trader.do_local()
+                    'c' -> elite_trader.do_cash()
+                    'h' -> elite_trader.do_hold()
+                }
+                num_commands++
+            }
+        }
+    }
+
+    str[] inputs = [
+        "i",
+        "diso",
+        "i",
+        "lave",
+        "m",
+        "b",
+        "food",
+        "15",
+        "map",
+        "g",
+        "map",
+        "l",
+        "j",
+        "zao",
+        "s",
+        "food",
+        "12",
+        "tele",
+        "quti",
+        "tele",
+        "aro",
+        "i",
+        "diso",
+        "i",
+        "lave",
+        "i",
+        "zao",
+        "galhyp",
+        "fuel",
+        "20",
+        "j",
+        "rib",
+        "i",
+        "rib",
+        "i",
+        "tiri",
+        "q",
+        0
+    ]
+
+    ubyte input_index
+
+    sub next_input(str buffer) -> ubyte {
+        input_index++
+        return strings.copy(inputs[input_index], buffer)
+    }
+}
+
+elite_trader {
+    str input = "??????????"
+    ubyte num_chars
+
+    sub do_jump() {
+        ;txt.print("\nJump to what system? ")
+        jump_to_system()
+    }
+
+    sub do_teleport() {
+        ;txt.print("\nCheat! Teleport to what system? ")
+        ubyte fuel = elite_ship.fuel
+        elite_ship.fuel = 255
+        jump_to_system()
+        elite_ship.fuel = fuel
+    }
+
+    sub jump_to_system() {
+        void textelite.next_input(input)
+        ubyte current_planet = elite_planet.number
+        ubyte x = elite_planet.x
+        ubyte y = elite_planet.y
+        if elite_galaxy.search_closest_planet(input) {
+            ubyte distance = elite_planet.distance(x, y)
+            if distance <= elite_ship.fuel {
+                elite_galaxy.init_market_for_planet()
+                elite_ship.fuel -= distance
+                ;txt.print("\n\nHyperspace jump! Arrived at:\n")
+                elite_planet.display(true,0 )
+                return
+            }
+            ;txt.print("\nInsufficient fuel\n")
+        } else {
+            ;txt.print(" Not found!\n")
+        }
+        elite_galaxy.travel_to(elite_galaxy.number, current_planet)
+    }
+
+    sub do_buy() {
+        ;txt.print("\nBuy what commodity? ")
+        str commodity = "???????????????"
+        void textelite.next_input(commodity)
+        ubyte ci = elite_market.match(commodity)
+        if ci & 128 !=0 {
+            txt.print("Unknown\n")
+        } else {
+            ;txt.print("\nHow much? ")
+            void textelite.next_input(input)
+            ubyte amount = conv.str2ubyte(input)
+            if elite_market.current_quantity[ci] < amount {
+                txt.print(" Insufficient supply!\n")
+            } else {
+                uword price = elite_market.current_price[ci] * amount
+                ;txt.print(" Total price: ")
+                ;elite_util.print_10s(price)
+                if price > elite_ship.cash {
+                    txt.print(" Not enough cash!\n")
+                } else {
+                    elite_ship.cash -= price
+                    elite_ship.cargohold[ci] += amount
+                    elite_market.current_quantity[ci] -= amount
+                }
+            }
+        }
+    }
+
+    sub do_sell() {
+        ;txt.print("\nSell what commodity? ")
+        str commodity = "???????????????"
+        void textelite.next_input(commodity)
+        ubyte ci = elite_market.match(commodity)
+        if ci & 128 !=0 {
+            txt.print("Unknown\n")
+        } else {
+            ;txt.print("\nHow much? ")
+            void textelite.next_input(input)
+            ubyte amount = conv.str2ubyte(input)
+            if elite_ship.cargohold[ci] < amount {
+                txt.print(" Insufficient supply!\n")
+            } else {
+                uword price = elite_market.current_price[ci] * amount
+                ;txt.print(" Total price: ")
+                ;elite_util.print_10s(price)
+                elite_ship.cash += price
+                elite_ship.cargohold[ci] -= amount
+                elite_market.current_quantity[ci] += amount
+            }
+        }
+    }
+
+    sub do_fuel() {
+        ;txt.print("\nBuy fuel. Amount? ")
+        void textelite.next_input(input)
+        ubyte buy_fuel = 10*conv.str2ubyte(input)
+        ubyte max_fuel = elite_ship.Max_fuel - elite_ship.fuel
+        if buy_fuel > max_fuel
+            buy_fuel = max_fuel
+        uword price = buy_fuel as uword * elite_ship.Fuel_cost
+        if price > elite_ship.cash {
+            txt.print("Not enough cash!\n")
+        } else {
+            elite_ship.cash -= price
+            elite_ship.fuel += buy_fuel
+        }
+    }
+
+    sub do_cash() {
+        ;txt.print("\nCheat! Set cash amount: ")
+        void textelite.next_input(input)
+        elite_ship.cash = conv.str2uword(input)
+    }
+
+    sub do_hold() {
+        ;txt.print("\nCheat! Set cargohold size: ")
+        void textelite.next_input(input)
+        elite_ship.Max_cargo = conv.str2ubyte(input)
+    }
+
+    sub do_next_galaxy() {
+        txt.print("\n>>>>> Galaxy Hyperjump!\n")
+        elite_galaxy.travel_to(elite_galaxy.number+1, elite_planet.number)
+        elite_planet.display(false, 0)
+    }
+
+    sub do_info() {
+        ;txt.print("\nSystem name (empty=current): ")
+        num_chars = textelite.next_input(input)
+        if num_chars!=0 {
+            ubyte current_planet = elite_planet.number
+            ubyte x = elite_planet.x
+            ubyte y = elite_planet.y
+            if elite_galaxy.search_closest_planet(input) {
+                ubyte distance = elite_planet.distance(x, y)
+                elite_planet.display(false, distance)
+            } else {
+                ;txt.print(" Not found!")
+            }
+            elite_galaxy.travel_to(elite_galaxy.number, current_planet)
+        } else {
+            elite_planet.display(false, 0)
+        }
+    }
+
+    sub do_local() {
+        elite_galaxy.local_area()
+    }
+
+    sub do_map() {
+        ;txt.print("\n(l)ocal or (g)alaxy starmap? ")
+        num_chars = textelite.next_input(input)
+        if num_chars!=0 {
+            elite_galaxy.starmap(input[0]=='l')
+        }
+    }
+
+    sub do_show_market() {
+        elite_market.display()
+        ;txt.print("\nFuel: ")
+        ;elite_util.print_10s(elite_ship.fuel)
+        ;txt.print("   Cargohold space: ")
+        ;txt.print_ub(elite_ship.cargo_free())
+        ;txt.print("t\n")
+    }
+}
+
+elite_ship {
+    const ubyte Max_fuel = 70
+    const ubyte Fuel_cost = 2
+    ubyte Max_cargo = 20
+
+    ubyte fuel
+    uword cash
+    ubyte[17] cargohold
+
+    sub init() {
+        sys.memset(cargohold, len(cargohold), 0)
+        fuel = Max_fuel
+        cash = 1000
+    }
+}
+
+elite_market {
+    ubyte[17] baseprices = [$13, $14, $41, $28, $53, $C4, $EB, $9A, $75, $4E, $7C, $B0, $20, $61, $AB, $2D, $35]
+    byte[17] gradients = [-$02, -$01, -$03, -$05, -$05, $08, $1D, $0E, $06, $01, $0d, -$09, -$01, -$01, -$02, -$01, $0F]
+    ubyte[17] basequants = [$06, $0A, $02, $E2, $FB, $36, $08, $38, $28, $11, $1D, $DC, $35, $42, $37, $FA, $C0]
+    ubyte[17] maskbytes = [$01, $03, $07, $1F, $0F, $03, $78, $03, $07, $1F, $07, $3F, $03, $07, $1F, $0F, $07]
+    str[17] names = ["Food", "Textiles", "Radioactives", "Slaves", "Liquor/Wines", "Luxuries", "Narcotics", "Computers",
+                     "Machinery", "Alloys", "Firearms", "Furs", "Minerals", "Gold", "Platinum", "Gem-Stones", "Alien Items"]
+
+    ubyte[17] current_quantity
+    uword[17] current_price
+
+    sub init(ubyte fluct) {
+        ; Prices and availabilities are influenced by the planet's economy type
+        ; (0-7) and a random "fluctuation" byte that was kept within the saved
+        ; commander position to keep the market prices constant over gamesaves.
+        ; Availabilities must be saved with the game since the player alters them
+        ; by buying (and selling(?))
+        ;
+        ; Almost all commands are one byte only and overflow "errors" are
+        ; extremely frequent and exploited.
+        ;
+        ; Trade Item prices are held internally in a single byte=true value/4.
+        ; The decimal point in prices is introduced only when printing them.
+        ; Internally, all prices are integers.
+        ; The player's cash is held in four bytes.
+        ubyte ci
+        for ci in 0 to len(names)-1 {
+            word product
+            byte changing
+            product = elite_planet.economy as word * gradients[ci]
+            changing = fluct & maskbytes[ci]  as byte
+            ubyte q = (basequants[ci] as word + changing - product) as ubyte
+            if q & $80 !=0
+                q = 0  ; clip to positive 8-bit
+            current_quantity[ci] = q & $3f
+            q = (baseprices[ci] + changing + product) as ubyte
+            current_price[ci] = q * $0004
+        }
+        current_quantity[16] = 0        ; force nonavailability of Alien Items
+    }
+
+    sub display() {
+        return
+;        ubyte ci
+;        txt.nl()
+;        elite_planet.print_name_uppercase()
+;        txt.print(" trade market:\n    COMMODITY / PRICE / AVAIL / IN HOLD\n")
+;        for ci in 0 to len(names)-1 {
+;            elite_util.print_right(13, names[ci])
+;            txt.print("   ")
+;            elite_util.print_10s(current_price[ci])
+;            txt.column(24)
+;            txt.print_ub(current_quantity[ci])
+;            txt.chrout(' ')
+;            when units[ci] {
+;                0 -> txt.chrout('t')
+;                1 -> txt.print("kg")
+;                2 -> txt.chrout('g')
+;            }
+;            txt.column(32)
+;            txt.print_ub(elite_ship.cargohold[ci])
+;            txt.nl()
+;        }
+    }
+
+    sub match(uword nameptr) -> ubyte {
+        ubyte ci
+        for ci in 0 to len(names)-1 {
+            if elite_util.prefix_matches(nameptr, names[ci])
+                return ci
+        }
+        return 255
+    }
+}
+
+elite_galaxy {
+    const uword GALSIZE = 256
+    const uword base0 = $5A4A       ; seeds for the first galaxy
+    const uword base1 = $0248
+    const uword base2 = $B753
+
+    str pn_pairs = "..lexegezacebisousesarmaindirea.eratenberalavetiedorquanteisrion"
+
+    ubyte number
+
+    uword[3] seed
+
+    sub init(ubyte galaxynum) {
+        number = 1
+        elite_planet.number = 255
+        seed[0] = base0
+        seed[1] = base1
+        seed[2] = base2
+        repeat galaxynum-1 {
+            nextgalaxy()
+        }
+    }
+
+    sub nextgalaxy() {
+        textelite.num_commands++
+
+        seed[0] = twist(seed[0])
+        seed[1] = twist(seed[1])
+        seed[2] = twist(seed[2])
+        number++
+        if number==9
+            number = 1
+    }
+
+    sub travel_to(ubyte galaxynum, ubyte system) {
+        init(galaxynum)
+        generate_next_planet()   ; always at least planet 0  (separate to avoid repeat ubyte overflow)
+        repeat system {
+            generate_next_planet()
+            textelite.num_commands++
+        }
+        elite_planet.name = make_current_planet_name()
+        init_market_for_planet()
+    }
+
+    sub init_market_for_planet() {
+        elite_market.init(lsb(seed[0])+msb(seed[2]))
+    }
+
+    sub search_closest_planet(uword nameptr) -> bool {
+        textelite.num_commands++
+
+        ubyte x = elite_planet.x
+        ubyte y = elite_planet.y
+        ubyte current_planet_num = elite_planet.number
+
+        init(number)
+        bool found = false
+        ubyte current_closest_pi
+        ubyte current_distance = 127
+        ubyte pi
+        for pi in 0 to 255 {
+            generate_next_planet()
+            elite_planet.name = make_current_planet_name()
+            if elite_util.prefix_matches(nameptr, elite_planet.name) {
+                ubyte distance = elite_planet.distance(x, y)
+                if distance < current_distance {
+                    current_distance = distance
+                    current_closest_pi = pi
+                    found = true
+                }
+            }
+        }
+
+        if found
+            travel_to(number, current_closest_pi)
+        else
+            travel_to(number, current_planet_num)
+
+        return found
+    }
+
+    sub local_area() {
+        ubyte current_planet = elite_planet.number
+        ubyte px = elite_planet.x
+        ubyte py = elite_planet.y
+        ubyte pn = 0
+
+        init(number)
+;        txt.print("\nGalaxy #")
+;        txt.print_ub(number)
+;        txt.print(" - systems in vicinity:\n")
+        do {
+            generate_next_planet()
+            ubyte distance = elite_planet.distance(px, py)
+            if distance <= elite_ship.Max_fuel {
+;                if distance <= elite_ship.fuel
+;                    txt.chrout('*')
+;                else
+;                    txt.chrout('-')
+;                txt.spc()
+                elite_planet.name = make_current_planet_name()
+                elite_planet.display(true, distance)
+            }
+            pn++
+        } until pn==0
+
+        travel_to(number, current_planet)
+    }
+
+    sub starmap(bool local) {
+        ubyte current_planet = elite_planet.number
+        ubyte px = elite_planet.x
+        ubyte py = elite_planet.y
+        str current_name = "        "       ; 8 max
+        ubyte pn = 0
+
+        current_name = elite_planet.name
+        init(number)
+;        txt.clear_screen()
+;        txt.print("Galaxy #")
+;        txt.print_ub(number)
+;        if local
+;            txt.print(" - local systems")
+;        else
+;            txt.print(" - galaxy")
+;        txt.print(" starmap:\n")
+        ubyte max_distance = 255
+        if local
+            max_distance = elite_ship.Max_fuel
+        ubyte home_sx
+        ubyte home_sy
+        ubyte home_distance
+
+        do {
+            generate_next_planet()
+            ubyte distance = elite_planet.distance(px, py)
+            if distance <= max_distance {
+                elite_planet.name = make_current_planet_name()
+                elite_planet.name[0] = strings.upperchar(elite_planet.name[0])
+                uword tx = elite_planet.x
+                uword ty = elite_planet.y
+                if local {
+                    tx = tx + 24 - px
+                    ty = ty + 24 - py
+                }
+                ubyte sx = display_scale_x(tx)
+                ubyte sy = display_scale_y(ty)
+                ubyte char = '*'
+                if elite_planet.number==current_planet
+                    char = '%'
+                if local {
+                    print_planet_details(elite_planet.name, sx, sy, distance)
+                } else if elite_planet.number==current_planet {
+                    home_distance = distance
+                    home_sx = sx
+                    home_sy = sy
+                }
+                ; txt.setchr(2+sx, 2+sy, char)
+            }
+            pn++
+        } until pn==0
+
+        if not local
+            print_planet_details(current_name, home_sx, home_sy, home_distance)
+
+;        if local
+;            txt.plot(0, display_scale_y(64) + 4)
+;        else
+;            txt.plot(0, display_scale_y(256) + 4 as ubyte)
+        travel_to(number, current_planet)
+
+        sub print_planet_details(str name, ubyte screenx, ubyte screeny, ubyte d) {
+            return
+;            txt.plot(2+screenx-2, 2+screeny+1)
+;            txt.print(name)
+;            if d!=0 {
+;                txt.plot(2+screenx-2, 2+screeny+2)
+;                elite_util.print_10s(d)
+;                txt.print(" LY")
+;            }
+        }
+
+        sub display_scale_x(uword x) -> ubyte {
+            if local
+                return x/2 as ubyte
+            return x/8 as ubyte
+        }
+
+        sub display_scale_y(uword y) -> ubyte {
+            if local
+                return y/4 as ubyte
+            return y/16 as ubyte
+        }
+    }
+
+    ubyte pn_pair1
+    ubyte pn_pair2
+    ubyte pn_pair3
+    ubyte pn_pair4
+    bool longname
+
+    sub generate_next_planet() {
+        determine_planet_properties()
+        longname = lsb(seed[0]) & 64 !=0
+
+        ; Always four iterations of random number
+        pn_pair1 = (msb(seed[2]) & 31) * 2
+        tweakseed()
+        pn_pair2 = (msb(seed[2]) & 31) * 2
+        tweakseed()
+        pn_pair3 = (msb(seed[2]) & 31) * 2
+        tweakseed()
+        pn_pair4 = (msb(seed[2]) & 31) * 2
+        tweakseed()
+    }
+
+    sub make_current_planet_name() -> str {
+        ubyte ni = 0
+        str name = "         "    ; max 8
+
+        if pn_pairs[pn_pair1] != '.' {
+            name[ni] = pn_pairs[pn_pair1]
+            ni++
+        }
+        if pn_pairs[pn_pair1+1] != '.' {
+            name[ni] = pn_pairs[pn_pair1+1]
+            ni++
+        }
+        if pn_pairs[pn_pair2] != '.' {
+            name[ni] = pn_pairs[pn_pair2]
+            ni++
+        }
+        if pn_pairs[pn_pair2+1] != '.' {
+            name[ni] = pn_pairs[pn_pair2+1]
+            ni++
+        }
+        if pn_pairs[pn_pair3] != '.' {
+            name[ni] = pn_pairs[pn_pair3]
+            ni++
+        }
+        if pn_pairs[pn_pair3+1] != '.' {
+            name[ni] = pn_pairs[pn_pair3+1]
+            ni++
+        }
+
+        if longname {
+            if pn_pairs[pn_pair4] != '.' {
+                name[ni] = pn_pairs[pn_pair4]
+                ni++
+            }
+            if pn_pairs[pn_pair4+1] != '.' {
+                name[ni] = pn_pairs[pn_pair4+1]
+                ni++
+            }
+        }
+
+        name[ni] = 0
+        return name
+    }
+
+    sub determine_planet_properties() {
+        ; create the planet's characteristics
+        elite_planet.number++
+        elite_planet.x = msb(seed[1])
+        elite_planet.y = msb(seed[0])
+        elite_planet.govtype = lsb(seed[1]) >> 3 & 7  ; bits 3,4 &5 of w1
+        elite_planet.economy = msb(seed[0]) & 7  ; bits 8,9 &A of w0
+        if elite_planet.govtype <= 1
+            elite_planet.economy = (elite_planet.economy | 2)
+        elite_planet.techlevel = (msb(seed[1]) & 3) + (elite_planet.economy ^ 7)
+        elite_planet.techlevel += elite_planet.govtype >> 1
+        if elite_planet.govtype & 1 !=0
+            elite_planet.techlevel++
+        elite_planet.population = 4 * elite_planet.techlevel + elite_planet.economy
+        elite_planet.population += elite_planet.govtype + 1
+        elite_planet.productivity = ((elite_planet.economy ^ 7) + 3) * (elite_planet.govtype + 4)
+        elite_planet.productivity *= elite_planet.population * 8
+        ubyte seed2_msb = msb(seed[2])
+        elite_planet.radius = mkword((seed2_msb & 15) + 11, elite_planet.x)
+        elite_planet.species_is_alien = lsb(seed[2]) & 128 !=0      ; bit 7 of w2_lo
+        if elite_planet.species_is_alien {
+            elite_planet.species_size = (seed2_msb >> 2) & 7      ; bits 2-4 of w2_hi
+            elite_planet.species_color = seed2_msb >> 5           ; bits 5-7 of w2_hi
+            elite_planet.species_look = (seed2_msb ^ msb(seed[1])) & 7   ;bits 0-2 of (w0_hi EOR w1_hi)
+            elite_planet.species_kind = (elite_planet.species_look + (seed2_msb & 3)) & 7      ;Add bits 0-1 of w2_hi to A from previous step, and take bits 0-2 of the result
+        }
+
+        elite_planet.goatsoup_seed[0] = lsb(seed[1])
+        elite_planet.goatsoup_seed[1] = msb(seed[1])
+        elite_planet.goatsoup_seed[2] = lsb(seed[2])
+        elite_planet.goatsoup_seed[3] = seed2_msb
+    }
+
+    sub tweakseed() {
+        uword temp = seed[0] + seed[1] + seed[2]
+        seed[0] = seed[1]
+        seed[1] = seed[2]
+        seed[2] = temp
+    }
+
+    sub twist(uword x) -> uword {
+        ubyte xh = msb(x)
+        ubyte xl = lsb(x)
+        xh <<= 1        ; make sure carry flag is not used on first shift!
+        rol(xl)
+        return mkword(xh, xl)
+    }
+}
+
+elite_planet {
+    str[] @nosplit words81 = ["fabled", "notable", "well known", "famous", "noted"]
+    str[] @nosplit words82 = ["very", "mildly", "most", "reasonably", ""]
+    str[] @nosplit words83 = ["ancient", "\x95", "great", "vast", "pink"]
+    str[] @nosplit words84 = ["\x9E \x9D plantations", "mountains", "\x9C", "\x94 forests", "oceans"]
+    str[] @nosplit words85 = ["shyness", "silliness", "mating traditions", "loathing of \x86", "love for \x86"]
+    str[] @nosplit words86 = ["food blenders", "tourists", "poetry", "discos", "\x8E"]
+    str[] @nosplit words87 = ["talking tree", "crab", "bat", "lobst", "\xB2"]
+    str[] @nosplit words88 = ["beset", "plagued", "ravaged", "cursed", "scourged"]
+    str[] @nosplit words89 = ["\x96 civil war", "\x9B \x98 \x99s", "a \x9B disease", "\x96 earthquakes", "\x96 solar activity"]
+    str[] @nosplit words8A = ["its \x83 \x84", "the \xB1 \x98 \x99", "its inhabitants' \x9A \x85", "\xA1", "its \x8D \x8E"]
+    str[] @nosplit words8B = ["juice", "brandy", "water", "brew", "gargle blasters"]
+    str[] @nosplit words8C = ["\xB2", "\xB1 \x99", "\xB1 \xB2", "\xB1 \x9B", "\x9B \xB2"]
+    str[] @nosplit words8D = ["fabulous", "exotic", "hoopy", "unusual", "exciting"]
+    str[] @nosplit words8E = ["cuisine", "night life", "casinos", "sit coms", " \xA1 "]
+    str[] @nosplit words8F = ["\xB0", "The planet \xB0", "The world \xB0", "This planet", "This world"]
+    str[] @nosplit words90 = ["n unremarkable", " boring", " dull", " tedious", " revolting"]
+    str[] @nosplit words91 = ["planet", "world", "place", "little planet", "dump"]
+    str[] @nosplit words92 = ["wasp", "moth", "grub", "ant", "\xB2"]
+    str[] @nosplit words93 = ["poet", "arts graduate", "yak", "snail", "slug"]
+    str[] @nosplit words94 = ["tropical", "dense", "rain", "impenetrable", "exuberant"]
+    str[] @nosplit words95 = ["funny", "wierd", "unusual", "strange", "peculiar"]
+    str[] @nosplit words96 = ["frequent", "occasional", "unpredictable", "dreadful", "deadly"]
+    str[] @nosplit words97 = ["\x82 \x81 for \x8A", "\x82 \x81 for \x8A and \x8A", "\x88 by \x89", "\x82 \x81 for \x8A but \x88 by \x89", "a\x90 \x91"]
+    str[] @nosplit words98 = ["\x9B", "mountain", "edible", "tree", "spotted"]
+    str[] @nosplit words99 = ["\x9F", "\xA0", "\x87oid", "\x93", "\x92"]
+    str[] @nosplit words9A = ["ancient", "exceptional", "eccentric", "ingrained", "\x95"]
+    str[] @nosplit words9B = ["killer", "deadly", "evil", "lethal", "vicious"]
+    str[] @nosplit words9C = ["parking meters", "dust clouds", "ice bergs", "rock formations", "volcanoes"]
+    str[] @nosplit words9D = ["plant", "tulip", "banana", "corn", "\xB2weed"]
+    str[] @nosplit words9E = ["\xB2", "\xB1 \xB2", "\xB1 \x9B", "inhabitant", "\xB1 \xB2"]
+    str[] @nosplit words9F = ["shrew", "beast", "bison", "snake", "wolf"]
+    str[] @nosplit wordsA0 = ["leopard", "cat", "monkey", "goat", "fish"]
+    str[] @nosplit wordsA1 = ["\x8C \x8B", "\xB1 \x9F \xA2", "its \x8D \xA0 \xA2", "\xA3 \xA4", "\x8C \x8B"]
+    str[] @nosplit wordsA2 = ["meat", "cutlet", "steak", "burgers", "soup"]
+    str[] @nosplit wordsA3 = ["ice", "mud", "Zero-G", "vacuum", "\xB1 ultra"]
+    str[] @nosplit wordsA4 = ["hockey", "cricket", "karate", "polo", "tennis"]
+
+    uword[] @shared wordlists = [
+        words81, words82, words83, words84, words85, words86, words87, words88,
+        words89, words8A, words8B, words8C, words8D, words8E, words8F, words90,
+        words91, words92, words93, words94, words95, words96, words97, words98,
+        words99, words9A, words9B, words9C, words9D, words9E, words9F, wordsA0,
+        wordsA1, wordsA2, wordsA3, wordsA4]
+
+    str pairs0 = "abouseitiletstonlonuthnoallexegezacebisousesarmaindirea.eratenbe"
+
+    ubyte[4] goatsoup_rnd = [0, 0, 0, 0]
+    ubyte[4] goatsoup_seed = [0, 0, 0, 0]
+
+    str name = "        "       ; 8 max
+    ubyte number                ; starts at 0 in new galaxy, then increases by 1 for each generated planet
+    ubyte x
+    ubyte y
+    ubyte economy
+    ubyte govtype
+    ubyte techlevel
+    ubyte population
+    uword productivity
+    uword radius
+    bool species_is_alien      ; otherwise "Human Colonials"
+    ubyte species_size
+    ubyte species_color
+    ubyte species_look
+    ubyte species_kind
+
+    sub set_seed(uword s1, uword s2) {
+        goatsoup_seed[0] = lsb(s1)
+        goatsoup_seed[1] = msb(s1)
+        goatsoup_seed[2] = lsb(s2)
+        goatsoup_seed[3] = msb(s2)
+        reset_rnd()
+    }
+
+    sub reset_rnd() {
+        goatsoup_rnd[0] = goatsoup_seed[0]
+        goatsoup_rnd[1] = goatsoup_seed[1]
+        goatsoup_rnd[2] = goatsoup_seed[2]
+        goatsoup_rnd[3] = goatsoup_seed[3]
+    }
+
+    sub random_name() -> str {
+        ubyte ii
+        str randname = "        "       ; 8 chars max
+        ubyte nx = 0
+        for ii in 0 to goatsoup_rnd_number() & 3 {
+            ubyte xx = goatsoup_rnd_number() & $3e
+            if pairs0[xx] != '.' {
+                randname[nx] = pairs0[xx]
+                nx++
+            }
+            xx++
+            if pairs0[xx] != '.' {
+                randname[nx] = pairs0[xx]
+                nx++
+            }
+        }
+        randname[nx] = 0
+        randname[0] = strings.upperchar(randname[0])
+        return randname
+    }
+
+    sub goatsoup_rnd_number() -> ubyte {
+        ubyte xx = goatsoup_rnd[0] * 2
+        uword a = xx as uword + goatsoup_rnd[2]
+        if goatsoup_rnd[0] > 127
+            a ++
+        goatsoup_rnd[0] = lsb(a)
+        goatsoup_rnd[2] = xx
+        xx = goatsoup_rnd[1]
+        ubyte ac = xx + goatsoup_rnd[3] + msb(a)
+        goatsoup_rnd[1] = ac
+        goatsoup_rnd[3] = xx
+        return ac
+    }
+
+    sub distance(ubyte px, ubyte py) -> ubyte {
+        uword ax
+        uword ay
+        if px>x
+            ax=px-x
+        else
+            ax=x-px
+        if py>y
+            ay=py-y
+        else
+            ay=y-py
+        ay /= 2
+        ubyte d = sqrt(ax*ax + ay*ay)
+        if d>63
+            return 255
+        return d*4
+    }
+
+    sub soup() -> str {
+        str planet_result = " " * 160
+        uword[6] source_stack
+        ubyte stack_ptr = 0
+        str start_source = "\x8F is \x97."
+        uword source_ptr = &start_source
+        uword result_ptr = &planet_result
+
+        reset_rnd()
+        recursive_soup()
+        return planet_result
+
+        sub recursive_soup() {
+            repeat {
+                ubyte c = @(source_ptr)
+                source_ptr++
+                if c == $00 {
+                    @(result_ptr) = 0
+                    return
+                }
+                else if c <= $80 {
+                    @(result_ptr) = c
+                    result_ptr++
+                }
+                else {
+                    if c <= $a4 {
+                        ubyte rnr = goatsoup_rnd_number()
+                        ubyte wordNr = ((rnr >= $33) as ubyte) + ((rnr >= $66) as ubyte) + ((rnr >= $99) as ubyte) + ((rnr >= $CC) as ubyte)
+                        source_stack[stack_ptr] = source_ptr
+                        stack_ptr++
+                        source_ptr = getword(c, wordNr)
+                        recursive_soup()    ; RECURSIVE CALL - ignore the warning message from the compiler; we don't use local variables or parameters so we're safe in this case
+                        stack_ptr--
+                        source_ptr = source_stack[stack_ptr]
+                    } else {
+                        if c == $b0 {
+                            @(result_ptr) = strings.upperchar(name[0])
+                            result_ptr++
+                            concat_string(&name + 1)
+                        }
+                        else if c == $b1 {
+                            @(result_ptr) = strings.upperchar(name[0])
+                            result_ptr++
+                            ubyte ni
+                            for ni in 1 to len(name) {
+                                ubyte cc = name[ni]
+                                if cc in ['e', 'o', 0]
+                                    break
+                                else {
+                                    @(result_ptr) = cc
+                                    result_ptr++
+                                }
+                            }
+                            @(result_ptr) = 'i'
+                            result_ptr++
+                            @(result_ptr) = 'a'
+                            result_ptr++
+                            @(result_ptr) = 'n'
+                            result_ptr++
+                        }
+                        else if c == $b2 {
+                            concat_string(random_name())
+                        }
+                        else {
+                            @(result_ptr) = c
+                            result_ptr++
+                        }
+                    }
+                }
+            }
+        }
+
+        sub concat_string(uword str_ptr) {
+            repeat {
+                ubyte c = @(str_ptr)
+                if c==0
+                    break
+                else {
+                    @(result_ptr) = c
+                    str_ptr++
+                    result_ptr++
+                }
+            }
+        }
+    }
+
+    sub display(bool compressed, ubyte distance) {
+        txt.print(soup())
+        txt.nl()
+    }
+
+    sub getword(ubyte listnum, ubyte wordidx) -> uword {
+        uword list = wordlists[listnum-$81]
+        return peekw(list + wordidx*2)
+    }
+}
+
+elite_util {
+    sub prefix_matches(uword prefixptr, uword stringptr) -> bool {
+        repeat {
+            ubyte pc = @(prefixptr)
+            ubyte sc = @(stringptr)
+            if pc == 0
+                return true
+            ; to lowercase for case insensitive compare:
+            if strings.lowerchar(pc)!=strings.lowerchar(sc)
+                return false
+            prefixptr++
+            stringptr++
+        }
+    }
+}

benchmark-program/benchmark.p8

@@ -0,0 +1,117 @@
+
+;  This benchmark program is meant to check for regressions in the
+;  Prog8 compiler's code-generator (performance wise).
+;
+;  As the X16 computer is a more or less fixed system, it's not very useful
+;  to benchmark the computer itself with.
+
+
+%import textio
+%import b_adpcm
+%import b_circles
+%import b_3d
+%import b_life
+%import b_mandelbrot
+%import b_queens
+%import b_textelite
+%import b_maze
+%import b_sprites
+
+%zeropage basicsafe
+%option no_sysinit
+
+
+main {
+
+    str[20] benchmark_names
+    uword[20] benchmark_score
+
+
+    sub start() {
+        ubyte benchmark_number
+
+        cx16.set_screen_mode(3)
+        txt.color2(1, 6)
+        txt.clear_screen()
+
+        txt.print("\n\n\n  prog8 compiler benchmark tests.\n")
+        sys.wait(60)
+
+        benchmark_number = 0
+
+        announce_benchmark("maze solver")
+        benchmark_score[benchmark_number]  = maze.bench(300)
+        benchmark_number++
+
+        announce_benchmark("n-queens")
+        benchmark_score[benchmark_number]  = queens.bench(300)
+        benchmark_number++
+
+        announce_benchmark("mandelbrot (floating point)")
+        benchmark_score[benchmark_number]  = mandelbrot.calc(400)
+        benchmark_number++
+
+        announce_benchmark("game of life")
+        benchmark_score[benchmark_number]  = life.benchmark(300)
+        benchmark_number++
+
+        announce_benchmark("3d model rotation")
+        benchmark_score[benchmark_number]  = rotate3d.benchmark(300)
+        benchmark_number++
+
+        announce_benchmark("adpcm audio decoding")
+        benchmark_score[benchmark_number]  = adpcm.decode_benchmark(300)
+        benchmark_number++
+
+        announce_benchmark("circles with gfx_lores")
+        benchmark_score[benchmark_number]  = circles.draw(false, 300)
+        benchmark_number++
+
+;        announce_benchmark("circles with kernal")
+;        benchmark_score[benchmark_number]  = circles.draw(true, 300)
+;        benchmark_number++
+
+        announce_benchmark("text-elite")
+        benchmark_score[benchmark_number]  = textelite.bench(120)
+        benchmark_number++
+
+        announce_benchmark("sprites-coroutines-defer")
+        benchmark_score[benchmark_number]  = animsprites.benchmark(300)
+        benchmark_number++
+
+        benchmark_names[benchmark_number] = 0
+        benchmark_score[benchmark_number] = 0
+
+        cx16.set_screen_mode(3)
+        txt.uppercase()
+        txt.color2(1, 6)
+        uword final_score
+        benchmark_number = 0
+        txt.print("\nscore benchmark\n\n")
+        do {
+            txt.spc()
+            txt.print_uw(benchmark_score[benchmark_number])
+            txt.column(6)
+            txt.print(benchmark_names[benchmark_number])
+            final_score += benchmark_score[benchmark_number]
+            txt.nl()
+            benchmark_number++
+        } until benchmark_names[benchmark_number]==0
+
+        txt.print("\n\nfinal score : ")
+        txt.print_uw(final_score)
+        txt.nl()
+
+        sub announce_benchmark(str name) {
+            benchmark_names[benchmark_number] = name
+            cx16.set_screen_mode(3)
+            txt.uppercase()
+            txt.color2(1, 6)
+            txt.clear_screen()
+            txt.plot(4, 6)
+            txt.print(benchmark_names[benchmark_number])
+            txt.nl()
+            sys.wait(60)
+        }
+    }
+}

build.gradle

@@ -1,10 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.jvm" version "$kotlinVersion" apply false
-}
-
-allprojects {
-    repositories {
-        mavenLocal()
-        mavenCentral()
-    }
-}

build.gradle.kts

@@ -0,0 +1,34 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.internal.config.LanguageFeature
+
+
+plugins {
+    kotlin("jvm") version "2.1.20"
+}
+
+allprojects {
+    apply(plugin="kotlin")
+
+    repositories {
+        mavenLocal()
+        mavenCentral()
+    }
+
+    kotlin {
+        compilerOptions {
+            freeCompilerArgs = listOf("-Xwhen-guards")
+            jvmTarget = JvmTarget.JVM_11
+        }
+        sourceSets.all {
+            languageSettings {
+                // enable language features like so:
+                // enableLanguageFeature(LanguageFeature.WhenGuards.name)
+            }
+        }
+    }
+
+    java {
+        targetCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_11
+    }
+}

codeCore/build.gradle

@@ -1,43 +0,0 @@
-
-plugins {
-    id 'java'
-    id 'application'
-    id "org.jetbrains.kotlin.jvm"
-}
-
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(javaVersion)
-    }
-}
-
-compileKotlin {
-    kotlinOptions {
-        jvmTarget = javaVersion
-    }
-}
-
-compileTestKotlin {
-    kotlinOptions {
-        jvmTarget = javaVersion
-    }
-}
-
-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.18"
-}
-
-sourceSets {
-    main {
-        java {
-            srcDir "${project.projectDir}/src"
-        }
-        resources {
-            srcDir "${project.projectDir}/res"
-        }
-    }
-}
-
-// note: there are no unit tests in this module!

codeCore/build.gradle.kts

@@ -0,0 +1,24 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    kotlin("jvm")
+}
+
+dependencies {
+    // should have no dependencies to other modules
+    // implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
+    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.1")
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir("${project.projectDir}/src")
+        }
+        resources {
+            srcDir("${project.projectDir}/res")
+        }
+    }
+}
+
+// note: there are no unit tests in this module!

codeCore/src/prog8/code/Globals.kt

@@ -0,0 +1,31 @@
+package prog8.code
+
+import java.io.IOException
+import java.nio.file.Path
+import kotlin.io.path.absolute
+
+
+// the automatically generated module where all string literals are interned to:
+const val INTERNED_STRINGS_MODULENAME = "prog8_interned_strings"
+
+// all automatically generated labels everywhere need to have the same label name prefix:
+const val GENERATED_LABEL_PREFIX = "p8_label_gen_"
+
+
+/**
+ * Returns the absolute path of the given path,
+ * where links are replaced by the actual directories,
+ * and containing no redundant path elements.
+ * If the path doesn't refer to an existing directory or file on the file system,
+ * it is returned unchanged.
+ */
+fun Path.sanitize(): Path {
+    return try {
+        this.toRealPath().normalize()
+    } catch (_: java.nio.file.NoSuchFileException) {
+        this.absolute().normalize()
+        //throw NoSuchFileException(this.toFile(), null, nx.reason).also { it.initCause(nx) }
+    } catch (iox: IOException) {
+        throw FileSystemException(this.toFile()).also { it.initCause(iox) }
+    }
+}

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

@@ -1,171 +0,0 @@
-package prog8.code.ast
-
-import prog8.code.core.*
-
-
-sealed interface IPtSubroutine {
-    val name: String
-}
-
-class PtAsmSub(
-    name: String,
-    val address: UInt?,
-    val clobbers: Set<CpuRegister>,
-    val parameters: List<Pair<RegisterOrStatusflag, PtSubroutineParameter>>,
-    val returns: List<Pair<RegisterOrStatusflag, DataType>>,
-    val inline: Boolean,
-    position: Position
-) : PtNamedNode(name, position), IPtSubroutine
-
-
-class PtSub(
-    name: String,
-    val parameters: List<PtSubroutineParameter>,
-    val returntype: DataType?,
-    position: Position
-) : PtNamedNode(name, position), IPtSubroutine, IPtStatementContainer {
-    init {
-        // params and return value should not be str
-        if(parameters.any{ it.type !in NumericDatatypes })
-            throw AssemblyError("non-numeric parameter")
-        if(returntype!=null && returntype !in NumericDatatypes)
-            throw AssemblyError("non-numeric returntype $returntype")
-        parameters.forEach { it.parent=this }
-    }
-}
-
-
-class PtSubroutineParameter(name: String, val type: DataType, position: Position): PtNamedNode(name, position)
-
-
-sealed interface IPtAssignment {
-    val children: MutableList<PtNode>
-    val target: PtAssignTarget
-        get() = children[0] as PtAssignTarget
-    val value: PtExpression
-        get() = children[1] as PtExpression
-}
-
-class PtAssignment(position: Position) : PtNode(position), IPtAssignment
-
-class PtAugmentedAssign(val operator: String, position: Position) : PtNode(position), IPtAssignment
-
-
-class PtAssignTarget(position: Position) : PtNode(position) {
-    val identifier: PtIdentifier?
-        get() = children.single() as? PtIdentifier
-    val array: PtArrayIndexer?
-        get() = children.single() as? PtArrayIndexer
-    val memory: PtMemoryByte?
-        get() = children.single() as? PtMemoryByte
-
-    val type: DataType
-        get() {
-            return when(val tgt = children.single()) {
-                is PtIdentifier -> tgt.type
-                is PtArrayIndexer -> tgt.type
-                is PtMemoryByte -> tgt.type
-                else -> throw AssemblyError("weird target $tgt")
-            }
-        }
-
-    infix fun isSameAs(expression: PtExpression): Boolean = expression.isSameAs(this)
-}
-
-
-class PtConditionalBranch(val condition: BranchCondition, position: Position) : PtNode(position) {
-    val trueScope: PtNodeGroup
-        get() = children[0] as PtNodeGroup
-    val falseScope: PtNodeGroup
-        get() = children[1] as PtNodeGroup
-}
-
-
-class PtForLoop(position: Position) : PtNode(position) {
-    val variable: PtIdentifier
-        get() = children[0] as PtIdentifier
-    val iterable: PtExpression
-        get() = children[1] as PtExpression
-    val statements: PtNodeGroup
-        get() = children[2] as PtNodeGroup
-}
-
-
-class PtIfElse(position: Position) : PtNode(position) {
-    val condition: PtExpression
-        get() = children[0] as PtExpression
-    val ifScope: PtNodeGroup
-        get() = children[1] as PtNodeGroup
-    val elseScope: PtNodeGroup
-        get() = children[2] as PtNodeGroup
-}
-
-
-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?,
-             position: Position) : PtNode(position) {
-    init {
-        identifier?.let {it.parent = this }
-    }
-}
-
-
-class PtPostIncrDecr(val operator: String, position: Position) : PtNode(position) {
-    val target: PtAssignTarget
-        get() = children.single() as PtAssignTarget
-}
-
-
-class PtRepeatLoop(position: Position) : PtNode(position) {
-    val count: PtExpression
-        get() = children[0] as PtExpression
-    val statements: PtNodeGroup
-        get() = children[1] as PtNodeGroup
-}
-
-
-class PtReturn(position: Position) : PtNode(position) {
-    val hasValue = children.any()
-    val value: PtExpression?
-        get() {
-            return if(children.any())
-                children.single() as PtExpression
-            else
-                null
-        }
-}
-
-
-sealed interface IPtVariable {
-    val name: String
-    val type: DataType
-}
-
-
-class PtVariable(name: String, override val type: DataType, val zeropage: ZeropageWish, val value: PtExpression?, val arraySize: UInt?, position: Position) : PtNamedNode(name, position), IPtVariable {
-    init {
-        value?.let {it.parent=this}
-    }
-}
-
-
-class PtConstant(name: String, override val type: DataType, val value: Double, position: Position) : PtNamedNode(name, position), IPtVariable
-
-
-class PtMemMapped(name: String, override val type: DataType, val address: UInt, val arraySize: UInt?, position: Position) : PtNamedNode(name, position), IPtVariable
-
-
-class PtWhen(position: Position) : PtNode(position) {
-    val value: PtExpression
-        get() = children[0] as PtExpression
-    val choices: PtNodeGroup
-        get() = children[1] as PtNodeGroup
-}
-
-
-class PtWhenChoice(val isElse: Boolean, position: Position) : PtNode(position) {
-    val values: PtNodeGroup
-        get() = children[0] as PtNodeGroup
-    val statements: PtNodeGroup
-        get() = children[1] as PtNodeGroup
-}

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

@@ -1,7 +1,7 @@
 package prog8.code.core
 
-class ReturnConvention(val dt: DataType?, val reg: RegisterOrPair?, val floatFac1: Boolean)
-class ParamConvention(val dt: DataType, val reg: RegisterOrPair?, val variable: Boolean)
+class ReturnConvention(val dt: BaseDataType?, val reg: RegisterOrPair?)
+class ParamConvention(val dt: BaseDataType, val reg: RegisterOrPair?, val variable: Boolean)
 class CallConvention(val params: List<ParamConvention>, val returns: ReturnConvention) {
     override fun toString(): String {
         val paramConvs =  params.mapIndexed { index, it ->
@@ -13,35 +13,41 @@ class CallConvention(val params: List<ParamConvention>, val returns: ReturnConve
         }
         val returnConv =
             when {
-                returns.reg!=null -> returns.reg.toString()
-                returns.floatFac1 -> "floatFAC1"
+                returns.reg == RegisterOrPair.FAC1 -> "floatFAC1"
+                returns.reg != null -> returns.reg.toString()
                 else -> "<no returnvalue>"
             }
         return "CallConvention[" + paramConvs.joinToString() + " ; returns: $returnConv]"
     }
 }
 
-class FParam(val name: String, val possibleDatatypes: Array<DataType>)
+class FParam(val name: String, vararg val possibleDatatypes: BaseDataType)
+
+
+private val IterableDatatypes = arrayOf(BaseDataType.STR, BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW)
+private val IntegerDatatypes = arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)
+private val NumericDatatypes = arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
+
 
 class FSignature(val pure: Boolean,      // does it have side effects?
-                      val parameters: List<FParam>,
-                      val returnType: DataType?) {
+                 val returnType: BaseDataType?,
+                 vararg val parameters: FParam) {
 
-    fun callConvention(actualParamTypes: List<DataType>): CallConvention {
+    fun callConvention(actualParamTypes: List<BaseDataType>): CallConvention {
         val returns: ReturnConvention = when (returnType) {
-            DataType.UBYTE, DataType.BYTE -> ReturnConvention(returnType, RegisterOrPair.A, false)
-            DataType.UWORD, DataType.WORD -> ReturnConvention(returnType, RegisterOrPair.AY, false)
-            DataType.FLOAT -> ReturnConvention(returnType, null, true)
-            in PassByReferenceDatatypes -> ReturnConvention(returnType!!, RegisterOrPair.AY, false)
-            null -> ReturnConvention(null, null, false)
+            BaseDataType.UBYTE, BaseDataType.BYTE -> ReturnConvention(returnType, RegisterOrPair.A)
+            BaseDataType.UWORD, BaseDataType.WORD -> ReturnConvention(returnType, RegisterOrPair.AY)
+            BaseDataType.FLOAT -> ReturnConvention(returnType, RegisterOrPair.FAC1)
+            in IterableDatatypes -> ReturnConvention(returnType!!, RegisterOrPair.AY)
+            null -> ReturnConvention(null, null)
             else -> {
                 // return type depends on arg type
                 when (val paramType = actualParamTypes.first()) {
-                    DataType.UBYTE, DataType.BYTE -> ReturnConvention(paramType, RegisterOrPair.A, false)
-                    DataType.UWORD, DataType.WORD -> ReturnConvention(paramType, RegisterOrPair.AY, false)
-                    DataType.FLOAT -> ReturnConvention(paramType, null, true)
-                    in PassByReferenceDatatypes -> ReturnConvention(paramType, RegisterOrPair.AY, false)
-                    else -> ReturnConvention(paramType, null, false)
+                    BaseDataType.UBYTE, BaseDataType.BYTE -> ReturnConvention(paramType, RegisterOrPair.A)
+                    BaseDataType.UWORD, BaseDataType.WORD -> ReturnConvention(paramType, RegisterOrPair.AY)
+                    BaseDataType.FLOAT -> ReturnConvention(paramType, RegisterOrPair.FAC1)
+                    in IterableDatatypes -> ReturnConvention(paramType, RegisterOrPair.AY)
+                    else -> ReturnConvention(paramType, null)
                 }
             }
         }
@@ -49,16 +55,27 @@ class FSignature(val pure: Boolean,      // does it have side effects?
         return when {
             actualParamTypes.isEmpty() -> CallConvention(emptyList(), returns)
             actualParamTypes.size==1 -> {
-                // one parameter goes via register/registerpair
+                // One parameter goes via register/registerpair.
+                // this avoids repeated code for every caller to store the value in the subroutine's argument variable.
+                // (that store is still done, but only coded once at the start at the subroutine itself rather than at every call site).
                 val paramConv = when(val paramType = actualParamTypes[0]) {
-                    DataType.UBYTE, DataType.BYTE -> ParamConvention(paramType, RegisterOrPair.A, false)
-                    DataType.UWORD, DataType.WORD -> ParamConvention(paramType, RegisterOrPair.AY, false)
-                    DataType.FLOAT -> ParamConvention(paramType, RegisterOrPair.AY, false)
-                    in PassByReferenceDatatypes -> ParamConvention(paramType, RegisterOrPair.AY, false)
+                    BaseDataType.UBYTE, BaseDataType.BYTE -> ParamConvention(paramType, RegisterOrPair.A, false)
+                    BaseDataType.UWORD, BaseDataType.WORD -> ParamConvention(paramType, RegisterOrPair.AY, false)
+                    BaseDataType.FLOAT -> ParamConvention(paramType, RegisterOrPair.AY, false)      // NOTE: for builtin functions, floating point arguments are passed by reference (so you get a pointer in AY)
+                    in IterableDatatypes -> ParamConvention(paramType, RegisterOrPair.AY, false)
                     else -> ParamConvention(paramType, null, false)
                 }
                 CallConvention(listOf(paramConv), returns)
             }
+            actualParamTypes.size==2 && (actualParamTypes[0].isByte && actualParamTypes[1].isWord) -> {
+                TODO("opportunity to pass word+byte arguments in A,Y and X registers but not implemented yet")
+            }
+            actualParamTypes.size==2 && (actualParamTypes[0].isWord && actualParamTypes[1].isByte) -> {
+                TODO("opportunity to pass word+byte arguments in A,Y and X registers but not implemented yet")
+            }
+            actualParamTypes.size==3 && actualParamTypes.all { it.isByte } -> {
+                TODO("opportunity to pass 3 byte arguments in A,Y and X registers but not implemented yet")
+            }
             else -> {
                 // multiple parameters go via variables
                 val paramConvs = actualParamTypes.map { ParamConvention(it, null, true) }
@@ -69,67 +86,67 @@ 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),
-    "ror2"      to FSignature(false, listOf(FParam("item", arrayOf(DataType.UBYTE, DataType.UWORD))), null),
-    "sort"      to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
-    "reverse"   to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
-    // cmp returns a status in the carry flag, but not a proper return value
-    "cmp"       to FSignature(false, listOf(FParam("value1", IntegerDatatypesNoBool), FParam("value2", NumericDatatypesNoBool)), null),
-    "prog8_lib_stringcompare"     to FSignature(true, listOf(FParam("str1", arrayOf(DataType.STR)), FParam("str2", arrayOf(DataType.STR))), DataType.BYTE),
-    "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.entries.toTypedArray())), DataType.UBYTE),
-    "sgn"       to FSignature(true, listOf(FParam("value", NumericDatatypesNoBool)), DataType.BYTE),
-    "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),
-    "pokew"     to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UWORD))), null),
-    "pokef"     to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.FLOAT))), null),
-    "pokemon"   to FSignature(false, listOf(FParam("address", arrayOf(DataType.UWORD)), FParam("value", arrayOf(DataType.UBYTE))), DataType.UBYTE),
-    "rsave"     to FSignature(false, emptyList(), null),
-    "rrestore"  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),
+    "setlsb"  to FSignature(false, null, FParam("variable", BaseDataType.WORD, BaseDataType.UWORD), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
+    "setmsb"  to FSignature(false, null, FParam("variable", BaseDataType.WORD, BaseDataType.UWORD), FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
+    "rol"     to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
+    "ror"     to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
+    "rol2"    to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
+    "ror2"    to FSignature(false, null, FParam("item", BaseDataType.UBYTE, BaseDataType.UWORD)),
+    "cmp"     to FSignature(false, null, FParam("value1", *IntegerDatatypes), FParam("value2", *NumericDatatypes)),  // cmp returns a status in the carry flag, but not a proper return value
+    "prog8_lib_stringcompare"     to FSignature(true, BaseDataType.BYTE, FParam("str1", BaseDataType.STR), FParam("str2", BaseDataType.STR)),
+    "prog8_lib_square_byte"       to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.BYTE, BaseDataType.UBYTE)),
+    "prog8_lib_square_word"       to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.WORD, BaseDataType.UWORD)),
+    "abs"           to FSignature(true, null, FParam("value", *NumericDatatypes)),
+    "abs__byte"     to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.BYTE)),
+    "abs__word"     to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.WORD)),
+    "abs__float"    to FSignature(true, BaseDataType.FLOAT, FParam("value", BaseDataType.FLOAT)),
+    "len"           to FSignature(true, BaseDataType.UWORD, FParam("values", *IterableDatatypes)),
+    "sizeof"        to FSignature(true, BaseDataType.UBYTE, FParam("object", *BaseDataType.entries.toTypedArray())),
+    "sgn"           to FSignature(true, BaseDataType.BYTE, FParam("value", *NumericDatatypes)),
+    "sqrt"          to FSignature(true, null, FParam("value", *NumericDatatypes)),
+    "sqrt__ubyte"   to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UBYTE)),
+    "sqrt__uword"   to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UWORD)),
+    "sqrt__float"   to FSignature(true, BaseDataType.FLOAT, FParam("value", BaseDataType.FLOAT)),
+    "divmod"        to FSignature(false, null, FParam("dividend", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("divisor", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("quotient", BaseDataType.UBYTE, BaseDataType.UWORD), FParam("remainder", BaseDataType.UBYTE, BaseDataType.UWORD)),
+    "divmod__ubyte" to FSignature(false, null, FParam("dividend", BaseDataType.UBYTE), FParam("divisor", BaseDataType.UBYTE), FParam("quotient", BaseDataType.UBYTE), FParam("remainder", BaseDataType.UBYTE)),
+    "divmod__uword" to FSignature(false, null, FParam("dividend", BaseDataType.UWORD), FParam("divisor", BaseDataType.UWORD), FParam("quotient", BaseDataType.UWORD), FParam("remainder", BaseDataType.UWORD)),
+    "lsb"           to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "lsw"           to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "msb"           to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "msw"           to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)),
+    "mkword"        to FSignature(true, BaseDataType.UWORD, FParam("msb", BaseDataType.UBYTE), FParam("lsb", BaseDataType.UBYTE)),
+    "clamp"         to FSignature(true, null, FParam("value", BaseDataType.BYTE), FParam("minimum", BaseDataType.BYTE), FParam("maximum", BaseDataType.BYTE)),
+    "clamp__byte"   to FSignature(true, BaseDataType.BYTE, FParam("value", BaseDataType.BYTE), FParam("minimum", BaseDataType.BYTE), FParam("maximum", BaseDataType.BYTE)),
+    "clamp__ubyte"  to FSignature(true, BaseDataType.UBYTE, FParam("value", BaseDataType.UBYTE), FParam("minimum", BaseDataType.UBYTE), FParam("maximum", BaseDataType.UBYTE)),
+    "clamp__word"   to FSignature(true, BaseDataType.WORD, FParam("value", BaseDataType.WORD), FParam("minimum", BaseDataType.WORD), FParam("maximum", BaseDataType.WORD)),
+    "clamp__uword"  to FSignature(true, BaseDataType.UWORD, FParam("value", BaseDataType.UWORD), FParam("minimum", BaseDataType.UWORD), FParam("maximum", BaseDataType.UWORD)),
+    "min"           to FSignature(true, null, FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
+    "min__byte"     to FSignature(true, BaseDataType.BYTE, FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
+    "min__ubyte"    to FSignature(true, BaseDataType.UBYTE, FParam("val1", BaseDataType.UBYTE), FParam("val2", BaseDataType.UBYTE)),
+    "min__word"     to FSignature(true, BaseDataType.WORD, FParam("val1", BaseDataType.WORD), FParam("val2", BaseDataType.WORD)),
+    "min__uword"    to FSignature(true, BaseDataType.UWORD, FParam("val1", BaseDataType.UWORD), FParam("val2", BaseDataType.UWORD)),
+    "max"           to FSignature(true, null, FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
+    "max__byte"     to FSignature(true, BaseDataType.BYTE, FParam("val1", BaseDataType.BYTE), FParam("val2", BaseDataType.BYTE)),
+    "max__ubyte"    to FSignature(true, BaseDataType.UBYTE, FParam("val1", BaseDataType.UBYTE), FParam("val2", BaseDataType.UBYTE)),
+    "max__word"     to FSignature(true, BaseDataType.WORD, FParam("val1", BaseDataType.WORD), FParam("val2", BaseDataType.WORD)),
+    "max__uword"    to FSignature(true, BaseDataType.UWORD, FParam("val1", BaseDataType.UWORD), FParam("val2", BaseDataType.UWORD)),
+    "peek"          to FSignature(true, BaseDataType.UBYTE, FParam("address", BaseDataType.UWORD)),
+    "peekw"         to FSignature(true, BaseDataType.UWORD, FParam("address", BaseDataType.UWORD)),
+    "peekf"         to FSignature(true, BaseDataType.FLOAT, FParam("address", BaseDataType.UWORD)),
+    "poke"          to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UBYTE)),
+    "pokew"         to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UWORD)),
+    "pokef"         to FSignature(false, null, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.FLOAT)),
+    "pokemon"       to FSignature(false, BaseDataType.UBYTE, FParam("address", BaseDataType.UWORD), FParam("value", BaseDataType.UBYTE)),
+    "rsave"         to FSignature(false, null),
+    "rrestore"      to FSignature(false, null),
+    "memory"        to FSignature(true, BaseDataType.UWORD, FParam("name", BaseDataType.STR), FParam("size", BaseDataType.UWORD), FParam("alignment", BaseDataType.UWORD)),
+    "callfar"       to FSignature(false, BaseDataType.UWORD, FParam("bank", BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD), FParam("arg", BaseDataType.UWORD)),
+    "callfar2"      to FSignature(false, BaseDataType.UWORD, FParam("bank", BaseDataType.UBYTE), FParam("address", BaseDataType.UWORD), FParam("argA", BaseDataType.UBYTE), FParam("argX", BaseDataType.UBYTE), FParam("argY", BaseDataType.UBYTE), FParam("argC", BaseDataType.BOOL)),
+    "call"          to FSignature(false, BaseDataType.UWORD, FParam("address", BaseDataType.UWORD)),
 )
 
-val InplaceModifyingBuiltinFunctions = setOf("setlsb", "setmsb", "rol", "ror", "rol2", "ror2", "sort", "reverse")
+val InplaceModifyingBuiltinFunctions = setOf(
+    "setlsb", "setmsb",
+    "rol", "ror", "rol2", "ror2",
+    "divmod", "divmod__ubyte", "divmod__uword"
+)

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

@@ -11,26 +11,32 @@ class CompilationOptions(val output: OutputType,
                          val zpAllowed: List<UIntRange>,
                          val floats: Boolean,
                          val noSysInit: Boolean,
+                         val romable: Boolean,
                          val compTarget: ICompilationTarget,
                          // these are set later, based on command line arguments or options in the source code:
                          var loadAddress: UInt,
+                         var memtopAddress: UInt,
                          var warnSymbolShadowing: Boolean = false,
                          var optimize: Boolean = false,
                          var asmQuiet: Boolean = false,
                          var asmListfile: Boolean = false,
                          var includeSourcelines: Boolean = false,
+                         var dumpVariables: Boolean = false,
+                         var dumpSymbols: Boolean = false,
                          var experimentalCodegen: Boolean = false,
                          var varsHighBank: Int? = null,
                          var varsGolden: Boolean = false,
                          var slabsHighBank: Int? = null,
                          var slabsGolden: Boolean = false,
-                         var splitWordArrays: Boolean = false,
+                         var dontSplitWordArrays: Boolean = false,
                          var breakpointCpuInstruction: String? = null,
+                         var ignoreFootguns: Boolean = false,
                          var outputDir: Path = Path(""),
+                         var quiet: Boolean = false,
                          var symbolDefs: Map<String, String> = emptyMap()
 ) {
     init {
-        compTarget.machine.initializeMemoryAreas(this)
+        compTarget.initializeMemoryAreas(this)
     }
 
     companion object {

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

@@ -1,11 +1,17 @@
 package prog8.code.core
 
 import kotlin.math.abs
+import kotlin.math.pow
+
+val powersOfTwoFloat = (0..16).map { (2.0).pow(it) }.toTypedArray()
+val negativePowersOfTwoFloat = powersOfTwoFloat.map { -it }.toTypedArray()
+val powersOfTwoInt = (0..16).map { 2.0.pow(it).toInt() }.toTypedArray()
 
 fun Number.toHex(): String {
     //  0..15 -> "0".."15"
     //  16..255 -> "$10".."$ff"
     //  256..65536 -> "$0100".."$ffff"
+    //  larger -> "$12345678"
     // negative values are prefixed with '-'.
     val integer = this.toInt()
     if(integer<0)
@@ -14,7 +20,7 @@ fun Number.toHex(): String {
         in 0 until 16 -> integer.toString()
         in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0')
         in 0 until 0x10000 -> "$"+integer.toString(16).padStart(4,'0')
-        else -> throw IllegalArgumentException("number too large for 16 bits $this")
+        else -> "$"+integer.toString(16).padStart(8,'0')
     }
 }
 
@@ -22,11 +28,12 @@ fun UInt.toHex(): String {
     //  0..15 -> "0".."15"
     //  16..255 -> "$10".."$ff"
     //  256..65536 -> "$0100".."$ffff"
+    //  larger -> "$12345678"
     return when (this) {
         in 0u until 16u -> this.toString()
         in 0u until 0x100u -> "$"+this.toString(16).padStart(2,'0')
         in 0u until 0x10000u -> "$"+this.toString(16).padStart(4,'0')
-        else -> throw IllegalArgumentException("number too large for 16 bits $this")
+        else -> "$"+this.toString(16).padStart(8,'0')
     }
 }
 
@@ -58,6 +65,7 @@ fun String.unescape(): String {
                 '\\' -> '\\'
                 'n' -> '\n'
                 'r' -> '\r'
+                't' -> '\t'
                 '"' -> '"'
                 '\'' -> '\''
                 'u' -> {

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

@@ -1,63 +1,241 @@
 package prog8.code.core
 
-enum class DataType {
+import java.util.*
+
+enum class BaseDataType {
     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
+    BOOL,               // pass by value            bit 0 of an 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
+    ARRAY,              // pass by reference, subtype is the element type
+    ARRAY_SPLITW,       // pass by reference, split word layout, subtype is the element type (restricted to word types)
     UNDEFINED;
 
-    /**
-     * is the type assignable to the given other type (perhaps via a typecast) without loss of precision?
-     */
-    infix fun isAssignableTo(targetType: DataType) =
-        when(this) {
-            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
-            else -> false
-        }
 
-    fun oneOf(vararg types: DataType) = this in types
-
-    infix fun largerThan(other: DataType) =
+    fun largerSizeThan(other: BaseDataType) =
         when {
             this == other -> false
-            this in ByteDatatypes -> false
-            this in WordDatatypes -> other in ByteDatatypes
-            this == LONG -> other in ByteDatatypes+WordDatatypes
+            this.isByteOrBool -> false
+            this.isWord -> other.isByteOrBool
+            this == LONG -> other.isByteOrBool || other.isWord
             this == STR && other == UWORD || this == UWORD && other == STR -> false
+            this.isArray && other.isArray -> false
+            this.isArray -> other != FLOAT
+            this == STR -> other != FLOAT
             else -> true
         }
 
-    infix fun equalsSize(other: DataType) =
+    fun equalsSize(other: BaseDataType) =
         when {
             this == other -> true
-            this in ByteDatatypes -> other in ByteDatatypes
-            this in WordDatatypes -> other in WordDatatypes
-            this== STR && other== UWORD || this== UWORD && other== STR -> true
+            this.isArray && other.isArray -> true
+            this.isByteOrBool -> other.isByteOrBool
+            this.isWord -> other.isWord
+            this == STR && other== UWORD || this== UWORD && other== STR -> true
+            this == STR && other.isArray -> true
+            this.isArray && other == STR -> true
             else -> false
         }
 }
 
+val BaseDataType.isByte get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE)
+val BaseDataType.isByteOrBool get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.BOOL)
+val BaseDataType.isWord get() = this in arrayOf(BaseDataType.UWORD, BaseDataType.WORD)
+val BaseDataType.isInteger get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG)
+val BaseDataType.isIntegerOrBool get() = this in arrayOf(BaseDataType.UBYTE, BaseDataType.BYTE, BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.BOOL)
+val BaseDataType.isNumeric get() = this == BaseDataType.FLOAT || this.isInteger
+val BaseDataType.isNumericOrBool get() = this == BaseDataType.BOOL || this.isNumeric
+val BaseDataType.isSigned get() = this in arrayOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
+val BaseDataType.isArray get() = this == BaseDataType.ARRAY || this == BaseDataType.ARRAY_SPLITW
+val BaseDataType.isSplitWordArray get() = this == BaseDataType.ARRAY_SPLITW
+val BaseDataType.isIterable get() =  this in arrayOf(BaseDataType.STR, BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW)
+val BaseDataType.isPassByRef get() = this.isIterable
+val BaseDataType.isPassByValue get() = !this.isIterable
+
+
+class DataType private constructor(val base: BaseDataType, val sub: BaseDataType?) {
+
+    init {
+        if(base.isArray) {
+            require(sub != null)
+            if(base.isSplitWordArray)
+                require(sub == BaseDataType.UWORD || sub == BaseDataType.WORD)
+        }
+        else if(base==BaseDataType.STR)
+            require(sub==BaseDataType.UBYTE) { "string subtype should be ubyte" }
+        else
+            require(sub == null) { "only string and array base types can have a subtype"}
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is DataType) return false
+        return base == other.base && sub == other.sub
+    }
+
+    override fun hashCode(): Int = Objects.hash(base, sub)
+
+    companion object {
+
+        val UBYTE = DataType(BaseDataType.UBYTE, null)
+        val BYTE = DataType(BaseDataType.BYTE, null)
+        val UWORD = DataType(BaseDataType.UWORD, null)
+        val WORD = DataType(BaseDataType.WORD, null)
+        val LONG = DataType(BaseDataType.LONG, null)
+        val FLOAT = DataType(BaseDataType.FLOAT, null)
+        val BOOL = DataType(BaseDataType.BOOL, null)
+        val STR = DataType(BaseDataType.STR, BaseDataType.UBYTE)
+        val UNDEFINED = DataType(BaseDataType.UNDEFINED, null)
+
+        private val simpletypes = mapOf(
+            BaseDataType.UBYTE to DataType(BaseDataType.UBYTE, null),
+            BaseDataType.BYTE to DataType(BaseDataType.BYTE, null),
+            BaseDataType.UWORD to DataType(BaseDataType.UWORD, null),
+            BaseDataType.WORD to DataType(BaseDataType.WORD, null),
+            BaseDataType.LONG to DataType(BaseDataType.LONG, null),
+            BaseDataType.FLOAT to DataType(BaseDataType.FLOAT, null),
+            BaseDataType.BOOL to DataType(BaseDataType.BOOL, null),
+            BaseDataType.STR to DataType(BaseDataType.STR, BaseDataType.UBYTE),
+            BaseDataType.UNDEFINED to DataType(BaseDataType.UNDEFINED, null)
+        )
+
+        fun forDt(dt: BaseDataType) = simpletypes.getValue(dt)
+
+        fun arrayFor(elementDt: BaseDataType, splitwordarray: Boolean=true): DataType {
+            val actualElementDt = if(elementDt==BaseDataType.STR) BaseDataType.UWORD else elementDt      // array of strings is actually just an array of UWORD pointers
+            return if(splitwordarray && actualElementDt.isWord)
+                DataType(BaseDataType.ARRAY_SPLITW, actualElementDt)
+            else {
+                if(actualElementDt.isNumericOrBool && actualElementDt != BaseDataType.LONG)
+                    DataType(BaseDataType.ARRAY, actualElementDt)
+                else
+                    throw NoSuchElementException("invalid element dt $elementDt")
+            }
+        }
+    }
+
+    fun elementToArray(splitwords: Boolean = true): DataType {
+        return if (base == BaseDataType.UWORD || base == BaseDataType.WORD || base == BaseDataType.STR) arrayFor(base, splitwords)
+        else arrayFor(base, false)
+    }
+
+    fun elementType(): DataType =
+        if(base.isArray || base==BaseDataType.STR)
+            forDt(sub!!)
+        else
+            throw IllegalArgumentException("not an array")
+
+    override fun toString(): String = when(base) {
+        BaseDataType.ARRAY -> {
+            when(sub) {
+                BaseDataType.BOOL -> "bool[]"
+                BaseDataType.FLOAT -> "float[]"
+                BaseDataType.BYTE -> "byte[]"
+                BaseDataType.WORD -> "word[]"
+                BaseDataType.UBYTE -> "ubyte[]"
+                BaseDataType.UWORD -> "uword[]"
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        BaseDataType.ARRAY_SPLITW -> {
+            when(sub) {
+                BaseDataType.WORD -> "word[] (split)"
+                BaseDataType.UWORD -> "uword[] (split)"
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        else -> base.name.lowercase()
+    }
+
+    fun sourceString(): String = when (base) {
+        BaseDataType.BOOL -> "bool"
+        BaseDataType.UBYTE -> "ubyte"
+        BaseDataType.BYTE -> "byte"
+        BaseDataType.UWORD -> "uword"
+        BaseDataType.WORD -> "word"
+        BaseDataType.LONG -> "long"
+        BaseDataType.FLOAT -> "float"
+        BaseDataType.STR -> "str"
+        BaseDataType.ARRAY -> {
+            when(sub) {
+                BaseDataType.UBYTE -> "ubyte["
+                BaseDataType.UWORD -> "@nosplit uword["
+                BaseDataType.BOOL -> "bool["
+                BaseDataType.BYTE -> "byte["
+                BaseDataType.WORD -> "@nosplit word["
+                BaseDataType.FLOAT -> "float["
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        BaseDataType.ARRAY_SPLITW -> {
+            when(sub) {
+                BaseDataType.UWORD -> "uword["
+                BaseDataType.WORD -> "word["
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        BaseDataType.UNDEFINED -> throw IllegalArgumentException("wrong dt")
+    }
+
+    // is the type assignable to the given other type (perhaps via a typecast) without loss of precision?
+    infix fun isAssignableTo(targetType: DataType) =
+        when(base) {
+            BaseDataType.BOOL -> targetType.base == BaseDataType.BOOL
+            BaseDataType.UBYTE -> targetType.base in arrayOf(BaseDataType.UBYTE, BaseDataType.WORD, BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.BYTE -> targetType.base in arrayOf(BaseDataType.BYTE, BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.UWORD -> targetType.base in arrayOf(BaseDataType.UWORD, BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.WORD -> targetType.base in arrayOf(BaseDataType.WORD, BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.LONG -> targetType.base in arrayOf(BaseDataType.LONG, BaseDataType.FLOAT)
+            BaseDataType.FLOAT -> targetType.base in arrayOf(BaseDataType.FLOAT)
+            BaseDataType.STR -> targetType.base in arrayOf(BaseDataType.STR, BaseDataType.UWORD)
+            BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW -> targetType.base in arrayOf(BaseDataType.ARRAY, BaseDataType.ARRAY_SPLITW) && targetType.sub == sub
+            BaseDataType.UNDEFINED -> false
+        }
+
+    fun largerSizeThan(other: DataType): Boolean = base.largerSizeThan(other.base)
+    fun equalsSize(other: DataType): Boolean = base.equalsSize(other.base)
+
+    val isUndefined = base == BaseDataType.UNDEFINED
+    val isByte = base.isByte
+    val isUnsignedByte = base == BaseDataType.UBYTE
+    val isSignedByte = base == BaseDataType.BYTE
+    val isByteOrBool = base.isByteOrBool
+    val isWord = base.isWord
+    val isUnsignedWord =  base == BaseDataType.UWORD
+    val isSignedWord =  base == BaseDataType.WORD
+    val isInteger = base.isInteger
+    val isIntegerOrBool = base.isIntegerOrBool
+    val isNumeric = base.isNumeric
+    val isNumericOrBool = base.isNumericOrBool
+    val isSigned = base.isSigned
+    val isUnsigned = !base.isSigned
+    val isArray = base.isArray
+    val isBoolArray = base.isArray && sub == BaseDataType.BOOL
+    val isByteArray = base.isArray && (sub == BaseDataType.UBYTE || sub == BaseDataType.BYTE)
+    val isUnsignedByteArray = base.isArray && sub == BaseDataType.UBYTE
+    val isSignedByteArray = base.isArray && sub == BaseDataType.BYTE
+    val isWordArray = base.isArray && (sub == BaseDataType.UWORD || sub == BaseDataType.WORD)
+    val isUnsignedWordArray = base.isArray && sub == BaseDataType.UWORD
+    val isSignedWordArray = base.isArray && sub == BaseDataType.WORD
+    val isFloatArray = base.isArray && sub == BaseDataType.FLOAT
+    val isString = base == BaseDataType.STR
+    val isBool = base == BaseDataType.BOOL
+    val isFloat = base == BaseDataType.FLOAT
+    val isLong = base == BaseDataType.LONG
+    val isStringly = base == BaseDataType.STR || base == BaseDataType.UWORD || (base == BaseDataType.ARRAY && (sub == BaseDataType.UBYTE || sub == BaseDataType.BYTE))
+    val isSplitWordArray = base.isSplitWordArray
+    val isSplitUnsignedWordArray = base.isSplitWordArray && sub == BaseDataType.UWORD
+    val isSplitSignedWordArray = base.isSplitWordArray && sub == BaseDataType.WORD
+    val isIterable =  base.isIterable
+    val isPassByRef = base.isPassByRef
+    val isPassByValue = base.isPassByValue
+}
+
+
 enum class CpuRegister {
     A,
     X,
@@ -78,7 +256,7 @@ enum class RegisterOrPair {
     R8, R9, R10, R11, R12, R13, R14, R15;
 
     companion object {
-        val names by lazy { values().map { it.toString()} }
+        val names by lazy { entries.map { it.toString()} }
         fun fromCpuRegister(cpu: CpuRegister): RegisterOrPair {
             return when(cpu) {
                 CpuRegister.A -> A
@@ -95,6 +273,17 @@ enum class RegisterOrPair {
         else -> throw IllegalArgumentException("no cpu hardware register for $this")
     }
 
+    fun asScopedNameVirtualReg(type: DataType?): List<String> {
+        require(this in Cx16VirtualRegisters)
+        val suffix = when(type?.base) {
+            BaseDataType.UBYTE, BaseDataType.BOOL -> "L"
+            BaseDataType.BYTE -> "sL"
+            BaseDataType.WORD -> "s"
+            BaseDataType.UWORD, null -> ""
+            else -> throw kotlin.IllegalArgumentException("invalid register param type")
+        }
+        return listOf("cx16", name.lowercase()+suffix)
+    }
 }       // only used in parameter and return value specs in asm subroutines
 
 enum class Statusflag {
@@ -104,7 +293,7 @@ enum class Statusflag {
     Pn;     // don't use
 
     companion object {
-        val names by lazy { values().map { it.toString()} }
+        val names by lazy { entries.map { it.toString()} }
     }
 }
 
@@ -123,47 +312,6 @@ enum class BranchCondition {
     VC
 }
 
-
-val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.BOOL)
-val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD)
-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
-val PassByReferenceDatatypes = IterableDatatypes
-val ArrayToElementTypes = mapOf(
-    DataType.STR to DataType.UBYTE,
-    DataType.ARRAY_B to DataType.BYTE,
-    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
-)
-val ElementToArrayTypes = mapOf(
-    DataType.BYTE to DataType.ARRAY_B,
-    DataType.UBYTE to DataType.ARRAY_UB,
-    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.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,
@@ -171,7 +319,7 @@ val Cx16VirtualRegisters = arrayOf(
     RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15
 )
 
-val CpuRegisters = setOf(
+val CpuRegisters = arrayOf(
     RegisterOrPair.A, RegisterOrPair.X, RegisterOrPair.Y,
     RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY
 )
@@ -180,7 +328,8 @@ val CpuRegisters = setOf(
 enum class OutputType {
     RAW,
     PRG,
-    XEX
+    XEX,
+    LIBRARY
 }
 
 enum class CbmPrgLauncherType {
@@ -202,3 +351,9 @@ enum class ZeropageWish {
     DONTCARE,
     NOT_IN_ZEROPAGE
 }
+
+enum class SplitWish {
+    DONTCARE,
+    SPLIT,
+    NOSPLIT
+}

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

@@ -1,8 +1,43 @@
 package prog8.code.core
 
+import java.nio.file.Path
+
+enum class CpuType {
+    CPU6502,
+    CPU65C02,
+    VIRTUAL
+}
+
 interface ICompilationTarget: IStringEncoding, IMemSizer {
     val name: String
-    val machine: IMachineDefinition
+
+    val FLOAT_MAX_NEGATIVE: Double
+    val FLOAT_MAX_POSITIVE: Double
+    val FLOAT_MEM_SIZE: Int
+    val STARTUP_CODE_RESERVED_SIZE: UInt        // this is here, so that certain compiler targets are able to tune this
+    val PROGRAM_LOAD_ADDRESS : UInt
+    val PROGRAM_MEMTOP_ADDRESS: UInt
+    val BSSHIGHRAM_START: UInt
+    val BSSHIGHRAM_END: UInt
+    val BSSGOLDENRAM_START: UInt
+    val BSSGOLDENRAM_END: UInt
+
+    val cpu: CpuType
+    var zeropage: Zeropage
+    var golden: GoldenRam
+    val libraryPath: Path?
+    val customLauncher: List<String>
+    val additionalAssemblerOptions: String?
+    val defaultOutputType: OutputType
+
+    fun initializeMemoryAreas(compilerOptions: CompilationOptions)
+    fun getFloatAsmBytes(num: Number): String
+
+    fun convertFloatToBytes(num: Double): List<UByte>
+    fun convertBytesToFloat(bytes: List<UByte>): Double
+
+    fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean)
+    fun isIOAddress(address: UInt): Boolean
 
     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

@@ -11,4 +11,8 @@ interface IErrorReporter {
         if(numErrors>0)
             throw ErrorsReportedException("There are $numErrors errors, $numWarnings warnings, and $numInfos infos.")
     }
+
+    fun noErrorForLine(position: Position): Boolean
+
+    fun printSingleError(errormessage: String)
 }

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

@@ -1,32 +0,0 @@
-package prog8.code.core
-
-import java.nio.file.Path
-
-
-enum class CpuType {
-    CPU6502,
-    CPU65c02,
-    VIRTUAL
-}
-
-interface IMachineDefinition {
-    val FLOAT_MAX_NEGATIVE: Double
-    val FLOAT_MAX_POSITIVE: Double
-    val FLOAT_MEM_SIZE: Int
-    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
-    var golden: GoldenRam
-
-    fun initializeMemoryAreas(compilerOptions: CompilationOptions)
-    fun getFloatAsmBytes(num: Number): String
-
-    fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String>
-    fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path)
-    fun isIOAddress(address: UInt): Boolean
-}

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

@@ -1,6 +1,15 @@
 package prog8.code.core
 
 interface IMemSizer {
-    fun memorySize(dt: DataType): Int
-    fun memorySize(arrayDt: DataType, numElements: Int): Int
+    fun memorySize(dt: DataType, numElements: Int?): Int
+
+    fun memorySize(dt: BaseDataType): Int {
+        if(dt.isPassByRef)
+            return memorySize(DataType.UWORD, null)      // a pointer size
+        try {
+            return memorySize(DataType.forDt(dt), null)
+        } catch (x: NoSuchElementException) {
+            throw IllegalArgumentException(x.message)
+        }
+    }
 }

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

@@ -5,7 +5,12 @@ enum class Encoding(val prefix: String) {
     PETSCII("petscii"),         // c64/c128/cx16
     SCREENCODES("sc"),          // c64/c128/cx16
     ATASCII("atascii"),         // atari
-    ISO("iso")                  // cx16
+    ISO("iso"),                 // cx16  (iso-8859-15)
+    ISO5("iso5"),               // cx16  (iso-8859-5, cyrillic)
+    ISO16("iso16"),             // cx16  (iso-8859-16, eastern european)
+    CP437("cp437"),             // cx16  (ibm pc, codepage 437)
+    KATAKANA("kata"),           // cx16  (katakana)
+    C64OS("c64os")              // c64 (C64 OS)
 }
 
 interface IStringEncoding {

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

@@ -22,7 +22,7 @@ abstract class MemoryAllocator(protected val options: CompilationOptions) {
 abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
 
     abstract val SCRATCH_B1 : UInt      // temp storage for a single byte
-    abstract val SCRATCH_REG : UInt     // temp storage for a register, must be B1+1
+    abstract val SCRATCH_REG : UInt     // temp storage for a register byte, must be B1+1
     abstract val SCRATCH_W1 : UInt      // temp storage 1 for a word  $fb+$fc
     abstract val SCRATCH_W2 : UInt      // temp storage 2 for a word  $fb+$fc
 
@@ -38,7 +38,7 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
             for (reserved in options.zpReserved)
                 reserve(reserved)
 
-            free.removeAll(setOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1u, SCRATCH_W2, SCRATCH_W2 + 1u))
+            free.removeAll(arrayOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1 + 1u, SCRATCH_W2, SCRATCH_W2 + 1u))
         }
     }
 
@@ -70,9 +70,9 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
             return Err(MemAllocationError("zero page usage has been disabled"))
 
         val size: Int =
-                when (datatype) {
-                    in IntegerDatatypes -> options.compTarget.memorySize(datatype)
-                    DataType.STR, in ArrayDatatypes  -> {
+                when {
+                    datatype.isIntegerOrBool -> options.compTarget.memorySize(datatype, null)
+                    datatype.isString || datatype.isArray -> {
                         val memsize = options.compTarget.memorySize(datatype, numElements!!)
                         if(position!=null)
                             errors.warn("allocating a large value in zeropage; str/array $memsize bytes", position)
@@ -80,9 +80,9 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
                             errors.warn("$name: allocating a large value in zeropage; str/array $memsize bytes", Position.DUMMY)
                         memsize
                     }
-                    DataType.FLOAT -> {
+                    datatype.isFloat -> {
                         if (options.floats) {
-                            val memsize = options.compTarget.memorySize(DataType.FLOAT)
+                            val memsize = options.compTarget.memorySize(DataType.FLOAT, null)
                             if(position!=null)
                                 errors.warn("allocating a large value in zeropage; float $memsize bytes", position)
                             else
@@ -94,7 +94,7 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
                 }
 
         synchronized(this) {
-            if(free.size > 0) {
+            if(free.isNotEmpty()) {
                 if(size==1) {
                     for(candidate in free.minOrNull()!! .. free.maxOrNull()!!+1u) {
                         if(oneSeparateByteFree(candidate))
@@ -118,10 +118,10 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
         require(size>=0)
         free.removeAll(address until address+size.toUInt())
         if(name.isNotEmpty()) {
-            allocatedVariables[name] = when(datatype) {
-                in NumericDatatypes -> VarAllocation(address, datatype, size)        // numerical variables in zeropage never have an initial value here because they are set in separate initializer assignments
-                DataType.STR -> VarAllocation(address, datatype, size)
-                in ArrayDatatypes -> VarAllocation(address, datatype, size)
+            allocatedVariables[name] = when {
+                datatype.isNumericOrBool -> VarAllocation(address, datatype, size)        // numerical variables in zeropage never have an initial value here because they are set in separate initializer assignments
+                datatype.isString -> VarAllocation(address, datatype, size)
+                datatype.isArray -> VarAllocation(address, datatype, size)
                 else -> throw AssemblyError("invalid dt")
             }
         }
@@ -133,8 +133,6 @@ abstract class Zeropage(options: CompilationOptions): MemoryAllocator(options) {
         require(size>0)
         return free.containsAll((address until address+size.toUInt()).toList())
     }
-
-    abstract fun allocateCx16VirtualRegisters()
 }
 
 
@@ -150,14 +148,13 @@ class GoldenRam(options: CompilationOptions, val region: UIntRange): MemoryAlloc
         errors: IErrorReporter): Result<VarAllocation, MemAllocationError> {
 
         val size: Int =
-            when (datatype) {
-                in IntegerDatatypes -> options.compTarget.memorySize(datatype)
-                DataType.STR, in ArrayDatatypes  -> {
-                    options.compTarget.memorySize(datatype, numElements!!)
-                }
-                DataType.FLOAT -> {
+            when {
+                datatype.isIntegerOrBool -> options.compTarget.memorySize(datatype, null)
+                datatype.isString -> numElements!!
+                datatype.isArray -> options.compTarget.memorySize(datatype, numElements!!)
+                datatype.isFloat -> {
                     if (options.floats) {
-                        options.compTarget.memorySize(DataType.FLOAT)
+                        options.compTarget.memorySize(DataType.FLOAT, null)
                     } else return Err(MemAllocationError("floating point option not enabled"))
                 }
                 else -> throw MemAllocationError("weird dt")

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

@@ -1,10 +1,10 @@
 package prog8.code.core
 
-val AssociativeOperators = setOf("+", "*", "&", "|", "^", "==", "!=", "and", "or", "xor")
-val ComparisonOperators = setOf("==", "!=", "<", ">", "<=", ">=")
-val LogicalOperators = setOf("and", "or", "xor", "not")
-val BitwiseOperators = setOf("&", "|", "^", "~")
-val PrefixOperators = setOf("+", "-", "~", "not")
+val AssociativeOperators = arrayOf("+", "*", "&", "|", "^", "==", "!=", "xor")       // note: and,or are not associative because of Shortcircuit/McCarthy evaluation
+val ComparisonOperators = arrayOf("==", "!=", "<", ">", "<=", ">=")
+val LogicalOperators = arrayOf("and", "or", "xor", "not", "in")
+val BitwiseOperators = arrayOf("&", "|", "^", "~")
+val PrefixOperators = arrayOf("+", "-", "~", "not")
 
 fun invertedComparisonOperator(operator: String) =
     when (operator) {

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

@@ -1,21 +1,21 @@
 package prog8.code.core
 
-import prog8.code.core.SourceCode.Companion.LIBRARYFILEPREFIX
+import prog8.code.sanitize
+import prog8.code.source.SourceCode
 import java.nio.file.InvalidPathException
 import kotlin.io.path.Path
-import kotlin.io.path.absolute
 
 data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
     override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
     fun toClickableStr(): String {
         if(this===DUMMY)
             return ""
-        if(file.startsWith(LIBRARYFILEPREFIX))
+        if(SourceCode.isLibraryResource(file))
             return "$file:$line:$startCol:"
         return try {
-            val path = Path(file).absolute().normalize().toString()
+            val path = Path(file).sanitize().toString()
             "file://$path:$line:$startCol:"
-        } catch(x: InvalidPathException) {
+        } catch(_: InvalidPathException) {
             // this can occur on Windows when the source origin contains "invalid" characters such as ':'
             "file://$file:$line:$startCol:"
         }

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

@@ -1,130 +0,0 @@
-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 var tempVarCounter = 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)
-        tempVarCounter++
-        val tempvarName = "prog8_subexprvar_$tempVarCounter"
-        // 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.NOT_IN_ZEROPAGE, 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/source/ImportFileSystem.kt

@@ -0,0 +1,74 @@
+package prog8.code.source
+
+import prog8.code.core.Position
+import prog8.code.sanitize
+import java.nio.file.Path
+import java.util.*
+import kotlin.io.path.Path
+
+
+// Resource caching "filesystem".
+// Note that it leaves the decision to load a resource or an actual disk file to the caller.
+
+object ImportFileSystem {
+
+    fun expandTilde(path: String): String = if (path.startsWith("~")) {
+        val userHome = System.getProperty("user.home")
+        userHome + path.drop(1)
+    } else {
+        path
+    }
+
+    fun expandTilde(path: Path): Path = Path(expandTilde(path.toString()))
+
+    fun getFile(path: Path, isLibrary: Boolean=false): SourceCode {
+        val normalized = path.sanitize()
+        val cached = cache[normalized.toString()]
+        if (cached != null)
+            return cached
+        val file = SourceCode.File(normalized, isLibrary)
+        cache[normalized.toString()] = file
+        return file
+    }
+
+    fun getResource(name: String): SourceCode {
+        val cached = cache[name]
+        if (cached != null) return cached
+        val resource = SourceCode.Resource(name)
+        cache[name] = resource
+        return resource
+    }
+
+    fun retrieveSourceLine(position: Position): String {
+        if(SourceCode.isLibraryResource(position.file)) {
+            val cached = cache[SourceCode.withoutPrefix(position.file)]
+            if(cached != null)
+                return getLine(cached, position.line)
+        }
+        val cached = cache[position.file]
+        if(cached != null)
+            return getLine(cached, position.line)
+        val path = Path(position.file).sanitize()
+        val cached2 = cache[path.toString()]
+        if(cached2 != null)
+            return getLine(cached2, position.line)
+        throw NoSuchElementException("cannot get source line $position, with path $path")
+    }
+
+    private fun getLine(code: SourceCode, lineIndex: Int): String {
+        var spans = lineSpanCache[code]
+        if(spans==null) {
+            val lineSpans = Regex("^", RegexOption.MULTILINE).findAll(code.text).map { it.range.first }
+            val ends = lineSpans.drop(1) + code.text.length
+            spans = lineSpans.zip(ends).map { (start, end) -> LineSpan(start, end) }.toList().toTypedArray()
+            lineSpanCache[code] = spans
+        }
+        val span = spans[lineIndex - 1]
+        return code.text.substring(span.start, span.end).trim()
+    }
+
+    private class LineSpan(val start: Int, val end: Int)
+
+    private val cache = TreeMap<String, SourceCode>(String.CASE_INSENSITIVE_ORDER)
+    private val lineSpanCache = mutableMapOf<SourceCode, Array<LineSpan>>()
+}

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

@@ -1,16 +1,13 @@
-package prog8.code.core
+package prog8.code.source
 
-import java.io.File
+import prog8.code.sanitize
 import java.io.IOException
 import java.nio.file.Path
 import java.text.Normalizer
 import kotlin.io.path.Path
+import kotlin.io.path.absolute
 import kotlin.io.path.readText
 
-
-const val internedStringsModuleName = "prog8_interned_strings"
-
-
 /**
  * Encapsulates - and ties together - actual source code (=text) and its [origin].
  */
@@ -26,6 +23,11 @@ sealed class SourceCode {
      */
     abstract val isFromFilesystem: Boolean
 
+    /**
+     * Whether this [SourceCode] instance was created from a library module file
+     */
+    abstract val isFromLibrary: Boolean
+
     /**
      * The logical name of the source code unit. Usually the module's name.
      */
@@ -55,14 +57,21 @@ 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:"
-        val curdir: Path = Path(".").toAbsolutePath()
-        fun relative(path: Path): Path = curdir.relativize(path.toAbsolutePath())
-        fun isRegularFilesystemPath(pathString: String) =
-            !(pathString.startsWith(LIBRARYFILEPREFIX) || pathString.startsWith(STRINGSOURCEPREFIX))
-
+        private const val LIBRARYFILEPREFIX = "library:"
+        private const val STRINGSOURCEPREFIX = "string:"
+        val curdir: Path = Path(".").absolute()
+        fun relative(path: Path): Path = curdir.relativize(path.sanitize())
+        fun isRegularFilesystemPath(pathString: String) = !isLibraryResource(pathString) && !isStringResource(pathString)
         fun isLibraryResource(path: String) = path.startsWith(LIBRARYFILEPREFIX)
+        fun isStringResource(path: String) = path.startsWith(STRINGSOURCEPREFIX)
+        fun withoutPrefix(path: String): String {
+            return if(isLibraryResource(path))
+                path.removePrefix(LIBRARYFILEPREFIX)
+            else if(isStringResource(path))
+                path.removePrefix(STRINGSOURCEPREFIX)
+            else
+                path
+        }
     }
 
     /**
@@ -73,6 +82,7 @@ sealed class SourceCode {
         override val text = origText.replace("\\R".toRegex(), "\n")      // normalize line endings
         override val isFromResources = false
         override val isFromFilesystem = false
+        override val isFromLibrary = false
         override val origin = "$STRINGSOURCEPREFIX${System.identityHashCode(text).toString(16)}"
         override val name = "<unnamed-text>"
     }
@@ -80,12 +90,13 @@ sealed class SourceCode {
     /**
      * Get [SourceCode] from the file represented by the specified Path.
      * This immediately reads the file fully into memory.
+     * You can only get an instance of this via the ImportFileSystem object.
      *
      * [origin] will be the given path in absolute and normalized form.
      * @throws NoSuchFileException if the file does not exist
      * @throws FileSystemException if the file cannot be read
      */
-    class File(path: Path): SourceCode() {
+    internal class File(path: Path, override val isFromLibrary: Boolean): SourceCode() {
         override val text: String
         override val origin: String
         override val name: String
@@ -109,12 +120,14 @@ sealed class SourceCode {
 
     /**
      * [origin]: `library:/x/y/z.p8` for a given `pathString` of "x/y/z.p8"
+     * You can only get an instance of this via the ImportFileSystem object.
      */
-    class Resource(pathString: String): SourceCode() {
+    internal class Resource(pathString: String): SourceCode() {
         private val normalized = "/" + Path(pathString).normalize().toMutableList().joinToString("/")
 
         override val isFromResources = true
         override val isFromFilesystem = false
+        override val isFromLibrary = true
         override val origin = "$LIBRARYFILEPREFIX$normalized"
         override val text: String
         override val name: String
@@ -124,7 +137,7 @@ sealed class SourceCode {
             if (rscURL == null) {
                 val rscRoot = object {}.javaClass.getResource("/")
                 throw NoSuchFileException(
-                    File(normalized),
+                    java.io.File(normalized),
                     reason = "looked in resources rooted at $rscRoot"
                 )
             }
@@ -141,37 +154,8 @@ sealed class SourceCode {
     class Generated(override val name: String) : SourceCode() {
         override val isFromResources: Boolean = false
         override val isFromFilesystem: Boolean = false
+        override val isFromLibrary: Boolean = false
         override val origin: String = name
         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/target/AtariTarget.kt

@@ -1,27 +0,0 @@
-package prog8.code.target
-
-import prog8.code.core.*
-import prog8.code.target.atari.AtariMachineDefinition
-
-
-class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
-    override val name = NAME
-    override val machine = AtariMachineDefinition()
-    override val defaultEncoding = Encoding.ATASCII
-
-    companion object {
-        const val NAME = "atari"
-    }
-
-    override fun memorySize(dt: DataType): Int {
-        return when(dt) {
-            in ByteDatatypes -> 1
-            in WordDatatypes, in PassByReferenceDatatypes -> 2
-            DataType.FLOAT -> machine.FLOAT_MEM_SIZE
-            else -> throw IllegalArgumentException("invalid datatype")
-        }
-    }
-
-    override fun memorySize(arrayDt: DataType, numElements: Int) =
-        memorySize(ArrayToElementTypes.getValue(arrayDt)) * numElements
-}

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

@@ -1,19 +1,81 @@
 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.c128.C128MachineDefinition
-import prog8.code.target.cbm.CbmMemorySizer
+import prog8.code.core.*
+import prog8.code.target.encodings.Encoder
+import prog8.code.target.zp.C128Zeropage
+import java.nio.file.Path
 
 
-class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+class C128Target: ICompilationTarget,
+    IStringEncoding by Encoder(true),
+    IMemSizer by NormalMemSizer(Mflpt5.FLOAT_MEM_SIZE) {
+
     override val name = NAME
-    override val machine = C128MachineDefinition()
     override val defaultEncoding = Encoding.PETSCII
+    override val libraryPath = null
+    override val customLauncher: List<String> = emptyList()
+    override val additionalAssemblerOptions = null
+    override val defaultOutputType = OutputType.PRG
 
     companion object {
         const val NAME = "c128"
     }
+
+
+    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 STARTUP_CODE_RESERVED_SIZE = 20u
+    override val PROGRAM_LOAD_ADDRESS = 0x1c01u
+    override val PROGRAM_MEMTOP_ADDRESS = 0xc000u
+
+    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
+
+    override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
+
+    override fun convertFloatToBytes(num: Double): List<UByte> {
+        val m5 = Mflpt5.fromNumber(num)
+        return listOf(m5.b0, m5.b1, m5.b2, m5.b3, m5.b4)
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==5) { "need 5 bytes" }
+        val m5 = Mflpt5(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])
+        return m5.toDouble()
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+        if(selectedEmulator!=1) {
+            System.err.println("The c128 target only supports the main emulator (Vice).")
+            return
+        }
+
+        if(!quiet)
+            println("\nStarting C-128 emulator x128...")
+
+        val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
+        val cmdline = listOf("x128", "-silent", "-moncommands", viceMonlist,
+            "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
+        val processb = ProcessBuilder(cmdline)
+        if(!quiet)
+            processb.inheritIO()
+        val process: Process = processb.start()
+        process.waitFor()
+    }
+
+    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0xd000u..0xdfffu
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = C128Zeropage(compilerOptions)
+        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)    // TODO does the c128 have some of this somewhere?
+    }
+
 }

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

@@ -1,21 +1,111 @@
 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.c64.C64MachineDefinition
-import prog8.code.target.cbm.CbmMemorySizer
+import prog8.code.core.*
+import prog8.code.target.encodings.Encoder
+import prog8.code.target.zp.C64Zeropage
+import java.io.IOException
+import java.nio.file.Path
 
 
-class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+class C64Target: ICompilationTarget,
+    IStringEncoding by Encoder(true),
+    IMemSizer by NormalMemSizer(Mflpt5.Companion.FLOAT_MEM_SIZE) {
+
     override val name = NAME
-    override val machine = C64MachineDefinition()
     override val defaultEncoding = Encoding.PETSCII
+    override val libraryPath = null
+    override val customLauncher: List<String> = emptyList()
+    override val additionalAssemblerOptions = null
+    override val defaultOutputType = OutputType.PRG
 
     companion object {
         const val NAME = "c64"
 
         fun viceMonListName(baseFilename: String) = "$baseFilename.vice-mon-list"
     }
+
+
+    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 STARTUP_CODE_RESERVED_SIZE = 20u
+    override val PROGRAM_LOAD_ADDRESS = 0x0801u
+    override val PROGRAM_MEMTOP_ADDRESS = 0xcfe0u      // $a000  if floats are used
+    // note that at $cfe0-$cfff are the 16 'virtual registers' R0-R15
+
+    override val BSSHIGHRAM_START = 0xc000u
+    override val BSSHIGHRAM_END = 0xcfdfu
+    override val BSSGOLDENRAM_START = 0u        // no golden ram on C64
+    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 convertFloatToBytes(num: Double): List<UByte> {
+        val m5 = Mflpt5.fromNumber(num)
+        return listOf(m5.b0, m5.b1, m5.b2, m5.b3, m5.b4)
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==5) { "need 5 bytes" }
+        val m5 = Mflpt5(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])
+        return m5.toDouble()
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+        if(selectedEmulator!=1) {
+            System.err.println("The c64 target only supports the main emulator (Vice).")
+            return
+        }
+
+        for(emulator in listOf("x64sc", "x64")) {
+            if(!quiet)
+                println("\nStarting C-64 emulator $emulator...")
+
+            val viceMonlist = viceMonListName(programNameWithPath.toString())
+            val cmdline = listOf(emulator, "-silent", "-moncommands", viceMonlist,
+                "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
+            val processb = ProcessBuilder(cmdline)
+            if(!quiet)
+                processb.inheritIO()
+            val process: Process
+            try {
+                process=processb.start()
+            } catch(_: IOException) {
+                continue  // try the next emulator executable
+            }
+            process.waitFor()
+            break
+        }
+    }
+
+    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0xd000u..0xdfffu
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = C64Zeropage(compilerOptions)
+        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
+    }
+
+}
+
+
+val CompilationTargets = listOf(
+    C64Target.NAME,
+    C128Target.NAME,
+    Cx16Target.NAME,
+    PETTarget.NAME,
+    VMTarget.NAME
+)
+
+fun getCompilationTargetByName(name: String) = when(name.lowercase()) {
+    C64Target.NAME -> C64Target()
+    C128Target.NAME -> C128Target()
+    Cx16Target.NAME -> Cx16Target()
+    PETTarget.NAME -> PETTarget()
+    VMTarget.NAME -> VMTarget()
+    else -> throw IllegalArgumentException("invalid compilation target")
 }

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

@@ -0,0 +1,173 @@
+package prog8.code.target
+
+import prog8.code.core.*
+import prog8.code.source.ImportFileSystem.expandTilde
+import prog8.code.target.encodings.Encoder
+import prog8.code.target.zp.ConfigurableZeropage
+import java.io.IOException
+import java.nio.file.Path
+import java.util.*
+import kotlin.io.path.Path
+import kotlin.io.path.inputStream
+import kotlin.io.path.isDirectory
+import kotlin.io.path.nameWithoutExtension
+
+
+class ConfigFileTarget(
+    override val name: String,
+    override val defaultEncoding: Encoding,
+    override val cpu: CpuType,
+    override val PROGRAM_LOAD_ADDRESS: UInt,
+    override val PROGRAM_MEMTOP_ADDRESS: UInt,
+    override val STARTUP_CODE_RESERVED_SIZE: UInt,
+    override val BSSHIGHRAM_START: UInt,
+    override val BSSHIGHRAM_END: UInt,
+    override val BSSGOLDENRAM_START: UInt,
+    override val BSSGOLDENRAM_END: UInt,
+    override val defaultOutputType: OutputType,
+    override val libraryPath: Path,
+    override val customLauncher: List<String>,
+    override val additionalAssemblerOptions: String?,
+    val ioAddresses: List<UIntRange>,
+    val zpScratchB1: UInt,
+    val zpScratchReg: UInt,
+    val zpScratchW1: UInt,
+    val zpScratchW2: UInt,
+    val virtualregistersStart: UInt,
+    val zpFullsafe: List<UIntRange>,
+    val zpKernalsafe: List<UIntRange>,
+    val zpBasicsafe: List<UIntRange>
+): ICompilationTarget, IStringEncoding by Encoder(true), IMemSizer by NormalMemSizer(8) {
+
+    companion object {
+
+        private fun Properties.getString(property: String): String {
+            val value = this.getProperty(property, null)
+            if(value!=null)
+                return value
+            throw NoSuchElementException("string property '$property' not found in config file")
+        }
+
+        private fun Properties.getInteger(property: String): UInt {
+            val value = this.getProperty(property, null)
+            if(value!=null) return parseInt(value)
+            throw NoSuchElementException("integer property '$property' not found in config file")
+        }
+
+        private fun parseInt(value: String): UInt {
+            if(value.startsWith("0x"))
+                return value.drop(2).toUInt(16)
+            if(value.startsWith("$"))
+                return value.drop(1).toUInt(16)
+            if(value.startsWith("%"))
+                return value.drop(1).toUInt(2)
+            return value.toUInt()
+        }
+
+        private fun parseAddressRanges(key: String, props: Properties): List<UIntRange> {
+            val rangesStr = props.getString(key)
+            if(rangesStr.isBlank())
+                return emptyList()
+            val result = mutableListOf<UIntRange>()
+            val ranges = rangesStr.split(",").map { it.trim() }
+            for(r in ranges) {
+                if ('-' in r) {
+                    val (fromStr, toStr) = r.split("-")
+                    val from = parseInt(fromStr.trim())
+                    val to = parseInt(toStr.trim())
+                    result.add(from..to)
+                } else {
+                    val address = parseInt(r)
+                    result.add(address..address)
+                }
+            }
+            return result
+        }
+
+        fun fromConfigFile(configfile: Path): ConfigFileTarget {
+            val props = Properties()
+            props.load(configfile.inputStream())
+
+            val cpuString = props.getString("cpu").uppercase()
+            val cpuType = try {
+                CpuType.valueOf(cpuString)
+            } catch (_: IllegalArgumentException) {
+                CpuType.valueOf("CPU$cpuString")
+            }
+            val ioAddresses = parseAddressRanges("io_regions", props)
+            val zpFullsafe = parseAddressRanges("zp_fullsafe", props)
+            val zpKernalsafe = parseAddressRanges("zp_kernalsafe", props)
+            val zpBasicsafe = parseAddressRanges("zp_basicsafe", props)
+
+            val libraryPath = expandTilde(Path(props.getString("library")))
+            if(!libraryPath.isDirectory())
+                throw IOException("invalid library path: $libraryPath")
+
+            val customLauncherStr = props.getProperty("custom_launcher_code", null)
+            val customLauncher =
+                if(customLauncherStr?.isNotBlank()==true)
+                    (customLauncherStr+"\n").lines().map { it.trimEnd() }
+                else emptyList()
+            val assemblerOptionsStr = props.getProperty("assembler_options", "").trim()
+            val assemblerOptions = assemblerOptionsStr.ifBlank { null }
+
+            val outputTypeString = props.getProperty("output_type", "PRG")
+            val defaultOutputType = OutputType.valueOf(outputTypeString.uppercase())
+
+            return ConfigFileTarget(
+                configfile.nameWithoutExtension,
+                Encoding.entries.first { it.prefix==props.getString("encoding") },
+                cpuType,
+                props.getInteger("load_address"),
+                props.getInteger("memtop"),
+                0u,         // used only in a very specific error condition check in a certain scenario...
+                props.getInteger("bss_highram_start"),
+                props.getInteger("bss_highram_end"),
+                props.getInteger("bss_goldenram_start"),
+                props.getInteger("bss_goldenram_end"),
+                defaultOutputType,
+                libraryPath,
+                customLauncher,
+                assemblerOptions,
+                ioAddresses,
+                props.getInteger("zp_scratch_b1"),
+                props.getInteger("zp_scratch_reg"),
+                props.getInteger("zp_scratch_w1"),
+                props.getInteger("zp_scratch_w2"),
+                props.getInteger("virtual_registers"),
+                zpFullsafe,
+                zpKernalsafe,
+                zpBasicsafe,
+            )
+        }
+    }
+
+    // TODO floats are not yet supported here, just enter some values
+    override val FLOAT_MAX_POSITIVE = 9.999999999e97
+    override val FLOAT_MAX_NEGATIVE = -9.999999999e97
+    override val FLOAT_MEM_SIZE = 8
+
+    override lateinit var zeropage: Zeropage
+    override lateinit var golden: GoldenRam     // TODO this is not yet used
+
+    override fun getFloatAsmBytes(num: Number) = TODO("floats")
+    override fun convertFloatToBytes(num: Double): List<UByte> = TODO("floats")
+    override fun convertBytesToFloat(bytes: List<UByte>): Double = TODO("floats")
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+        throw IllegalArgumentException("Custom compiler target cannot automatically launch an emulator. Do this manually.")
+    }
+
+    override fun isIOAddress(address: UInt): Boolean = ioAddresses.any { address in it }
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = ConfigurableZeropage(
+            zpScratchB1, zpScratchReg, zpScratchW1, zpScratchW2,
+            virtualregistersStart,
+            zpBasicsafe,
+            zpKernalsafe,
+            zpFullsafe,
+            compilerOptions
+        )
+        // note: there's no golden ram yet
+    }
+}

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

@@ -1,19 +1,94 @@
 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.cx16.CX16MachineDefinition
+import prog8.code.core.*
+import prog8.code.target.encodings.Encoder
+import prog8.code.target.zp.CX16Zeropage
+import java.nio.file.Path
 
 
-class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+class Cx16Target: ICompilationTarget,
+    IStringEncoding by Encoder(true),
+    IMemSizer by NormalMemSizer(Mflpt5.Companion.FLOAT_MEM_SIZE) {
+
     override val name = NAME
-    override val machine = CX16MachineDefinition()
     override val defaultEncoding = Encoding.PETSCII
+    override val libraryPath = null
+    override val customLauncher: List<String> = emptyList()
+    override val additionalAssemblerOptions = null
+    override val defaultOutputType = OutputType.PRG
 
     companion object {
         const val NAME = "cx16"
     }
+
+
+    override val cpu = CpuType.CPU65C02
+
+    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 STARTUP_CODE_RESERVED_SIZE = 20u
+    override val PROGRAM_LOAD_ADDRESS = 0x0801u
+    override val PROGRAM_MEMTOP_ADDRESS = 0x9f00u
+
+    override val BSSHIGHRAM_START = 0xa000u     // hiram bank 1, 8Kb, assumed to be active
+    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
+
+    override fun getFloatAsmBytes(num: Number) = Mflpt5.fromNumber(num).makeFloatFillAsm()
+
+    override fun convertFloatToBytes(num: Double): List<UByte> {
+        val m5 = Mflpt5.fromNumber(num)
+        return listOf(m5.b0, m5.b1, m5.b2, m5.b3, m5.b4)
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==5) { "need 5 bytes" }
+        val m5 = Mflpt5(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])
+        return m5.toDouble()
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+        val emulator: String
+        val extraArgs: List<String>
+
+        when(selectedEmulator) {
+            1 -> {
+                emulator = "x16emu"
+                extraArgs = listOf("-debug")
+            }
+            2 -> {
+                emulator = "box16"
+                extraArgs = listOf("-sym", C64Target.viceMonListName(programNameWithPath.toString()))
+            }
+            else -> {
+                System.err.println("Cx16 target only supports x16emu and box16 emulators.")
+                return
+            }
+        }
+
+        if(!quiet)
+            println("\nStarting Commander X16 emulator $emulator...")
+
+        val cmdline = listOf(emulator, "-scale", "2", "-rtc", "-run", "-prg", "${programNameWithPath}.prg") + extraArgs
+        val processb = ProcessBuilder(cmdline)
+        if(!quiet)
+            processb.inheritIO()
+        processb.environment()["PULSE_LATENCY_MSEC"] = "10"
+        val process: Process = processb.start()
+        process.waitFor()
+    }
+
+    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0x9f00u..0x9fffu
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = CX16Zeropage(compilerOptions)
+        golden = GoldenRam(compilerOptions, BSSGOLDENRAM_START..BSSGOLDENRAM_END)
+    }
+
+
 }

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

@@ -1,10 +1,9 @@
-package prog8.code.target.cbm
+package prog8.code.target
 
 import prog8.code.core.InternalCompilerException
 import kotlin.math.absoluteValue
 import kotlin.math.pow
 
-
 data class Mflpt5(val b0: UByte, val b1: UByte, val b2: UByte, val b3: UByte, val b4: UByte) {
 
     companion object {

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

@@ -0,0 +1,34 @@
+package prog8.code.target
+
+import prog8.code.core.BaseDataType
+import prog8.code.core.DataType
+import prog8.code.core.IMemSizer
+
+internal class NormalMemSizer(val floatsize: Int): IMemSizer {
+
+    override fun memorySize(dt: DataType, numElements: Int?): Int {
+        if(dt.isArray) {
+            if(numElements==null) return 2      // treat it as a pointer size
+            return when(dt.sub) {
+                BaseDataType.BOOL, BaseDataType.UBYTE, BaseDataType.BYTE -> numElements
+                BaseDataType.UWORD, BaseDataType.WORD, BaseDataType.STR -> numElements * 2
+                BaseDataType.FLOAT-> numElements * floatsize
+                BaseDataType.UNDEFINED -> throw IllegalArgumentException("undefined has no memory size")
+                else -> throw IllegalArgumentException("invalid sub type")
+            }
+        }
+        else if (dt.isString) {
+            return numElements        // treat it as the size of the given string with the length
+                ?: 2    // treat it as the size to store a string pointer
+        }
+
+        return when {
+            dt.isByteOrBool -> 1 * (numElements ?: 1)
+            dt.isFloat -> floatsize * (numElements ?: 1)
+            dt.isLong -> 4 * (numElements ?: 1)
+            dt.isUndefined -> throw IllegalArgumentException("undefined has no memory size")
+            else -> 2 * (numElements ?: 1)
+        }
+    }
+
+}

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

@@ -1,19 +1,80 @@
 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
+import prog8.code.core.*
+import prog8.code.target.encodings.Encoder
+import prog8.code.target.zp.PETZeropage
+import java.nio.file.Path
 
 
-class PETTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+class PETTarget: ICompilationTarget,
+    IStringEncoding by Encoder(true),
+    IMemSizer by NormalMemSizer(Mflpt5.Companion.FLOAT_MEM_SIZE) {
+
     override val name = NAME
-    override val machine = PETMachineDefinition()
     override val defaultEncoding = Encoding.PETSCII
+    override val libraryPath = null
+    override val customLauncher: List<String> = emptyList()
+    override val additionalAssemblerOptions = null
+    override val defaultOutputType = OutputType.PRG
 
     companion object {
         const val NAME = "pet32"
     }
+
+    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 STARTUP_CODE_RESERVED_SIZE = 20u
+    override val PROGRAM_LOAD_ADDRESS = 0x0401u
+    override val PROGRAM_MEMTOP_ADDRESS = 0x8000u
+
+    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 convertFloatToBytes(num: Double): List<UByte> {
+        val m5 = Mflpt5.fromNumber(num)
+        return listOf(m5.b0, m5.b1, m5.b2, m5.b3, m5.b4)
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==5) { "need 5 bytes" }
+        val m5 = Mflpt5(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4])
+        return m5.toDouble()
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+        if(selectedEmulator!=1) {
+            System.err.println("The pet target only supports the main emulator (Vice).")
+            return
+        }
+
+        if(!quiet)
+            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)
+        if(!quiet)
+            processb.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)
+        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
+    }
+
 }

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

@@ -1,26 +1,111 @@
 package prog8.code.target
 
 import prog8.code.core.*
-import prog8.code.target.virtual.VirtualMachineDefinition
+import prog8.code.target.encodings.Encoder
+import java.nio.file.Path
+import kotlin.io.path.isReadable
+import kotlin.io.path.name
+import kotlin.io.path.readText
+
+class VMTarget: ICompilationTarget,
+    IStringEncoding by Encoder(false),
+    IMemSizer by NormalMemSizer(FLOAT_MEM_SIZE) {
 
-class VMTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
     override val name = NAME
-    override val machine = VirtualMachineDefinition()
     override val defaultEncoding = Encoding.ISO
+    override val libraryPath = null
+    override val customLauncher: List<String> = emptyList()
+    override val additionalAssemblerOptions = null
+    override val defaultOutputType = OutputType.PRG
 
     companion object {
         const val NAME = "virtual"
+        const val FLOAT_MEM_SIZE = 8             // 64-bits double
     }
 
-    override fun memorySize(dt: DataType): Int {
-        return when(dt) {
-            in ByteDatatypes -> 1
-            in WordDatatypes, in PassByReferenceDatatypes -> 2
-            DataType.FLOAT -> machine.FLOAT_MEM_SIZE
-            else -> throw IllegalArgumentException("invalid datatype")
+    override val cpu = CpuType.VIRTUAL
+
+    override val FLOAT_MAX_POSITIVE = Double.MAX_VALUE
+    override val FLOAT_MAX_NEGATIVE = -Double.MAX_VALUE
+    override val FLOAT_MEM_SIZE = VMTarget.FLOAT_MEM_SIZE
+    override val STARTUP_CODE_RESERVED_SIZE = 0u  // not actually used
+    override val PROGRAM_LOAD_ADDRESS = 0u      // not actually used
+    override val PROGRAM_MEMTOP_ADDRESS = 0xffffu  // 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.toDouble().toBits().toULong()
+        val hexStr = bits.toString(16).padStart(16, '0')
+        val parts = hexStr.chunked(2).map { "$$it" }
+        return parts.joinToString(", ")
+    }
+
+    override fun convertFloatToBytes(num: Double): List<UByte> {
+        val bits = num.toBits().toULong()
+        val hexStr = bits.toString(16).padStart(16, '0')
+        val parts = hexStr.chunked(2).map { it.toInt(16).toUByte() }
+        return parts
+    }
+
+    override fun convertBytesToFloat(bytes: List<UByte>): Double {
+        require(bytes.size==8) { "need 8 bytes" }
+        val b0 = bytes[0].toLong() shl (8*7)
+        val b1 = bytes[1].toLong() shl (8*6)
+        val b2 = bytes[2].toLong() shl (8*5)
+        val b3 = bytes[3].toLong() shl (8*4)
+        val b4 = bytes[4].toLong() shl (8*3)
+        val b5 = bytes[5].toLong() shl (8*2)
+        val b6 = bytes[6].toLong() shl (8*1)
+        val b7 = bytes[7].toLong() shl (8*0)
+        return Double.fromBits(b0 or b1 or b2 or b3 or b4 or b5 or b6 or b7)
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path, quiet: Boolean) {
+        if(!quiet)
+            println("\nStarting Virtual Machine...")
+
+        // to not have external module dependencies in our own module, we launch the virtual machine via reflection
+        val vm = Class.forName("prog8.vm.VmRunner").getDeclaredConstructor().newInstance() as IVirtualMachineRunner
+        val filename = programNameWithPath.name
+        if(programNameWithPath.isReadable()) {
+            vm.runProgram(programNameWithPath.readText(), quiet)
+        } else {
+            val withExt = programNameWithPath.resolveSibling("$filename.p8ir")
+            if(withExt.isReadable())
+                vm.runProgram(withExt.readText(), quiet)
+            else
+                throw java.nio.file.NoSuchFileException(withExt.name, null, "not a .p8ir file")
         }
     }
 
-    override fun memorySize(arrayDt: DataType, numElements: Int) =
-        memorySize(ArrayToElementTypes.getValue(arrayDt)) * numElements
+    override fun isIOAddress(address: UInt): Boolean = false
+
+    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
+        zeropage = VirtualZeropage(compilerOptions)
+        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
+    }
+}
+
+
+
+interface IVirtualMachineRunner {
+    fun runProgram(irSource: String, quiet: Boolean)
+}
+
+private class VirtualZeropage(options: CompilationOptions): Zeropage(options) {
+    override val SCRATCH_B1: UInt
+        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
+    override val SCRATCH_REG: UInt
+        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
+    override val SCRATCH_W1: UInt
+        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
+    override val SCRATCH_W2: UInt
+        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
 }

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

@@ -1,65 +0,0 @@
-package prog8.code.target.atari
-
-import prog8.code.core.*
-import java.nio.file.Path
-
-
-class AtariMachineDefinition: IMachineDefinition {
-
-    override val cpu = CpuType.CPU6502
-
-    override val FLOAT_MAX_POSITIVE = 9.999999999e97
-    override val FLOAT_MAX_NEGATIVE = -9.999999999e97
-    override val FLOAT_MEM_SIZE = 6
-    override val PROGRAM_LOAD_ADDRESS = 0x2000u
-
-    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
-
-    override fun getFloatAsmBytes(num: Number) = TODO("atari float asm bytes from number")
-
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return if (compilerOptions.output == OutputType.XEX)
-            listOf("syslib")
-        else
-            emptyList()
-    }
-
-    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
-        val emulatorName: String
-        val cmdline: List<String>
-        when(selectedEmulator) {
-            1 -> {
-                emulatorName = "atari800"
-                cmdline = listOf(emulatorName, "-xl", "-xl-rev", "2", "-nobasic", "-run", "${programNameWithPath}.xex")
-            }
-            2 -> {
-                emulatorName = "altirra"
-                cmdline = listOf("Altirra64.exe", "${programNameWithPath.normalize()}.xex")
-            }
-            else -> {
-                System.err.println("Atari target only supports atari800 and altirra emulators.")
-                return
-            }
-        }
-
-        // TODO monlist?
-
-        println("\nStarting Atari800XL emulator $emulatorName...")
-        val processb = ProcessBuilder(cmdline).inheritIO()
-        val process: Process = processb.start()
-        process.waitFor()
-    }
-
-    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0xd000u..0xdfffu        // TODO
-
-    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
-        zeropage = AtariZeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)
-    }
-}

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

@@ -1,57 +0,0 @@
-package prog8.code.target.atari
-
-import prog8.code.core.CompilationOptions
-import prog8.code.core.InternalCompilerException
-import prog8.code.core.Zeropage
-import prog8.code.core.ZeropageType
-
-class AtariZeropage(options: CompilationOptions) : Zeropage(options) {
-
-    override val SCRATCH_B1 = 0xcbu      // temp storage for a single byte
-    override val SCRATCH_REG = 0xccu     // temp storage for a register, must be B1+1
-    override val SCRATCH_W1 = 0xcdu      // temp storage 1 for a word  $cd+$ce
-    override val SCRATCH_W2 = 0xcfu      // temp storage 2 for a word  $cf+$d0        TODO is $d0 okay to use?
-
-    init {
-        if (options.floats) {
-            throw InternalCompilerException("Atari target doesn't yet support floating point routines")
-        }
-
-        if (options.floats && options.zeropage !in arrayOf(
-                ZeropageType.FLOATSAFE,
-                ZeropageType.BASICSAFE,
-                ZeropageType.DONTUSE
-            ))
-            throw InternalCompilerException("when floats are enabled, zero page type should be 'floatsafe' or 'basicsafe' or 'dontuse'")
-
-        when (options.zeropage) {
-            ZeropageType.FULL -> {
-                // TODO all atari usable zero page locations, except the ones used by the system's IRQ routine
-                free.addAll(0x00u..0xffu)
-                // TODO atari  free.removeAll(setOf(0xa0u, 0xa1u, 0xa2u, 0x91u, 0xc0u, 0xc5u, 0xcbu, 0xf5u, 0xf6u))        // these are updated by IRQ
-            }
-            ZeropageType.KERNALSAFE -> {
-                free.addAll(0x80u..0xffu)       // TODO
-            }
-            ZeropageType.BASICSAFE,
-            ZeropageType.FLOATSAFE -> {
-                free.addAll(0x80u..0xffu)       // TODO
-                free.removeAll(0xd4u .. 0xefu)      // floating point storage
-            }
-            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 atari can put the virtual regs in ZP")
-    }
-}

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

@@ -1,56 +0,0 @@
-package prog8.code.target.c128
-
-import prog8.code.core.*
-import prog8.code.target.C64Target
-import prog8.code.target.cbm.Mflpt5
-import java.nio.file.Path
-
-
-class C128MachineDefinition: 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 = 0x1c01u
-
-    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
-
-    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 c128 target only supports the main emulator (Vice).")
-            return
-        }
-
-        println("\nStarting C-128 emulator x128...")
-        val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
-        val cmdline = listOf("x128", "-silent", "-moncommands", viceMonlist,
-                "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
-        val processb = ProcessBuilder(cmdline).inheritIO()
-        val process: Process = processb.start()
-        process.waitFor()
-    }
-
-    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0xd000u..0xdfffu
-
-    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
-        zeropage = C128Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, UIntRange.EMPTY)    // TODO does the c128 have some of this somewhere?
-    }
-}

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

@@ -1,66 +0,0 @@
-package prog8.code.target.c64
-
-import prog8.code.core.*
-import prog8.code.target.C64Target
-import prog8.code.target.cbm.Mflpt5
-import java.io.IOException
-import java.nio.file.Path
-
-
-class C64MachineDefinition: 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 = 0x0801u
-
-    override val BSSHIGHRAM_START = 0xc000u
-    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
-
-    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 c64 target only supports the main emulator (Vice).")
-            return
-        }
-
-        for(emulator in listOf("x64sc", "x64")) {
-            println("\nStarting C-64 emulator $emulator...")
-            val viceMonlist = C64Target.viceMonListName(programNameWithPath.toString())
-            val cmdline = listOf(emulator, "-silent", "-moncommands", viceMonlist,
-                    "-autostartprgmode", "1", "-autostart-warp", "-autostart", "${programNameWithPath}.prg")
-            val processb = ProcessBuilder(cmdline).inheritIO()
-            val process: Process
-            try {
-                process=processb.start()
-            } catch(x: IOException) {
-                continue  // try the next emulator executable
-            }
-            process.waitFor()
-            break
-        }
-    }
-
-    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0xd000u..0xdfffu
-
-    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
-        zeropage = C64Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, 0xc000u until 0xd000u)
-    }
-
-}

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

@@ -1,18 +0,0 @@
-package prog8.code.target.cbm
-
-import prog8.code.core.*
-
-
-internal object CbmMemorySizer: IMemSizer {
-    override fun memorySize(dt: DataType): Int {
-        return when(dt) {
-            in ByteDatatypes -> 1
-            in WordDatatypes, in PassByReferenceDatatypes -> 2
-            DataType.FLOAT -> Mflpt5.FLOAT_MEM_SIZE
-            else -> throw IllegalArgumentException("invalid datatype")
-        }
-    }
-
-    override fun memorySize(arrayDt: DataType, numElements: Int) =
-        memorySize(ArrayToElementTypes.getValue(arrayDt)) * numElements
-}

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

@@ -1,68 +0,0 @@
-package prog8.code.target.cx16
-
-import prog8.code.core.*
-import prog8.code.target.C64Target
-import prog8.code.target.cbm.Mflpt5
-import java.nio.file.Path
-
-
-class CX16MachineDefinition: IMachineDefinition {
-
-    override val cpu = CpuType.CPU65c02
-
-    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 = 0x0801u
-
-    override val BSSHIGHRAM_START = 0xa000u     // hiram bank 1, 8Kb, assumed to be active
-    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
-
-    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) {
-        val emulator: String
-        val extraArgs: List<String>
-
-        when(selectedEmulator) {
-            1 -> {
-                emulator = "x16emu"
-                extraArgs = listOf("-debug")
-            }
-            2 -> {
-                emulator = "box16"
-                extraArgs = listOf("-sym", C64Target.viceMonListName(programNameWithPath.toString()))
-            }
-            else -> {
-                System.err.println("Cx16 target only supports x16emu and box16 emulators.")
-                return
-            }
-        }
-
-        println("\nStarting Commander X16 emulator $emulator...")
-        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()
-        process.waitFor()
-    }
-
-    override fun isIOAddress(address: UInt): Boolean = address==0u || address==1u || address in 0x9f00u..0x9fffu
-
-    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
-        zeropage = CX16Zeropage(compilerOptions)
-        golden = GoldenRam(compilerOptions, 0x0400u until 0x0800u)
-    }
-
-}

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

@@ -1,4 +1,4 @@
-package prog8.code.target.cbm
+package prog8.code.target.encodings
 
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
@@ -197,6 +197,7 @@ object AtasciiEncoding {
     fun encode(str: String): Result<List<UByte>, CharConversionException> {
         val mapped = str.map { chr ->
             when (chr) {
+                '\r' -> 0x9bu
                 '\u0000' -> 0u
                 in '\u8000'..'\u80ff' -> {
                     // special case: take the lower 8 bit hex value directly

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

@@ -0,0 +1,327 @@
+package prog8.code.target.encodings
+
+import com.github.michaelbull.result.Err
+import com.github.michaelbull.result.Ok
+import com.github.michaelbull.result.Result
+import java.io.CharConversionException
+
+object C64osEncoding {
+
+    // decoding:  from C64 OS Screencodes (0-255) to unicode
+    // character table from:
+    // https://www.c64os.com/c64os/usersguide/appendices#charactersets
+
+    private val decodingC64os = charArrayOf(
+        '@'     ,    //  @    0x00 -> COMMERCIAL AT
+        'a'     ,    //  a    0x01 -> LATIN SMALL LETTER A
+        'b'     ,    //  b    0x02 -> LATIN SMALL LETTER B
+        'c'     ,    //  c    0x03 -> LATIN SMALL LETTER C
+        'd'     ,    //  d    0x04 -> LATIN SMALL LETTER D
+        'e'     ,    //  e    0x05 -> LATIN SMALL LETTER E
+        'f'     ,    //  f    0x06 -> LATIN SMALL LETTER F
+        'g'     ,    //  g    0x07 -> LATIN SMALL LETTER G
+        'h'     ,    //  h    0x08 -> LATIN SMALL LETTER H
+        'i'     ,    //  i    0x09 -> LATIN SMALL LETTER I
+        'j'     ,    //  j    0x0A -> LATIN SMALL LETTER J
+        'k'     ,    //  k    0x0B -> LATIN SMALL LETTER K
+        'l'     ,    //  l    0x0C -> LATIN SMALL LETTER L
+        'm'     ,    //  m    0x0D -> LATIN SMALL LETTER M
+        'n'     ,    //  n    0x0E -> LATIN SMALL LETTER N
+        'o'     ,    //  o    0x0F -> LATIN SMALL LETTER O
+        'p'     ,    //  p    0x10 -> LATIN SMALL LETTER P
+        'q'     ,    //  q    0x11 -> LATIN SMALL LETTER Q
+        'r'     ,    //  r    0x12 -> LATIN SMALL LETTER R
+        's'     ,    //  s    0x13 -> LATIN SMALL LETTER S
+        't'     ,    //  t    0x14 -> LATIN SMALL LETTER T
+        'u'     ,    //  u    0x15 -> LATIN SMALL LETTER U
+        'v'     ,    //  v    0x16 -> LATIN SMALL LETTER V
+        'w'     ,    //  w    0x17 -> LATIN SMALL LETTER W
+        'x'     ,    //  x    0x18 -> LATIN SMALL LETTER X
+        'y'     ,    //  y    0x19 -> LATIN SMALL LETTER Y
+        'z'     ,    //  z    0x1A -> LATIN SMALL LETTER Z
+        '['     ,    //  [    0x1B -> LEFT SQUARE BRACKET
+        '\\'    ,    //  \    0x1C -> REVERSE SOLIDUS
+        ']'     ,    //  ]    0x1D -> RIGHT SQUARE BRACKET
+        '^'     ,    //  ^    0x1E -> CIRCUMFLEX
+        '_'     ,    //  _    0x1F -> UNDERSCORE
+        ' '     ,    //       0x20 -> SPACE
+        '!'     ,    //  !    0x21 -> EXCLAMATION MARK
+        '"'     ,    //  "    0x22 -> QUOTATION MARK
+        '#'     ,    //  #    0x23 -> NUMBER SIGN
+        '$'     ,    //  $    0x24 -> DOLLAR SIGN
+        '%'     ,    //  %    0x25 -> PERCENT SIGN
+        '&'     ,    //  &    0x26 -> AMPERSAND
+        '\''    ,    //  '    0x27 -> APOSTROPHE
+        '('     ,    //  (    0x28 -> LEFT PARENTHESIS
+        ')'     ,    //  )    0x29 -> RIGHT PARENTHESIS
+        '*'     ,    //  *    0x2A -> ASTERISK
+        '+'     ,    //  +    0x2B -> PLUS SIGN
+        ','     ,    //  ,    0x2C -> COMMA
+        '-'     ,    //  -    0x2D -> HYPHEN-MINUS
+        '.'     ,    //  .    0x2E -> FULL STOP
+        '/'     ,    //  /    0x2F -> SOLIDUS
+        '0'     ,    //  0    0x30 -> DIGIT ZERO
+        '1'     ,    //  1    0x31 -> DIGIT ONE
+        '2'     ,    //  2    0x32 -> DIGIT TWO
+        '3'     ,    //  3    0x33 -> DIGIT THREE
+        '4'     ,    //  4    0x34 -> DIGIT FOUR
+        '5'     ,    //  5    0x35 -> DIGIT FIVE
+        '6'     ,    //  6    0x36 -> DIGIT SIX
+        '7'     ,    //  7    0x37 -> DIGIT SEVEN
+        '8'     ,    //  8    0x38 -> DIGIT EIGHT
+        '9'     ,    //  9    0x39 -> DIGIT NINE
+        ':'     ,    //  :    0x3A -> COLON
+        ';'     ,    //  ;    0x3B -> SEMICOLON
+        '<'     ,    //  <    0x3C -> LESS-THAN SIGN
+        '='     ,    //  =    0x3D -> EQUALS SIGN
+        '>'     ,    //  >    0x3E -> GREATER-THAN SIGN
+        '?'     ,    //  ?    0x3F -> QUESTION MARK
+        '`'     ,    //  `    0x40 -> GRAVE ACCENT
+        'A'     ,    //  A    0x41 -> LATIN CAPITAL LETTER A
+        'B'     ,    //  B    0x42 -> LATIN CAPITAL LETTER B
+        'C'     ,    //  C    0x43 -> LATIN CAPITAL LETTER C
+        'D'     ,    //  D    0x44 -> LATIN CAPITAL LETTER D
+        'E'     ,    //  E    0x45 -> LATIN CAPITAL LETTER E
+        'F'     ,    //  F    0x46 -> LATIN CAPITAL LETTER F
+        'G'     ,    //  G    0x47 -> LATIN CAPITAL LETTER G
+        'H'     ,    //  H    0x48 -> LATIN CAPITAL LETTER H
+        'I'     ,    //  I    0x49 -> LATIN CAPITAL LETTER I
+        'J'     ,    //  J    0x4A -> LATIN CAPITAL LETTER J
+        'K'     ,    //  K    0x4B -> LATIN CAPITAL LETTER K
+        'L'     ,    //  L    0x4C -> LATIN CAPITAL LETTER L
+        'M'     ,    //  M    0x4D -> LATIN CAPITAL LETTER M
+        'N'     ,    //  N    0x4E -> LATIN CAPITAL LETTER N
+        'O'     ,    //  O    0x4F -> LATIN CAPITAL LETTER O
+        'P'     ,    //  P    0x50 -> LATIN CAPITAL LETTER P
+        'Q'     ,    //  Q    0x51 -> LATIN CAPITAL LETTER Q
+        'R'     ,    //  R    0x52 -> LATIN CAPITAL LETTER R
+        'S'     ,    //  S    0x53 -> LATIN CAPITAL LETTER S
+        'T'     ,    //  T    0x54 -> LATIN CAPITAL LETTER T
+        'U'     ,    //  U    0x55 -> LATIN CAPITAL LETTER U
+        'V'     ,    //  V    0x56 -> LATIN CAPITAL LETTER V
+        'W'     ,    //  W    0x57 -> LATIN CAPITAL LETTER W
+        'X'     ,    //  X    0x58 -> LATIN CAPITAL LETTER X
+        'Y'     ,    //  Y    0x59 -> LATIN CAPITAL LETTER Y
+        'Z'     ,    //  Z    0x5A -> LATIN CAPITAL LETTER Z
+        '{'     ,    //  {    0x5B -> LEFT BRACE
+        '|'     ,    //  |    0x5C -> VERTICAL BAR
+        '}'     ,    //  }    0x5D -> RIGHT BRACE
+        '~'     ,    //  ~    0x5E -> TILDE
+        '\ufffe',    //       0x5F -> RESERVED
+        '\u00a0',    //       0x60 -> NO-BREAK SPACE (TRANSPARENT)
+        '\ufffe',    //       0x61 -> COMMODORE SYMBOL
+        '\u2191',    //  ↑    0x62 -> UP ARROW
+        '\u2193',    //  ↓    0x63 -> DOWN ARROW
+        '\u2190',    //  ←    0x64 -> LEFT ARROW
+        '\u2192',    //  →    0x65 -> RIGHT ARROW
+        '\u231A',    //  ⌚   0x66 -> WATCH (ANALOG CLOCKFACE)
+        '\u21BB',    //  ↻    0x67 -> CYCLE ARROWS
+        '\u2026',    //  …    0x68 -> ELLIPSIS
+        '\u25a7',    //  ▧    0x69 -> DIAGNONAL STRIPES
+        '\u2610',    //  ☐    0x6A -> CHECKBOX UNCHECKED
+        '\u2611',    //  ☑    0x6B -> CHECKBOX CHECKED
+        '\ufffe',    //       0x6C -> RADIO BUTTON UNSELECTED
+        '\ufffe',    //       0x6D -> RADIO BUTTON SELECTED
+        '\ufffe',    //       0x6E -> UTILITY CLOSE BUTTON
+        '\ufffe',    //       0x6F -> UTILITY TITLE BAR
+        '\u00a9',    //  ©    0x70 -> COPYRIGHT
+        '\u2713',    //  ✓    0x71 -> CHECKMARK
+        '\u2261',    //  ≡    0x72 -> THREE HORIZONTAL STRIPES
+        '\ufffe',    //       0x73 -> TICK TRACK
+        '\ufffe',    //       0x74 -> TICK TRACK NUB
+        '\ufffe',    //       0x75 -> TAB CORNER
+        '\u2980',    //  ⦀    0x76 -> THREE VERTICAL STRIPES
+        '\ufffe',    //       0x77 -> CUSTOM 1
+        '\ufffe',    //       0x78 -> CUSTOM 2
+        '\ufffe',    //       0x79 -> CUSTOM 3
+        '\ufffe',    //       0x7A -> CUSTOM 4
+        '\ufffe',    //       0x7B -> CUSTOM 5
+        '\ufffe',    //       0x7C -> CUSTOM 6
+        '\ufffe',    //       0x7D -> CUSTOM 7
+        '\ufffe',    //       0x7E -> CUSTOM 8
+        '\ufffe',    //       0x7F -> CUSTOM 9
+        '\ufffe',    //       0x80 -> REVERSED COMMERCIAL AT
+        '\ufffe',    //       0x81 -> REVERSED LATIN SMALL LETTER A
+        '\ufffe',    //       0x82 -> REVERSED LATIN SMALL LETTER B
+        '\ufffe',    //       0x83 -> REVERSED LATIN SMALL LETTER C
+        '\ufffe',    //       0x84 -> REVERSED LATIN SMALL LETTER D
+        '\ufffe',    //       0x85 -> REVERSED LATIN SMALL LETTER E
+        '\ufffe',    //       0x86 -> REVERSED LATIN SMALL LETTER F
+        '\ufffe',    //       0x87 -> REVERSED LATIN SMALL LETTER G
+        '\ufffe',    //       0x88 -> REVERSED LATIN SMALL LETTER H
+        '\ufffe',    //       0x89 -> REVERSED LATIN SMALL LETTER I
+        '\ufffe',    //       0x8A -> REVERSED LATIN SMALL LETTER J
+        '\ufffe',    //       0x8B -> REVERSED LATIN SMALL LETTER K
+        '\ufffe',    //       0x8C -> REVERSED LATIN SMALL LETTER L
+        '\ufffe',    //       0x8D -> REVERSED LATIN SMALL LETTER M
+        '\ufffe',    //       0x8E -> REVERSED LATIN SMALL LETTER N
+        '\ufffe',    //       0x8F -> REVERSED LATIN SMALL LETTER O
+        '\ufffe',    //       0x90 -> REVERSED LATIN SMALL LETTER P
+        '\ufffe',    //       0x91 -> REVERSED LATIN SMALL LETTER Q
+        '\ufffe',    //       0x92 -> REVERSED LATIN SMALL LETTER R
+        '\ufffe',    //       0x93 -> REVERSED LATIN SMALL LETTER S
+        '\ufffe',    //       0x94 -> REVERSED LATIN SMALL LETTER T
+        '\ufffe',    //       0x95 -> REVERSED LATIN SMALL LETTER U
+        '\ufffe',    //       0x96 -> REVERSED LATIN SMALL LETTER V
+        '\ufffe',    //       0x97 -> REVERSED LATIN SMALL LETTER W
+        '\ufffe',    //       0x98 -> REVERSED LATIN SMALL LETTER X
+        '\ufffe',    //       0x99 -> REVERSED LATIN SMALL LETTER Y
+        '\ufffe',    //       0x9A -> REVERSED LATIN SMALL LETTER Z
+        '\ufffe',    //       0x9B -> REVERSED LEFT SQUARE BRACKET
+        '\ufffe',    //       0x9C -> REVERSED REVERSE SOLIDUS
+        '\ufffe',    //       0x9D -> REVERSED RIGHT SQUARE BRACKET
+        '\ufffe',    //       0x9E -> REVERSED CIRCUMFLEX
+        '\ufffe',    //       0x9F -> REVERSED UNDERSCORE
+        '\ufffe',    //       0xA0 -> REVERSED SPACE
+        '\ufffe',    //       0xA1 -> REVERSED EXCLAMATION MARK
+        '\ufffe',    //       0xA2 -> REVERSED QUOTATION MARK
+        '\ufffe',    //       0xA3 -> REVERSED NUMBER SIGN
+        '\ufffe',    //       0xA4 -> REVERSED DOLLAR SIGN
+        '\ufffe',    //       0xA5 -> REVERSED PERCENT SIGN
+        '\ufffe',    //       0xA6 -> REVERSED AMPERSAND
+        '\ufffe',    //       0xA7 -> REVERSED APOSTROPHE
+        '\ufffe',    //       0xA8 -> REVERSED LEFT PARENTHESIS
+        '\ufffe',    //       0xA9 -> REVERSED RIGHT PARENTHESIS
+        '\ufffe',    //       0xAA -> REVERSED ASTERISK
+        '\ufffe',    //       0xAB -> REVERSED PLUS SIGN
+        '\ufffe',    //       0xAC -> REVERSED COMMA
+        '\ufffe',    //       0xAD -> REVERSED HYPHEN-MINUS
+        '\ufffe',    //       0xAE -> REVERSED FULL STOP
+        '\ufffe',    //       0xAF -> REVERSED SOLIDUS
+        '\ufffe',    //       0xB0 -> REVERSED DIGIT ZERO
+        '\ufffe',    //       0xB1 -> REVERSED DIGIT ONE
+        '\ufffe',    //       0xB2 -> REVERSED DIGIT TWO
+        '\ufffe',    //       0xB3 -> REVERSED DIGIT THREE
+        '\ufffe',    //       0xB4 -> REVERSED DIGIT FOUR
+        '\ufffe',    //       0xB5 -> REVERSED DIGIT FIVE
+        '\ufffe',    //       0xB6 -> REVERSED DIGIT SIX
+        '\ufffe',    //       0xB7 -> REVERSED DIGIT SEVEN
+        '\ufffe',    //       0xB8 -> REVERSED DIGIT EIGHT
+        '\ufffe',    //       0xB9 -> REVERSED DIGIT NINE
+        '\ufffe',    //       0xBA -> REVERSED COLON
+        '\ufffe',    //       0xBB -> REVERSED SEMICOLON
+        '\ufffe',    //       0xBC -> REVERSED LESS-THAN SIGN
+        '\ufffe',    //       0xBD -> REVERSED EQUALS SIGN
+        '\ufffe',    //       0xBE -> REVERSED GREATER-THAN SIGN
+        '\ufffe',    //       0xBF -> REVERSED QUESTION MARK
+        '\ufffe',    //       0xC0 -> REVERSED GRAVE ACCENT
+        '\ufffe',    //       0xC1 -> REVERSED LATIN CAPITAL LETTER A
+        '\ufffe',    //       0xC2 -> REVERSED LATIN CAPITAL LETTER B
+        '\ufffe',    //       0xC3 -> REVERSED LATIN CAPITAL LETTER C
+        '\ufffe',    //       0xC4 -> REVERSED LATIN CAPITAL LETTER D
+        '\ufffe',    //       0xC5 -> REVERSED LATIN CAPITAL LETTER E
+        '\ufffe',    //       0xC6 -> REVERSED LATIN CAPITAL LETTER F
+        '\ufffe',    //       0xC7 -> REVERSED LATIN CAPITAL LETTER G
+        '\ufffe',    //       0xC8 -> REVERSED LATIN CAPITAL LETTER H
+        '\ufffe',    //       0xC9 -> REVERSED LATIN CAPITAL LETTER I
+        '\ufffe',    //       0xCA -> REVERSED LATIN CAPITAL LETTER J
+        '\ufffe',    //       0xCB -> REVERSED LATIN CAPITAL LETTER K
+        '\ufffe',    //       0xCC -> REVERSED LATIN CAPITAL LETTER L
+        '\ufffe',    //       0xCD -> REVERSED LATIN CAPITAL LETTER M
+        '\ufffe',    //       0xCE -> REVERSED LATIN CAPITAL LETTER N
+        '\ufffe',    //       0xCF -> REVERSED LATIN CAPITAL LETTER O
+        '\ufffe',    //       0xD0 -> REVERSED LATIN CAPITAL LETTER P
+        '\ufffe',    //       0xD1 -> REVERSED LATIN CAPITAL LETTER Q
+        '\ufffe',    //       0xD2 -> REVERSED LATIN CAPITAL LETTER R
+        '\ufffe',    //       0xD3 -> REVERSED LATIN CAPITAL LETTER S
+        '\ufffe',    //       0xD4 -> REVERSED LATIN CAPITAL LETTER T
+        '\ufffe',    //       0xD5 -> REVERSED LATIN CAPITAL LETTER U
+        '\ufffe',    //       0xD6 -> REVERSED LATIN CAPITAL LETTER V
+        '\ufffe',    //       0xD7 -> REVERSED LATIN CAPITAL LETTER W
+        '\ufffe',    //       0xD8 -> REVERSED LATIN CAPITAL LETTER X
+        '\ufffe',    //       0xD9 -> REVERSED LATIN CAPITAL LETTER Y
+        '\ufffe',    //       0xDA -> REVERSED LATIN CAPITAL LETTER Z
+        '\ufffe',    //       0xDB -> REVERSED LEFT BRACE
+        '\ufffe',    //       0xDC -> REVERSED VERTICAL BAR
+        '\ufffe',    //       0xDD -> REVERSED RIGHT BRACE
+        '\ufffe',    //       0xDE -> REVERSED TILDE
+        '\ufffe',    //       0xDF -> RESERVED
+        '\ufffe',    //       0xE0 -> RESERVED
+        '\ufffe',    //       0xE1 -> REVERSED COMMODORE SYMBOL
+        '\ufffe',    //       0xE2 -> REVERSED UP ARROW
+        '\ufffe',    //       0xE3 -> REVERSED DOWN ARROW
+        '\ufffe',    //       0xE4 -> REVERSED LEFT ARROW
+        '\ufffe',    //       0xE5 -> REVERSED RIGHT ARROW
+        '\ufffe',    //       0xE6 -> REVERSED ANALOG CLOCKFACE
+        '\ufffe',    //       0xE7 -> REVERSED CYCLE ARROWS
+        '\ufffe',    //       0xE8 -> REVERSED ELLIPSIS
+        '\ufffe',    //       0xE9 -> REVERSED DIAGONAL STRIPES
+        '\ufffe',    //       0xEA -> REVERSED CHECKBOX UNCHECKED
+        '\ufffe',    //       0xEB -> REVERSED CHECKBOX CHECKED
+        '\ufffe',    //       0xEC -> REVERSED RADIO BUTTON UNSELECTED
+        '\ufffe',    //       0xED -> REVERSED RADIO BUTTON SELECTED
+        '\ufffe',    //       0xEE -> MEMORY CHIP ICON
+        '\u21e7',    //  ⇧    0xEF -> SHIFT SYMBOL
+        '\ufffe',    //       0xF0 -> REVERSED COPYRIGHT SYMBOL
+        '\ufffe',    //       0xF1 -> REVERSED CHECKMARK
+        '\ufffe',    //       0xF2 -> REVERSED THREE HORIZONTAL STRIPES
+        '\ufffe',    //       0xF3 -> REVERSED TICK TRACK
+        '\ufffe',    //       0xF4 -> REVERSED TICK TRACK NUB
+        '\ufffe',    //       0xF5 -> REVERSED TAB CORNER
+        '\ufffe',    //       0xF6 -> REVERSED THREE VERTICAL STRIPES
+        '\ufffe',    //       0xF7 -> CUSTOM 10
+        '\ufffe',    //       0xF8 -> CUSTOM 11
+        '\ufffe',    //       0xF9 -> CUSTOM 12
+        '\ufffe',    //       0xFA -> CUSTOM 13
+        '\ufffe',    //       0xFB -> CUSTOM 14
+        '\ufffe',    //       0xFC -> CUSTOM 15
+        '\ufffe',    //       0xFD -> CUSTOM 16
+        '\ufffe',    //       0xFE -> CUSTOM 17
+        '\ufffe'     //       0xFF -> CUSTOM 18
+    )
+
+    // encoding:  from unicode to C64 OS Screencodes (0-255)
+    private val encodingC64os = decodingC64os.withIndex().associate{it.value to it.index}
+
+    private fun replaceSpecial(chr: Char): Char =
+        when(chr) {
+            '\r' -> '\n'        // to make \r (carriage returrn) equivalent to \n (line feed): RETURN ($0d)
+            else -> chr
+        }
+    
+    fun encode(text: String, lowercase: Boolean = false): Result<List<UByte>, CharConversionException> {
+        fun encodeChar(chr3: Char, lowercase: Boolean): UByte {
+            val chr = replaceSpecial(chr3)
+            val screencode = encodingC64os[chr]
+            return screencode?.toUByte() ?: when (chr) {
+                '\u0000' -> 0u
+                '\n' -> 13u
+                in '\u8000'..'\u80ff' -> {
+                    // special case: take the lower 8 bit hex value directly
+                    (chr.code - 0x8000).toUByte()
+                }
+                else -> {
+                    if(chr.isISOControl())
+                        throw CharConversionException("no c64os character for char #${chr.code}")
+                    else
+                        throw CharConversionException("no c64os character for char #${chr.code} '${chr}'")
+                }
+            }
+        }
+
+        return try {
+            Ok(text.map {
+                try {
+                    encodeChar(it, lowercase)
+                } catch (x: CharConversionException) {
+                    encodeChar(it, !lowercase)
+                }
+            })
+        } catch(cx: CharConversionException) {
+            Err(cx)
+        }
+    }
+
+    fun decode(screencode: Iterable<UByte>, lowercase: Boolean = false): Result<String, CharConversionException> {
+        return try {
+            Ok(screencode.map {
+                val code = it.toInt()
+                if(code<0 || code>= decodingC64os.size)
+                    throw CharConversionException("c64os $code out of range 0..${decodingC64os.size-1}")
+                decodingC64os[code]
+            }.joinToString(""))
+        } catch(ce: CharConversionException) {
+            Err(ce)
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+package prog8.code.target.encodings
+
+import com.github.michaelbull.result.Err
+import com.github.michaelbull.result.Ok
+import com.github.michaelbull.result.Result
+import java.io.CharConversionException
+import java.nio.charset.Charset
+
+object Cp437Encoding {
+    val charset: Charset = Charset.forName("IBM437")
+
+    fun encode(str: String): Result<List<UByte>, CharConversionException> {
+        return try {
+            val mapped = str.map { chr ->
+                when (chr) {
+                    '\u0000' -> 0u
+                    '\u00a0' -> 255u
+                    '☺' -> 1u
+                    '☻' -> 2u
+                    '♥' -> 3u
+                    '♦' -> 4u
+                    '♣' -> 5u
+                    '♠' -> 6u
+                    '•' -> 7u
+                    '◘' -> 8u
+                    '○' -> 9u
+                    '◙' -> 10u
+                    '♂' -> 11u
+                    '♀' -> 12u
+                    '♪' -> 13u
+                    '♫' -> 14u
+                    '☼' -> 15u
+                    '►' -> 16u
+                    '◄' -> 17u
+                    '↕' -> 18u
+                    '‼' -> 19u
+                    '¶' -> 20u
+                    '§' -> 21u
+                    '▬' -> 22u
+                    '↨' -> 23u
+                    '↑' -> 24u
+                    '↓' -> 25u
+                    '→' -> 26u
+                    '←' -> 27u
+                    '∟' -> 28u
+                    '↔' -> 29u
+                    '▲' -> 30u
+                    '▼' -> 31u
+                    in '\u8000'..'\u80ff' -> {
+                        // special case: take the lower 8 bit hex value directly
+                        (chr.code - 0x8000).toUByte()
+                    }
+                    else -> charset.encode(chr.toString())[0].toUByte()
+                }
+            }
+            Ok(mapped)
+        } catch (ce: CharConversionException) {
+            Err(ce)
+        }
+    }
+
+    fun decode(bytes: Iterable<UByte>): Result<String, CharConversionException> {
+        return try {
+            Ok(String(bytes.map { it.toByte() }.toByteArray(), charset))
+        } catch (ce: CharConversionException) {
+            Err(ce)
+        }
+    }
+}

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

@@ -1,23 +1,24 @@
-package prog8.code.target
+package prog8.code.target.encodings
 
 import com.github.michaelbull.result.fold
 import prog8.code.core.Encoding
 import prog8.code.core.IStringEncoding
 import prog8.code.core.InternalCompilerException
-import prog8.code.target.cbm.AtasciiEncoding
-import prog8.code.target.cbm.IsoEncoding
-import prog8.code.target.cbm.PetsciiEncoding
 
-
-object Encoder: IStringEncoding {
+class Encoder(val newlineToCarriageReturn: Boolean): 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)
             Encoding.SCREENCODES -> PetsciiEncoding.encodeScreencode(str, true)
-            Encoding.ISO -> IsoEncoding.encode(str)
+            Encoding.ISO -> IsoEncoding.encode(str, newlineToCarriageReturn)
+            Encoding.ISO5 -> IsoCyrillicEncoding.encode(str, newlineToCarriageReturn)
+            Encoding.ISO16 -> IsoEasternEncoding.encode(str, newlineToCarriageReturn)
+            Encoding.CP437 -> Cp437Encoding.encode(str)
+            Encoding.KATAKANA -> KatakanaEncoding.encode(str, newlineToCarriageReturn)
             Encoding.ATASCII -> AtasciiEncoding.encode(str)
+            Encoding.C64OS -> C64osEncoding.encode(str)
             else -> throw InternalCompilerException("unsupported encoding $encoding")
         }
         return coded.fold(
@@ -29,8 +30,13 @@ object Encoder: IStringEncoding {
         val decoded = when(encoding) {
             Encoding.PETSCII -> PetsciiEncoding.decodePetscii(bytes, true)
             Encoding.SCREENCODES -> PetsciiEncoding.decodeScreencode(bytes, true)
-            Encoding.ISO -> IsoEncoding.decode(bytes)
+            Encoding.ISO -> IsoEncoding.decode(bytes, newlineToCarriageReturn)
+            Encoding.ISO5 -> IsoCyrillicEncoding.decode(bytes, newlineToCarriageReturn)
+            Encoding.ISO16 -> IsoEasternEncoding.decode(bytes, newlineToCarriageReturn)
+            Encoding.CP437 -> Cp437Encoding.decode(bytes)
+            Encoding.KATAKANA -> KatakanaEncoding.decode(bytes, newlineToCarriageReturn)
             Encoding.ATASCII -> AtasciiEncoding.decode(bytes)
+            Encoding.C64OS -> C64osEncoding.decode(bytes)
             else -> throw InternalCompilerException("unsupported encoding $encoding")
         }
         return decoded.fold(

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

@@ -1,4 +1,4 @@
-package prog8.code.target.cbm
+package prog8.code.target.encodings
 
 import com.github.michaelbull.result.Err
 import com.github.michaelbull.result.Ok
@@ -6,14 +6,16 @@ import com.github.michaelbull.result.Result
 import java.io.CharConversionException
 import java.nio.charset.Charset
 
-object IsoEncoding {
-    val charset: Charset = Charset.forName("ISO-8859-15")
 
-    fun encode(str: String): Result<List<UByte>, CharConversionException> {
+open class IsoEncodingBase(charsetName: String) {
+    val charset: Charset = Charset.forName(charsetName)
+
+    fun encode(str: String, newlineToCarriageReturn: Boolean): Result<List<UByte>, CharConversionException> {
         return try {
             val mapped = str.map { chr ->
                 when (chr) {
                     '\u0000' -> 0u
+                    '\n' -> if(newlineToCarriageReturn) 13u else 10u
                     in '\u8000'..'\u80ff' -> {
                         // special case: take the lower 8 bit hex value directly
                         (chr.code - 0x8000).toUByte()
@@ -27,11 +29,21 @@ object IsoEncoding {
         }
     }
 
-    fun decode(bytes: Iterable<UByte>): Result<String, CharConversionException> {
+    fun decode(bytes: Iterable<UByte>, newlineToCarriageReturn: Boolean): Result<String, CharConversionException> {
         return try {
-            Ok(String(bytes.map { it.toByte() }.toByteArray(), charset))
+            Ok(String(bytes.map {
+                when(it) {
+                    13u.toUByte() -> if(newlineToCarriageReturn) 10 else 13
+                    else -> it.toByte()
+                }
+            }.toByteArray(), charset))
         } catch (ce: CharConversionException) {
             Err(ce)
         }
     }
 }
+
+
+object IsoEncoding: IsoEncodingBase("ISO-8859-15")
+object IsoCyrillicEncoding: IsoEncodingBase("ISO-8859-5")
+object IsoEasternEncoding: IsoEncodingBase("ISO-8859-16")

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

@@ -0,0 +1,128 @@
+package prog8.code.target.encodings
+
+import com.github.michaelbull.result.Err
+import com.github.michaelbull.result.Ok
+import com.github.michaelbull.result.Result
+import java.io.CharConversionException
+import java.nio.charset.Charset
+
+
+object JapaneseCharacterConverter {
+    // adapted from https://github.com/raminduw/Japanese-Character-Converter
+
+    private val ZENKAKU_KATAKANA = charArrayOf(
+        'ァ', 'ア', 'ィ', 'イ', 'ゥ',
+        'ウ', 'ェ', 'エ', 'ォ', 'オ', 'カ', 'ガ', 'キ', 'ギ', 'ク', 'グ', 'ケ', 'ゲ',
+        'コ', 'ゴ', 'サ', 'ザ', 'シ', 'ジ', 'ス', 'ズ', 'セ', 'ゼ', 'ソ', 'ゾ', 'タ',
+        'ダ', 'チ', 'ヂ', 'ッ', 'ツ', 'ヅ', 'テ', 'デ', 'ト', 'ド', 'ナ', 'ニ', 'ヌ',
+        'ネ', 'ノ', 'ハ', 'バ', 'パ', 'ヒ', 'ビ', 'ピ', 'フ', 'ブ', 'プ', 'ヘ', 'ベ',
+        'ペ', 'ホ', 'ボ', 'ポ', 'マ', 'ミ', 'ム', 'メ', 'モ', 'ャ', 'ヤ', 'ュ', 'ユ',
+        'ョ', 'ヨ', 'ラ', 'リ', 'ル', 'レ', 'ロ', 'ヮ', 'ワ', 'ヰ', 'ヱ', 'ヲ', 'ン',
+        'ヴ', 'ヵ', 'ヶ'
+    )
+
+    private val HANKAKU_HIRAGANA = charArrayOf(
+        'ぁ', 'あ', 'ぃ', 'い', 'ぅ', 'う', 'ぇ', 'え',
+        'ぉ', 'お', 'か', 'が', 'き', 'ぎ', 'く', 'ぐ',
+        'け', 'げ', 'こ', 'ご', 'さ', 'ざ', 'し', 'じ',
+        'す', 'ず', 'せ', 'ぜ', 'そ', 'ぞ', 'た', 'だ',
+        'ち', 'ぢ', 'っ', 'つ', 'づ', 'て', 'で', 'と',
+        'ど', 'な', 'に', 'ぬ', 'ね', 'の', 'は', 'ば',
+        'ぱ', 'ひ', 'び', 'ぴ', 'ふ', 'ぶ', 'ぷ', 'へ',
+        'べ', 'ぺ', 'ほ', 'ぼ', 'ぽ', 'ま', 'み', 'む',
+        'め', 'も', 'ゃ', 'や', 'ゅ', 'ゆ', 'ょ', 'よ',
+        'ら', 'り', 'る', 'れ', 'ろ', 'ゎ', 'わ', 'ゐ',
+        'ゑ', 'を', 'ん', 'ゔ', 'ゕ', 'ゖ'
+    )
+
+    private val HANKAKU_KATAKANA = arrayOf(
+        "ｧ", "ｱ", "ｨ", "ｲ", "ｩ",
+        "ｳ", "ｪ", "ｴ", "ｫ", "ｵ", "ｶ", "ｶﾞ", "ｷ", "ｷﾞ", "ｸ", "ｸﾞ", "ｹ",
+        "ｹﾞ", "ｺ", "ｺﾞ", "ｻ", "ｻﾞ", "ｼ", "ｼﾞ", "ｽ", "ｽﾞ", "ｾ", "ｾﾞ", "ｿ",
+        "ｿﾞ", "ﾀ", "ﾀﾞ", "ﾁ", "ﾁﾞ", "ｯ", "ﾂ", "ﾂﾞ", "ﾃ", "ﾃﾞ", "ﾄ", "ﾄﾞ",
+        "ﾅ", "ﾆ", "ﾇ", "ﾈ", "ﾉ", "ﾊ", "ﾊﾞ", "ﾊﾟ", "ﾋ", "ﾋﾞ", "ﾋﾟ", "ﾌ",
+        "ﾌﾞ", "ﾌﾟ", "ﾍ", "ﾍﾞ", "ﾍﾟ", "ﾎ", "ﾎﾞ", "ﾎﾟ", "ﾏ", "ﾐ", "ﾑ", "ﾒ",
+        "ﾓ", "ｬ", "ﾔ", "ｭ", "ﾕ", "ｮ", "ﾖ", "ﾗ", "ﾘ", "ﾙ", "ﾚ", "ﾛ", "ﾜ",
+        "ﾜ", "ｲ", "ｴ", "ｦ", "ﾝ", "ｳﾞ", "ｶ", "ｹ"
+    )
+
+    private val ZENKAKU_KATAKANA_FIRST_CHAR_CODE = ZENKAKU_KATAKANA.first().code
+    private val HANKAKU_HIRAGANA_FIRST_CHAR_CODE = HANKAKU_HIRAGANA.first().code
+
+    private fun zenkakuKatakanaToHankakuKatakana(c: Char): String = if (c in ZENKAKU_KATAKANA) HANKAKU_KATAKANA[c.code - ZENKAKU_KATAKANA_FIRST_CHAR_CODE] else c.toString()
+    private fun hankakuKatakanaToZenkakuKatakana(c: Char): Char = if (c in HANKAKU_HIRAGANA) ZENKAKU_KATAKANA[c.code - HANKAKU_HIRAGANA_FIRST_CHAR_CODE] else c
+
+    fun zenkakuKatakanaToHankakuKatakana(s: String): String = buildString {
+        for (element in s) {
+            val converted = hankakuKatakanaToZenkakuKatakana(element)
+            val convertedChar = zenkakuKatakanaToHankakuKatakana(converted)
+            append(convertedChar)
+        }
+    }
+}
+
+object KatakanaEncoding {
+    val charset: Charset = Charset.forName("JIS_X0201")
+
+    fun encode(str: String, newlineToCarriageReturn: Boolean): Result<List<UByte>, CharConversionException> {
+        return try {
+            val mapped = str.map { chr ->
+                when (chr) {
+                    '\n' -> if(newlineToCarriageReturn) 13u else 10u
+
+                    '\u0000' -> 0u
+                    '\u00a0' -> 0xa0u // $a0 isn't technically a part of JIS X 0201 spec, and so we need to handle this ourselves
+
+                    '♥' -> 0xe3u
+                    '♦' -> 0xe4u
+                    '♣' -> 0xe5u
+                    '♠' -> 0xe6u
+
+                    '大' -> 0xeau
+                    '中' -> 0xebu
+                    '小' -> 0xecu
+                    '百' -> 0xedu
+                    '千' -> 0xeeu
+                    '万' -> 0xefu
+                    '♪' -> 0xf0u
+                    '土' -> 0xf1u
+                    '金' -> 0xf2u
+                    '木' -> 0xf3u
+                    '水' -> 0xf4u
+                    '火' -> 0xf5u
+                    '月' -> 0xf6u
+                    '日' -> 0xf7u
+                    '時' -> 0xf8u
+                    '分' -> 0xf9u
+                    '秒' -> 0xfau
+                    '年' -> 0xfbu
+                    '円' -> 0xfcu
+                    '人' -> 0xfdu
+                    '生' -> 0xfeu
+                    '〒' -> 0xffu
+                    in '\u8000'..'\u80ff' -> {
+                        // special case: take the lower 8 bit hex value directly
+                        (chr.code - 0x8000).toUByte()
+                    }
+                    else -> charset.encode(chr.toString())[0].toUByte()
+                }
+            }
+            Ok(mapped)
+        } catch (ce: CharConversionException) {
+            Err(ce)
+        }
+    }
+
+    fun decode(bytes: Iterable<UByte>, newlineToCarriageReturn: Boolean): Result<String, CharConversionException> {
+        return try {
+            Ok(String(bytes.map {
+                when(it) {
+                    13u.toUByte() -> if(newlineToCarriageReturn) 10 else 13
+                    else -> it.toByte()
+                }
+            }.toByteArray(), charset))
+        } catch (ce: CharConversionException) {
+            Err(ce)
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-package prog8.code.target.cbm
+package prog8.code.target.encodings
 
 import com.github.michaelbull.result.Err
 import com.github.michaelbull.result.Ok
@@ -7,7 +7,7 @@ import java.io.CharConversionException
 
 object PetsciiEncoding {
 
-    // decoding:  from Petscii/Screencodes (0-255) to unicode
+    // decoding:  from Petscii/Screencodes (0-255) to Unicode
     // character tables used from https://github.com/irmen/cbmcodecs2
 
     private val decodingPetsciiLowercase = charArrayOf(
@@ -21,7 +21,7 @@ object PetsciiEncoding {
         '\ufffe',    //       0x07 -> UNDEFINED
         '\uf118',    //       0x08 -> DISABLE CHARACTER SET SWITCHING (CUS)
         '\uf119',    //       0x09 -> ENABLE CHARACTER SET SWITCHING (CUS)
-        '\ufffe',    //       0x0A -> UNDEFINED
+        '\n',        //       0x0A -> LINE FEED (RETURN)
         '\ufffe',    //       0x0B -> UNDEFINED
         '\ufffe',    //       0x0C -> UNDEFINED
         '\n'    ,    //       0x0D -> LINE FEED (RETURN)
@@ -1089,7 +1089,7 @@ object PetsciiEncoding {
             Ok(text.map {
                 try {
                     encodeChar(it, lowercase)
-                } catch (x: CharConversionException) {
+                } catch (_: CharConversionException) {
                     encodeChar(it, !lowercase)
                 }
             })
@@ -1117,6 +1117,8 @@ object PetsciiEncoding {
             val screencode = if(lowercase) encodingScreencodeLowercase[chr] else encodingScreencodeUppercase[chr]
             return screencode?.toUByte() ?: when (chr) {
                 '\u0000' -> 0u
+                '\n' -> 141u
+                '\r' -> 141u
                 in '\u8000'..'\u80ff' -> {
                     // special case: take the lower 8 bit hex value directly
                     (chr.code - 0x8000).toUByte()
@@ -1135,7 +1137,7 @@ object PetsciiEncoding {
             Ok(text.map {
                 try {
                     encodeChar(it, lowercase)
-                } catch (x: CharConversionException) {
+                } catch (_: CharConversionException) {
                     encodeChar(it, !lowercase)
                 }
             })
@@ -1157,16 +1159,16 @@ object PetsciiEncoding {
         }
     }
 
-    fun petscii2scr(petscii_code: UByte, inverseVideo: Boolean): Result<UByte, CharConversionException> {
+    fun petscii2scr(petsciicode: UByte, inverseVideo: Boolean): Result<UByte, CharConversionException> {
         val code: UInt = when {
-            petscii_code <= 0x1fu -> petscii_code + 128u
-            petscii_code <= 0x3fu -> petscii_code.toUInt()
-            petscii_code <= 0x5fu -> petscii_code - 64u
-            petscii_code <= 0x7fu -> petscii_code - 32u
-            petscii_code <= 0x9fu -> petscii_code + 64u
-            petscii_code <= 0xbfu -> petscii_code - 64u
-            petscii_code <= 0xfeu -> petscii_code - 128u
-            petscii_code == 255.toUByte() -> 95u
+            petsciicode <= 0x1fu -> petsciicode + 128u
+            petsciicode <= 0x3fu -> petsciicode.toUInt()
+            petsciicode <= 0x5fu -> petsciicode - 64u
+            petsciicode <= 0x7fu -> petsciicode - 32u
+            petsciicode <= 0x9fu -> petsciicode + 64u
+            petsciicode <= 0xbfu -> petsciicode - 64u
+            petsciicode <= 0xfeu -> petsciicode - 128u
+            petsciicode == 255.toUByte() -> 95u
             else -> return Err(CharConversionException("petscii code out of range"))
         }
         if(inverseVideo) {

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

@@ -1,57 +0,0 @@
-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/virtual/VirtualMachineDefinition.kt

@@ -1,75 +0,0 @@
-package prog8.code.target.virtual
-
-import prog8.code.core.*
-import java.nio.file.Path
-import kotlin.io.path.isReadable
-import kotlin.io.path.name
-import kotlin.io.path.readText
-
-class VirtualMachineDefinition: IMachineDefinition {
-
-    override val cpu = CpuType.VIRTUAL
-
-    override val FLOAT_MAX_POSITIVE = Float.MAX_VALUE.toDouble()
-    override val FLOAT_MAX_NEGATIVE = -Float.MAX_VALUE.toDouble()
-    override val FLOAT_MEM_SIZE = 8             // 64-bits double
-    override val PROGRAM_LOAD_ADDRESS = 0u      // not actually used
-
-    override val BSSHIGHRAM_START = 0u          // not actually used
-    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.toDouble().toBits().toULong()
-        val hexStr = bits.toString(16).padStart(16, '0')
-        val parts = hexStr.chunked(2).map { "\$" + it }
-        return parts.joinToString(", ")
-    }
-
-    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return listOf("syslib")
-    }
-
-    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
-        println("\nStarting Virtual Machine...")
-        // to not have external module dependencies in our own module, we launch the virtual machine via reflection
-        val vm = Class.forName("prog8.vm.VmRunner").getDeclaredConstructor().newInstance() as IVirtualMachineRunner
-        val filename = programNameWithPath.name
-        if(programNameWithPath.isReadable()) {
-            vm.runProgram(programNameWithPath.readText())
-        } else {
-            val withExt = programNameWithPath.resolveSibling("$filename.p8ir")
-            if(withExt.isReadable())
-                vm.runProgram(withExt.readText())
-            else
-                throw NoSuchFileException(withExt.toFile(), reason="not a .p8ir file")
-        }
-    }
-
-    override fun isIOAddress(address: UInt): Boolean = false
-
-    override fun initializeMemoryAreas(compilerOptions: CompilationOptions) {
-        zeropage = VirtualZeropage(compilerOptions)
-    }
-}
-
-interface IVirtualMachineRunner {
-    fun runProgram(irSource: String)
-}
-
-private class VirtualZeropage(options: CompilationOptions): Zeropage(options) {
-    override val SCRATCH_B1: UInt
-        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
-    override val SCRATCH_REG: UInt
-        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
-    override val SCRATCH_W1: UInt
-        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
-    override val SCRATCH_W2: UInt
-        get() = throw IllegalStateException("virtual shouldn't use this zeropage variable")
-
-    override fun allocateCx16VirtualRegisters() { /* there is no actual zero page in this target to allocate thing in */ }
-}

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

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

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

@@ -1,4 +1,4 @@
-package prog8.code.target.c64
+package prog8.code.target.zp
 
 import prog8.code.core.*
 
@@ -6,7 +6,7 @@ import prog8.code.core.*
 class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
 
     override val SCRATCH_B1 = 0x02u      // temp storage for a single byte
-    override val SCRATCH_REG = 0x03u     // temp storage for a register, must be B1+1
+    override val SCRATCH_REG = 0x03u     // temp storage for a register byte, must be B1+1
     override val SCRATCH_W1 = 0xfbu      // temp storage 1 for a word  $fb+$fc
     override val SCRATCH_W2 = 0xfdu      // temp storage 2 for a word  $fd+$fe
 
@@ -21,11 +21,11 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
 
         if (options.zeropage == ZeropageType.FULL) {
             free.addAll(0x02u..0xffu)
-            free.removeAll(setOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1+1u, SCRATCH_W2, SCRATCH_W2+1u))
-            free.removeAll(setOf(0xa0u, 0xa1u, 0xa2u, 0x91u, 0xc0u, 0xc5u, 0xcbu, 0xf5u, 0xf6u))        // these are updated by IRQ
+            free.removeAll(arrayOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_W1, SCRATCH_W1+1u, SCRATCH_W2, SCRATCH_W2+1u))
+            free.removeAll(arrayOf(0xa0u, 0xa1u, 0xa2u, 0x91u, 0xc0u, 0xc5u, 0xcbu, 0xf5u, 0xf6u))        // these are updated by IRQ
         } else {
             if (options.zeropage == ZeropageType.KERNALSAFE || options.zeropage == ZeropageType.FLOATSAFE) {
-                free.addAll(listOf(
+                free.addAll(arrayOf(
                         0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
@@ -43,7 +43,7 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
 
             if (options.zeropage == ZeropageType.FLOATSAFE) {
                 // remove the zeropage locations used for floating point operations from the free list
-                free.removeAll(listOf(
+                free.removeAll(arrayOf(
                         0x03, 0x04, 0x05, 0x06, 0x10, 0x11, 0x12,
                         0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
                         0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
@@ -56,7 +56,7 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
             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,
+                free.addAll(arrayOf(0x02, 0x03, 0x04, 0x05, 0x06, 0x0a, 0x0e,
                         0x92, 0x96, 0x9b, 0x9c, 0x9e, 0x9f, 0xa6,
                         0xb0, 0xb1, 0xbe, 0xbf, 0xf9).map{it.toUInt()})
             } else {
@@ -79,9 +79,9 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
         retainAllowed()
     }
 
-    override fun allocateCx16VirtualRegisters() {
+    private fun allocateCx16VirtualRegisters() {
         // Note: the 16 virtual registers R0-R15 are not regular allocated variables, they're *memory mapped* elsewhere to fixed addresses.
-        // However, to be able for the compiler to "see" them as zero page variables, we have to register them here as well.
+        // However, to be able for the compiler to "see" them as zeropage variables, we have to register them here as well.
         // This is important because the compiler sometimes treats ZP variables more efficiently (for example if it's a pointer)
         // The base addres is $04.  Unfortunately it cannot be the same as on the Commander X16 ($02).
         for(reg in 0..15) {

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

@@ -1,4 +1,4 @@
-package prog8.code.target.cx16
+package prog8.code.target.zp
 
 import prog8.code.core.*
 
@@ -6,7 +6,7 @@ import prog8.code.core.*
 class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
 
     override val SCRATCH_B1 = 0x7au      // temp storage for a single byte
-    override val SCRATCH_REG = 0x7bu     // temp storage for a register, must be B1+1
+    override val SCRATCH_REG = 0x7bu     // temp storage for a register byte, must be B1+1
     override val SCRATCH_W1 = 0x7cu      // temp storage 1 for a word  $7c+$7d
     override val SCRATCH_W2 = 0x7eu      // temp storage 2 for a word  $7e+$7f
 
@@ -52,9 +52,9 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
         }
     }
 
-    override fun allocateCx16VirtualRegisters() {
+    private fun allocateCx16VirtualRegisters() {
         // Note: the 16 virtual registers R0-R15 are not regular allocated variables, they're *memory mapped* elsewhere to fixed addresses.
-        // However, to be able for the compiler to "see" them as zero page variables, we have to register them here as well.
+        // However, to be able for the compiler to "see" them as zeropage variables, we have to register them here as well.
         // This is important because the compiler sometimes treats ZP variables more efficiently (for example if it's a pointer)
         for(reg in 0..15) {
             allocatedVariables["cx16.r${reg}"]   = VarAllocation((2+reg*2).toUInt(), DataType.UWORD, 2)       // cx16.r0 .. cx16.r15

codeCore/src/prog8/code/target/zp/ConfigurableZeropage.kt

@@ -0,0 +1,61 @@
+package prog8.code.target.zp
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.DataType
+import prog8.code.core.Zeropage
+import prog8.code.core.ZeropageType
+
+class ConfigurableZeropage(
+    override val SCRATCH_B1: UInt,      // temp storage for a single byte
+    override val SCRATCH_REG: UInt,     // temp storage for a register byte, must be B1+1
+    override val SCRATCH_W1: UInt,      // temp storage 1 for a word
+    override val SCRATCH_W2: UInt,      // temp storage 2 for a word
+    val virtualRegistersStart: UInt,        // location of 32 bytes for the r0-r15 virtual registers
+    basicsafe: List<UIntRange>,
+    kernalsafe: List<UIntRange>,
+    fullsafe: List<UIntRange>,
+    options: CompilationOptions
+) : Zeropage(options) {
+
+    init {
+        if (options.floats) {
+            TODO("floats in configurable target zp")
+        }
+
+        if(SCRATCH_REG!=SCRATCH_B1+1u)
+            throw IllegalArgumentException("Zero page scratch variable REG should be B1+1")
+
+        when (options.zeropage) {
+            ZeropageType.DONTUSE -> { /* don't use any zeropage at all */ }
+            ZeropageType.FULL -> fullsafe.forEach { free.addAll(it) }
+            ZeropageType.BASICSAFE -> basicsafe.forEach { free.addAll(it) }
+            ZeropageType.KERNALSAFE -> kernalsafe.forEach { free.addAll(it) }
+            ZeropageType.FLOATSAFE -> TODO("floatsafe in configurable target zp")
+        }
+
+        val distinctFree = free.distinct()
+        free.clear()
+        free.addAll(distinctFree)
+
+        removeReservedFromFreePool()
+        allocateCx16VirtualRegisters()
+        retainAllowed()
+    }
+
+    private fun allocateCx16VirtualRegisters() {
+        // Note: the 16 virtual registers R0-R15 are not regular allocated variables, they're *memory mapped* elsewhere to fixed addresses.
+        // However, to be able for the compiler to "see" them as zeropage variables, we have to register them here as well.
+        // This is important because the compiler sometimes treats ZP variables more efficiently (for example if it's a pointer)
+        for(reg in 0..15) {
+            val address = virtualRegistersStart + (2*reg).toUInt()
+            if(address<=0xffu) {
+                allocatedVariables["cx16.r${reg}"]   = VarAllocation(address, DataType.UWORD, 2)       // cx16.r0 .. cx16.r15
+                allocatedVariables["cx16.r${reg}s"]  = VarAllocation(address, DataType.WORD, 2)        // cx16.r0s .. cx16.r15s
+                allocatedVariables["cx16.r${reg}L"]  = VarAllocation(address, DataType.UBYTE, 1)       // cx16.r0L .. cx16.r15L
+                allocatedVariables["cx16.r${reg}H"]  = VarAllocation(address+1u, DataType.UBYTE, 1)    // cx16.r0H .. cx16.r15H
+                allocatedVariables["cx16.r${reg}sL"] = VarAllocation(address, DataType.BYTE, 1)        // cx16.r0sL .. cx16.r15sL
+                allocatedVariables["cx16.r${reg}sH"] = VarAllocation(address+1u, DataType.BYTE, 1)     // cx16.r0sH .. cx16.r15sH
+            }
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-package prog8.code.target.pet
+package prog8.code.target.zp
 
 import prog8.code.core.CompilationOptions
 import prog8.code.core.InternalCompilerException
@@ -11,15 +11,11 @@ import prog8.code.core.ZeropageType
 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_REG = 0xb4u     // temp storage for a register byte, 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,
@@ -52,8 +48,4 @@ class PETZeropage(options: CompilationOptions) : Zeropage(options) {
         removeReservedFromFreePool()
         retainAllowed()
     }
-
-    override fun allocateCx16VirtualRegisters() {
-        TODO("Not known if PET can put the virtual regs in ZP")
-    }
 }

codeGenCpu6502/build.gradle

@@ -1,63 +0,0 @@
-
-plugins {
-    id 'java'
-    id 'application'
-    id "org.jetbrains.kotlin.jvm"
-    id "io.kotest" version "0.3.9"
-}
-
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(javaVersion)
-    }
-}
-
-compileKotlin {
-    kotlinOptions {
-        jvmTarget = javaVersion
-    }
-}
-
-compileTestKotlin {
-    kotlinOptions {
-        jvmTarget = javaVersion
-    }
-}
-
-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.18"
-
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.8.0'
-}
-
-sourceSets {
-    main {
-        java {
-            srcDir "${project.projectDir}/src"
-        }
-        resources {
-            srcDir "${project.projectDir}/res"
-        }
-    }
-    test {
-        java {
-            srcDir "${project.projectDir}/test"
-        }
-    }
-}
-
-test {
-    // Enable JUnit 5 (Gradle 4.6+).
-    useJUnitPlatform()
-
-    // Always run tests, even when nothing changed.
-    dependsOn 'cleanTest'
-
-    // Show test results.
-    testLogging {
-        events "skipped", "failed"
-    }
-}

codeGenCpu6502/build.gradle.kts

@@ -0,0 +1,47 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    kotlin("jvm")
+}
+
+dependencies {
+    implementation(project(":codeCore"))
+    implementation(project(":simpleAst"))
+    // implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
+    // implementation "org.jetbrains.kotlin:kotlin-reflect"
+    implementation("com.michael-bull.kotlin-result:kotlin-result-jvm:2.0.1")
+
+    testImplementation("io.kotest:kotest-runner-junit5-jvm:5.9.1")
+    testImplementation("io.kotest:kotest-framework-datatest:5.9.1")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.9.1")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+}
+
+sourceSets {
+    main {
+        java {
+            setSrcDirs(listOf("$projectDir/src"))
+        }
+        resources {
+            setSrcDirs(listOf("$projectDir/res"))
+        }
+    }
+    test {
+        java {
+            setSrcDirs(listOf("$projectDir/test"))
+        }
+    }
+}
+
+tasks.test {
+    // Enable JUnit 5 (Gradle 4.6+).
+    useJUnitPlatform()
+
+    // Always run tests, even when nothing changed.
+    dependsOn("cleanTest")
+
+    // Show test results.
+    testLogging {
+        events("skipped", "failed")
+    }
+}

codeGenCpu6502/codeGenCpu6502.iml

@@ -11,8 +11,10 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
     <orderEntry type="module" module-name="codeCore" />
+    <orderEntry type="module" module-name="simpleAst" />
     <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
     <orderEntry type="library" name="io.kotest.assertions.core.jvm" level="project" />
     <orderEntry type="library" name="io.kotest.runner.junit5.jvm" level="project" />
+    <orderEntry type="library" name="io.kotest.framework.datatest" level="project" />
   </component>
 </module>

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

@@ -1,15 +1,16 @@
 package prog8.codegen.cpu6502
 
+import prog8.code.GENERATED_LABEL_PREFIX
 import prog8.code.StConstant
 import prog8.code.StMemVar
 import prog8.code.SymbolTable
-import prog8.code.core.IMachineDefinition
+import prog8.code.core.ICompilationTarget
 
 
 // note: see https://wiki.nesdev.org/w/index.php/6502_assembly_optimisations
 
 
-internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefinition, symbolTable: SymbolTable): Int {
+internal fun optimizeAssembly(lines: MutableList<String>, machine: ICompilationTarget, symbolTable: SymbolTable): Int {
 
     var numberOfOptimizations = 0
 
@@ -50,6 +51,13 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
         numberOfOptimizations++
     }
 
+    mods = optimizeTSBtoRegularOr(linesByFour)
+    if(mods.isNotEmpty()) {
+        apply(mods, lines)
+        linesByFour = getLinesBy(lines, 4)
+        numberOfOptimizations++
+    }
+
     var linesByFourteen = getLinesBy(lines, 14)
     mods = optimizeSameAssignments(linesByFourteen, machine, symbolTable)
     if(mods.isNotEmpty()) {
@@ -58,15 +66,13 @@ internal fun optimizeAssembly(lines: MutableList<String>, machine: IMachineDefin
         numberOfOptimizations++
     }
 
-    mods = optimizeSamePointerIndexing(linesByFourteen)
+    mods = optimizeSamePointerIndexingAndUselessBeq(linesByFourteen)
     if(mods.isNotEmpty()) {
         apply(mods, lines)
         linesByFourteen = getLinesBy(lines, 14)
         numberOfOptimizations++
     }
 
-    // TODO more assembly peephole optimizations
-
     return numberOfOptimizations
 }
 
@@ -75,24 +81,49 @@ private fun String.isStoreReg() = this.startsWith("sta") || this.startsWith("sty
 private fun String.isStoreRegOrZero() = this.isStoreReg() || this.startsWith("stz")
 private fun String.isLoadReg() = this.startsWith("lda") || this.startsWith("ldy") || this.startsWith("ldx")
 
-private class Modification(val lineIndex: Int, val remove: Boolean, val replacement: String?)
+private class Modification(val lineIndex: Int, val remove: Boolean, val replacement: String?, val removeLabel: Boolean=false)
 
 private fun apply(modifications: List<Modification>, lines: MutableList<String>) {
     for (modification in modifications.sortedBy { it.lineIndex }.reversed()) {
-        if(modification.remove)
+        if(modification.remove) {
+            if(modification.removeLabel)
                 lines.removeAt(modification.lineIndex)
+            else {
+                val line = lines[modification.lineIndex]
+                if (line.length < 2 || line[0] == ';' || line.trimStart()[0] == ';')
+                    lines.removeAt(modification.lineIndex)
+                else if (haslabel(line)) {
+                    val label = keeplabel(line)
+                    if (label.isNotEmpty())
+                        lines[modification.lineIndex] = label
+                    else
+                        lines.removeAt(modification.lineIndex)
+                } else lines.removeAt(modification.lineIndex)
+            }
+        }
         else
             lines[modification.lineIndex] = modification.replacement!!
     }
 }
 
+private fun haslabel(line: String): Boolean {
+    return line.length>1 && line[0]!=';' && (!line[0].isWhitespace() || ':' in line)
+}
+
+private fun keeplabel(line: String): String {
+    if(':' in line)
+        return line.substringBefore(':') + ':'
+    val splits = line.split('\t', ' ', limit=2)
+    return if(splits.size>1) splits[0] + ':' else ""
+}
+
 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)
+        lines.asSequence().withIndex().filter { it.value.isNotBlank() && !it.value.trimStart().startsWith(';') }.windowed(windowSize, partialWindows = false)
 
 private fun optimizeSameAssignments(
-    linesByFourteen: List<List<IndexedValue<String>>>,
-    machine: IMachineDefinition,
+    linesByFourteen: Sequence<List<IndexedValue<String>>>,
+    machine: ICompilationTarget,
     symbolTable: SymbolTable
 ): List<Modification> {
 
@@ -281,7 +312,7 @@ private fun optimizeSameAssignments(
     return mods
 }
 
-private fun optimizeSamePointerIndexing(linesByFourteen: List<List<IndexedValue<String>>>): List<Modification> {
+private fun optimizeSamePointerIndexingAndUselessBeq(linesByFourteen: Sequence<List<IndexedValue<String>>>): List<Modification> {
 
     // Optimize same pointer indexing where for instance we load and store to the same ptr index in Y
     // if Y isn't modified in between we can omit the second LDY:
@@ -318,33 +349,60 @@ private fun optimizeSamePointerIndexing(linesByFourteen: List<List<IndexedValue<
                 mods.add(Modification(lines[4].index, true, null))
             }
         }
+
+
+        /*
+    beq  +
+    lda  #1
++
+[ optional:  label_xxxx_shortcut   line here]
+    beq  label_xxxx_shortcut   /  bne label_xxxx_shortcut
+or *_afterif labels.
+
+This gets generated after certain if conditions, and only the branch instruction is needed in these cases.
+         */
+
+        val autoLabelPrefix = GENERATED_LABEL_PREFIX
+        if(first=="beq  +" && second=="lda  #1" && third=="+") {
+            if((fourth.startsWith("beq  $autoLabelPrefix") || fourth.startsWith("bne  $autoLabelPrefix")) &&
+                (fourth.endsWith("_shortcut") || fourth.endsWith("_afterif") || fourth.endsWith("_shortcut:") || fourth.endsWith("_afterif:"))) {
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, true, null))
+                mods.add(Modification(lines[2].index, true, null))
+            }
+            else if(fourth.startsWith(autoLabelPrefix) && (fourth.endsWith("_shortcut") || fourth.endsWith("_shortcut:"))) {
+                if((fifth.startsWith("beq  $autoLabelPrefix") || fifth.startsWith("bne  $autoLabelPrefix")) &&
+                    (fifth.endsWith("_shortcut") || fifth.endsWith("_afterif") || fifth.endsWith("_shortcut:") || fifth.endsWith("_afterif:"))) {
+                    mods.add(Modification(lines[0].index, true, null))
+                    mods.add(Modification(lines[1].index, true, null))
+                    mods.add(Modification(lines[2].index, true, null))
+                }
+            }
+        }
     }
 
     return mods
 }
 
 private fun optimizeStoreLoadSame(
-    linesByFour: List<List<IndexedValue<String>>>,
-    machine: IMachineDefinition,
+    linesByFour: Sequence<List<IndexedValue<String>>>,
+    machine: ICompilationTarget,
     symbolTable: SymbolTable
 ): List<Modification> {
-    // sta X + lda X,  sty X + ldy X,   stx X + ldx X  -> the second instruction can OFTEN be eliminated
     val mods = mutableListOf<Modification>()
     for (lines in linesByFour) {
         val first = lines[1].value.trimStart()
         val second = lines[2].value.trimStart()
+        val third = lines[3].value.trimStart()
 
+        // sta X + lda X,  sty X + ldy X,   stx X + ldx X  -> the second instruction can OFTEN be eliminated
         if ((first.startsWith("sta ") && second.startsWith("lda ")) ||
                 (first.startsWith("stx ") && second.startsWith("ldx ")) ||
                 (first.startsWith("sty ") && second.startsWith("ldy ")) ||
                 (first.startsWith("lda ") && second.startsWith("lda ")) ||
                 (first.startsWith("ldy ") && second.startsWith("ldy ")) ||
-                (first.startsWith("ldx ") && second.startsWith("ldx ")) ||
-                (first.startsWith("sta ") && second.startsWith("lda ")) ||
-                (first.startsWith("sty ") && second.startsWith("ldy ")) ||
-                (first.startsWith("stx ") && second.startsWith("ldx "))
+                (first.startsWith("ldx ") && second.startsWith("ldx "))
         ) {
-            val third = lines[3].value.trimStart()
             val attemptRemove =
                 if(third.isBranch()) {
                     // a branch instruction follows, we can only remove the load instruction if
@@ -385,11 +443,23 @@ private fun optimizeStoreLoadSame(
             mods.add(Modification(lines[1].index, true, null))
             mods.add(Modification(lines[2].index, false, "  tya"))
         }
+
+
+        // lda X + sta X,  ldy X + sty X,   ldx X + stx X  -> the second instruction can be eliminated
+        if ((first.startsWith("lda ") && second.startsWith("sta ")) ||
+            (first.startsWith("ldx ") && second.startsWith("stx ")) ||
+            (first.startsWith("ldy ") && second.startsWith("sty "))
+        ) {
+            val firstLoc = first.substring(4).trimStart()
+            val secondLoc = second.substring(4).trimStart()
+            if (firstLoc == secondLoc)
+                mods.add(Modification(lines[2].index, true, null))
+        }
     }
     return mods
 }
 
-private val identifierRegex = Regex("""^([a-zA-Z_$][a-zA-Z\d_\.$]*)""")
+private val identifierRegex = Regex("""^([a-zA-Z_$][a-zA-Z\d_.$]*)""")
 
 private fun getAddressArg(line: String, symbolTable: SymbolTable): UInt? {
     // try to get the constant value address, could return null if it's a symbol instead
@@ -414,7 +484,7 @@ private fun getAddressArg(line: String, symbolTable: SymbolTable): UInt? {
     }
 }
 
-private fun optimizeIncDec(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
+private fun optimizeIncDec(linesByFour: Sequence<List<IndexedValue<String>>>): List<Modification> {
     // sometimes, iny+dey / inx+dex / dey+iny / dex+inx sequences are generated, these can be eliminated.
     val mods = mutableListOf<Modification>()
     for (lines in linesByFour) {
@@ -431,23 +501,36 @@ private fun optimizeIncDec(linesByFour: List<List<IndexedValue<String>>>): List<
             mods.add(Modification(lines[0].index, true, null))
             mods.add(Modification(lines[1].index, true, null))
         }
+
     }
     return mods
 }
 
-private fun optimizeJsrRtsAndOtherCombinations(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
+private fun optimizeJsrRtsAndOtherCombinations(linesByFour: Sequence<List<IndexedValue<String>>>): List<Modification> {
     // jsr Sub + rts -> jmp Sub
+    // jmp Sub + rts -> jmp Sub
     // rts + jmp -> remove jmp
     // rts + bxx -> remove bxx
+    // lda  + cmp #0 -> remove cmp,  same for cpy and cpx.
+    // bra/jmp + bra/jmp -> remove second bra/jmp   (bra bra / jmp jmp are not removed because this is likely a jump table!)
+    // and some other optimizations.
 
     val mods = mutableListOf<Modification>()
     for (lines in linesByFour) {
         val first = lines[0].value
         val second = lines[1].value
-        if ((" jsr" in first || "\tjsr" in first ) && (" rts" in second || "\trts" in second)) {
+        val third = lines[2].value
+
+        if(!haslabel(second)) {
+            if ((" jmp" in first || "\tjmp" in first ) && (" rts" in second || "\trts" in second)) {
+                mods += Modification(lines[1].index, true, null)
+            }
+            else if ((" jsr" in first || "\tjsr" in first ) && (" rts" in second || "\trts" in second)) {
+                if("floats.pushFAC" !in first && "floats.popFAC" !in first) {       // these 2 routines depend on being called with JSR!!
                     mods += Modification(lines[0].index, false, lines[0].value.replace("jsr", "jmp"))
                     mods += Modification(lines[1].index, true, null)
                 }
+            }
             else if (" rts" in first || "\trts" in first) {
                 if (" jmp" in second || "\tjmp" in second)
                     mods += Modification(lines[1].index, true, null)
@@ -470,11 +553,114 @@ private fun optimizeJsrRtsAndOtherCombinations(linesByFour: List<List<IndexedVal
                 else if (" bvc" in second || "\tbvc" in second)
                     mods += Modification(lines[1].index, true, null)
             }
+
+            if ((" lda" in first || "\tlda" in first) && (" cmp  #0" in second || "\tcmp  #0" in second) ||
+                (" ldx" in first || "\tldx" in first) && (" cpx  #0" in second || "\tcpx  #0" in second) ||
+                (" ldy" in first || "\tldy" in first) && (" cpy  #0" in second || "\tcpy  #0" in second)
+            ) {
+                mods.add(Modification(lines[1].index, true, null))
+            }
+            else if(" cmp  #0" in second || "\tcmp  #0" in second) {
+                // there are many instructions that modify A and set the bits...
+                for(instr in arrayOf("lda", "ora", "and", "eor", "adc", "sbc", "asl", "cmp", "inc  a", "lsr", "pla", "rol", "ror", "txa", "tya")) {
+                    if(" $instr" in first || "\t$instr" in first) {
+                        mods.add(Modification(lines[1].index, true, null))
+                    }
+                }
+            }
+
+            // only remove bra followed by jmp or jmp followed by bra
+            // bra bra or jmp jmp is likely part of a jump table, which should keep all entries!
+            if((" bra" in first || "\tbra" in first) && (" jmp" in second || "\tjmp" in second)) {
+                mods.add(Modification(lines[1].index, true, null))
+            }
+            if((" jmp" in first || "\tjmp" in first) && (" bra" in second || "\tbra" in second)) {
+                mods.add(Modification(lines[1].index, true, null))
+            }
+        }
+
+        /*
+    LDA NUM1
+    CMP NUM2
+    BCC LABEL
+    BEQ LABEL
+
+(or something similar) which branches to LABEL when NUM1 <= NUM2. (In this case NUM1 and NUM2 are unsigned numbers.) However, consider the following sequence:
+
+    LDA NUM2
+    CMP NUM1
+    BCS LABEL
+         */
+        val tfirst = first.trimStart()
+        val tsecond = second.trimStart()
+        val tthird = lines[2].value.trimStart()
+        val tfourth = lines[3].value.trimStart()
+        if(tfirst.startsWith("lda") && tsecond.startsWith("cmp") && tthird.startsWith("bcc") && tfourth.startsWith("beq")) {
+            val label = tthird.substring(4)
+            if(label==tfourth.substring(4)) {
+                mods += Modification(lines[0].index, false, "  lda  ${tsecond.substring(4)}")
+                mods += Modification(lines[1].index, false, "  cmp  ${tfirst.substring(4)}")
+                mods += Modification(lines[2].index, false, "  bcs  $label")
+                mods += Modification(lines[3].index, true, null)
+            }
+        }
+
+
+        fun sameLabel(branchInstr: String, jumpInstr: String, labelInstr: String): Boolean {
+            if('(' in jumpInstr) return false       // indirect jump cannot be replaced
+            val label = labelInstr.trimEnd().substringBefore(':').substringBefore(' ').substringBefore('\t')
+            val branchLabel = branchInstr.trimStart().substring(3).trim()
+            return label==branchLabel
+        }
+
+        // beq Label + jmp Addr + Label  -> bne Addr
+        if((" jmp" in second || "\tjmp " in second) && haslabel(third)) {
+            if((" beq " in first || "\tbeq " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bne")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bne " in first || "\tbne " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "beq")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bcc " in first || "\tbcc " in first) && sameLabel(first, second, third)){
+                val branch = second.replace("jmp", "bcs")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bcs " in first || "\tbcs " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bcc")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bpl " in first || "\tbpl " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bmi")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bmi " in first || "\tbmi " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bpl")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bvc " in first || "\tbvc " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bvs")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+            else if((" bvs " in first || "\tbvs " in first) && sameLabel(first, second, third)) {
+                val branch = second.replace("jmp", "bvc")
+                mods.add(Modification(lines[0].index, true, null))
+                mods.add(Modification(lines[1].index, false, branch))
+            }
+        }
     }
     return mods
 }
 
-private fun optimizeUselessPushPopStack(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
+private fun optimizeUselessPushPopStack(linesByFour: Sequence<List<IndexedValue<String>>>): List<Modification> {
     val mods = mutableListOf<Modification>()
 
     fun optimize(register: Char, lines: List<IndexedValue<String>>) {
@@ -507,11 +693,59 @@ private fun optimizeUselessPushPopStack(linesByFour: List<List<IndexedValue<Stri
         optimize('a', lines)
         optimize('x', lines)
         optimize('y', lines)
+
+        val first = lines[1].value.trimStart()
+        val second = lines[2].value.trimStart()
+        val third = lines[3].value.trimStart()
+
+        // phy + ldy + pla -> tya + ldy
+        // phx + ldx + pla -> txa + ldx
+        // pha + lda + pla -> nop
+        when (first) {
+            "phy" if second.startsWith("ldy ") && third=="pla" -> {
+                mods.add(Modification(lines[3].index, true, null))
+                mods.add(Modification(lines[1].index, false, "  tya"))
+            }
+            "phx" if second.startsWith("ldx ") && third=="pla" -> {
+                mods.add(Modification(lines[3].index, true, null))
+                mods.add(Modification(lines[1].index, false, "  txa"))
+            }
+            "pha" if second.startsWith("lda ") && third=="pla" -> {
+                mods.add(Modification(lines[1].index, true, null))
+                mods.add(Modification(lines[2].index, true, null))
+                mods.add(Modification(lines[3].index, true, null))
+            }
+        }
+    }
+
+
+    return mods
+}
+
+
+private fun optimizeTSBtoRegularOr(linesByFour: Sequence<List<IndexedValue<String>>>): List<Modification> {
+    // Asm peephole:   lda var2 / tsb var1 / lda var1  Replace this with this to save 1 cycle:   lda var1 / ora var2 / sta var1
+    val mods = mutableListOf<Modification>()
+
+    for(lines in linesByFour) {
+        val first = lines[0].value.trimStart()
+        val second = lines[1].value.trimStart()
+        val third = lines[2].value.trimStart()
+        if(first.startsWith("lda") && second.startsWith("tsb") && third.startsWith("lda")) {
+            val operand1 = first.substring(3)
+            val operand2 = second.substring(3)
+            val operand3 = third.substring(3)
+            if(operand1!=operand2 && operand2==operand3) {
+                mods.add(Modification(lines[0].index, false, "  lda  $operand2"))
+                mods.add(Modification(lines[1].index, false, "  ora  $operand1"))
+                mods.add(Modification(lines[2].index, false, "  sta  $operand2"))
+            }
+        }
     }
     return mods
 }
 
-private fun optimizeUnneededTempvarInAdd(linesByFour: List<List<IndexedValue<String>>>): List<Modification> {
+private fun optimizeUnneededTempvarInAdd(linesByFour: Sequence<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>()

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

@@ -11,18 +11,22 @@ fun asmsub6502ArgsEvalOrder(sub: PtAsmSub): List<Int> {
     //  1) cx16 virtual word registers,
     //  2) paired CPU registers,
     //  3) single CPU registers (order Y,X,A),
-    //  4) CPU Carry status flag
+    //  4) floating point registers (FAC1, FAC2),
+    //  5) CPU Carry status flag
     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 (singleRegs, rest) = args3.partition { it.value.first.registerOrPair != null }
+    val (singleRegsMixed, rest) = args3.partition { it.value.first.registerOrPair != null }
+    val (singleCpuRegs, floatRegs) = singleRegsMixed.partition {it.value.first.registerOrPair != RegisterOrPair.FAC1 && it.value.first.registerOrPair != RegisterOrPair.FAC2  }
 
     cx16regs.forEach { order += it.index }
     pairedRegs.forEach { order += it.index }
-    singleRegs.sortedBy { it.value.first.registerOrPair!!.asCpuRegister() }.asReversed().forEach { order += it.index }
+    singleCpuRegs.sortedBy { it.value.first.registerOrPair!!.asCpuRegister() }.asReversed().forEach { order += it.index }
     require(rest.all { it.value.first.registerOrPair==null && it.value.first.statusflag!=null})
+    floatRegs.forEach { order += it.index }
     rest.forEach { order += it.index }
     require(order.size==sub.parameters.size)
+
     return order
 }

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

@@ -1,7 +1,14 @@
 package prog8.codegen.cpu6502
 
-import prog8.code.core.*
+import prog8.code.GENERATED_LABEL_PREFIX
+import prog8.code.IAssemblyProgram
+import prog8.code.core.CompilationOptions
+import prog8.code.core.ICompilationTarget
+import prog8.code.core.IErrorReporter
+import prog8.code.core.OutputType
+import prog8.code.target.C128Target
 import prog8.code.target.C64Target
+import prog8.code.target.PETTarget
 import java.nio.file.Path
 
 
@@ -21,15 +28,12 @@ internal class AssemblyProgram(
 
         val assemblerCommand: List<String>
 
-        when (compTarget.name) {
-            in setOf("c64", "c128", "cx16", "pet32") -> {
+        when(options.output) {
+            OutputType.PRG -> {
                 // 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", "-Werror",
-                    "--dump-labels", "--vice-labels", "--labels=$viceMonListFile", "--no-monitor"
-                )
+                val command = mutableListOf("64tass", "--cbm-prg", "--ascii", "--case-sensitive", "--long-branch",
+                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=$viceMonListFile")
 
                 if(options.warnSymbolShadowing)
                     command.add("-Wshadow")
@@ -39,34 +43,20 @@ internal class AssemblyProgram(
                 if(options.asmQuiet)
                     command.add("--quiet")
 
-                if(options.asmListfile)
+                if(options.asmListfile) {
                     command.add("--list=$listFile")
+                }
 
-                val outFile = when (options.output) {
-                    OutputType.PRG -> {
-                        command.add("--cbm-prg")
-                        println("\nCreating prg for target ${compTarget.name}.")
-                        prgFile
-                    }
-                    OutputType.RAW -> {
-                        command.add("--nostart")
-                        println("\nCreating raw binary for target ${compTarget.name}.")
-                        binFile
-                    }
-                    else -> throw AssemblyError("invalid output type")
-                }
-                command.addAll(listOf("--output", outFile.toString(), assemblyFile.toString()))
+                command.addAll(listOf("--output", prgFile.toString(), assemblyFile.toString()))
                 assemblerCommand = command
-
+                if(!options.quiet)
+                    println("\nCreating prg for target ${compTarget.name}.")
             }
-            "atari" -> {
+            OutputType.XEX -> {
                 // Atari800XL .xex generation.
 
-                // TODO are these options okay for atari?
-                val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
-                    "-Wall", // "-Werror", "-Wno-strict-bool"
-                    "--no-monitor"
-                )
+                val command = mutableListOf("64tass", "--atari-xex", "--case-sensitive", "--long-branch",
+                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=$viceMonListFile")
 
                 if(options.warnSymbolShadowing)
                     command.add("-Wshadow")
@@ -79,28 +69,73 @@ internal class AssemblyProgram(
                 if(options.asmListfile)
                     command.add("--list=$listFile")
 
-                val outFile = when (options.output) {
-                    OutputType.XEX -> {
-                        command.add("--atari-xex")
+                command.addAll(listOf("--output", xexFile.toString(), assemblyFile.toString()))
+                assemblerCommand = command
+                if(!options.quiet)
                     println("\nCreating xex for target ${compTarget.name}.")
-                        xexFile
             }
             OutputType.RAW -> {
-                        command.add("--nostart")
-                        println("\nCreating raw binary for target ${compTarget.name}.")
-                        binFile
-                    }
-                    else -> throw AssemblyError("invalid output type")
-                }
-                command.addAll(listOf("--output", outFile.toString(), assemblyFile.toString()))
+                // Neo6502/headerless raw program generation.
+                val command = mutableListOf("64tass", "--nostart", "--case-sensitive", "--long-branch",
+                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=$viceMonListFile")
+
+                if(options.warnSymbolShadowing)
+                    command.add("-Wshadow")
+                else
+                    command.add("-Wno-shadow")
+
+                if(options.asmQuiet)
+                    command.add("--quiet")
+
+                if(options.asmListfile)
+                    command.add("--list=$listFile")
+
+                command.addAll(listOf("--output", binFile.toString(), assemblyFile.toString()))
                 assemblerCommand = command
+                if(!options.quiet)
+                    println("\nCreating raw binary for target ${compTarget.name}.")
             }
-            else -> throw AssemblyError("invalid compilation target")
+            OutputType.LIBRARY -> {
+                // CBM machines library (.bin) generation (with or without 2 byte load address header depending on the compilation target machine)
+
+                val command = mutableListOf("64tass", "--ascii", "--case-sensitive", "--long-branch",
+                    "-Wall", "-Wno-implied-reg", "--no-monitor", "--dump-labels", "--vice-labels", "--labels=$viceMonListFile")
+
+                if(options.warnSymbolShadowing)
+                    command.add("-Wshadow")
+                else
+                    command.add("-Wno-shadow")
+
+                if(options.asmQuiet)
+                    command.add("--quiet")
+
+                if(options.asmListfile)
+                    command.add("--list=$listFile")
+
+                if(compTarget.name in listOf(C64Target.NAME, C128Target.NAME, PETTarget.NAME)) {
+                    if(!options.quiet)
+                        println("\nCreating binary library file with header for target ${compTarget.name}.")
+                    command.add("--cbm-prg")
+                } else {
+                    if(!options.quiet)
+                        println("\nCreating binary library file without header for target ${compTarget.name}.")
+                    command.add("--nostart")       // should be headerless bin, because basic has problems doing a normal LOAD"lib",8,1 - need to use BLOAD
                 }
 
-        val proc = ProcessBuilder(assemblerCommand).inheritIO().start()
-        val result = proc.waitFor()
-        if (result == 0 && compTarget.name!="atari") {
+                command.addAll(listOf("--output", binFile.toString(), assemblyFile.toString()))
+                assemblerCommand = command
+            }
+        }
+
+        if(options.compTarget.additionalAssemblerOptions!=null)
+            assemblerCommand.add(options.compTarget.additionalAssemblerOptions!!)
+
+        val proc = ProcessBuilder(assemblerCommand)
+        if(!options.quiet)
+            proc.inheritIO()
+        val process = proc.start()
+        val result = process.waitFor()
+        if (result == 0) {
             removeGeneratedLabelsFromMonlist()
             generateBreakpointList()
         }
@@ -108,7 +143,7 @@ internal class AssemblyProgram(
     }
 
     private fun removeGeneratedLabelsFromMonlist() {
-        val pattern = Regex("""al (\w+) \S+prog8_label_.+?""")
+        val pattern = Regex("""al (\w+) \S+$GENERATED_LABEL_PREFIX.+?""")
         val lines = viceMonListFile.toFile().readLines()
         viceMonListFile.toFile().outputStream().bufferedWriter().use {
             for (line in lines) {
@@ -125,7 +160,7 @@ internal class AssemblyProgram(
         for (line in viceMonListFile.toFile().readLines()) {
             val match = pattern.matchEntire(line)
             if (match != null)
-                breakpoints.add("break \$" + match.groupValues[1])
+                breakpoints.add("break $" + match.groupValues[1])
         }
         val num = breakpoints.size
         breakpoints.add(0, "; breakpoint list now follows")

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

@@ -1,40 +0,0 @@
-package prog8.codegen.cpu6502
-
-import prog8.code.ast.IPtSubroutine
-import prog8.code.ast.PtAsmSub
-import prog8.code.ast.PtSub
-import prog8.code.core.*
-
-
-internal fun IPtSubroutine.returnsWhatWhere(): List<Pair<RegisterOrStatusflag, DataType>> {
-    when(this) {
-        is PtAsmSub -> {
-            return returns
-        }
-        is PtSub -> {
-            // for non-asm subroutines, determine the return registers based on the type of the return value
-            return if(returntype==null)
-                emptyList()
-            else {
-                val register = when (returntype!!) {
-                    in ByteDatatypes -> RegisterOrStatusflag(RegisterOrPair.A, null)
-                    in WordDatatypes -> RegisterOrStatusflag(RegisterOrPair.AY, null)
-                    DataType.FLOAT -> RegisterOrStatusflag(RegisterOrPair.FAC1, null)
-                    else -> RegisterOrStatusflag(RegisterOrPair.AY, null)
-                }
-                listOf(Pair(register, returntype!!))
-            }
-        }
-    }
-}
-
-
-internal fun PtSub.returnRegister(): RegisterOrStatusflag? {
-    return when(returntype) {
-        in ByteDatatypes -> RegisterOrStatusflag(RegisterOrPair.A, null)
-        in WordDatatypes -> RegisterOrStatusflag(RegisterOrPair.AY, null)
-        DataType.FLOAT -> RegisterOrStatusflag(RegisterOrPair.FAC1, null)
-        null -> null
-        else -> RegisterOrStatusflag(RegisterOrPair.AY, null)
-    }
-}

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

@@ -33,63 +33,100 @@ internal class ForLoopsAsmGen(
     }
 
     private fun translateForOverNonconstRange(stmt: PtForLoop, iterableDt: DataType, range: PtRange) {
-        val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
-        val modifiedLabel = asmgen.makeLabel("for_modified")
-        val modifiedLabel2 = asmgen.makeLabel("for_modifiedb")
-        asmgen.loopEndLabels.push(endLabel)
-        val stepsize=range.step.asConstInteger()!!
-
-        if(stepsize < -1) {
+        if(range.step.asConstInteger()!! < -1) {
             val limit = range.to.asConstInteger()
             if(limit==0)
                 throw AssemblyError("for unsigned loop variable it's not possible to count down with step != -1 from a non-const value to exactly zero due to value wrapping")
         }
 
-        when(iterableDt) {
-            DataType.ARRAY_B, DataType.ARRAY_UB -> {
-                if (stepsize==1 || stepsize==-1) {
+        when {
+            iterableDt.isByteArray -> forOverNonconstByteRange(stmt, iterableDt, range)
+            iterableDt.isWordArray && !iterableDt.isSplitWordArray -> forOverNonconstWordRange(stmt, iterableDt, range)
+            else -> throw AssemblyError("range expression can only be byte or word")
+        }
 
-                    // bytes array, step 1 or -1
+        asmgen.loopEndLabels.removeLast()
+    }
 
-                    val incdec = if(stepsize==1) "inc" else "dec"
-                    // loop over byte range via loopvar
+    private fun forOverNonconstByteRange(stmt: PtForLoop, iterableDt: DataType, range: PtRange) {
+        val stepsize = range.step.asConstInteger()!!
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.add(endLabel)
         val varname = asmgen.asmVariableName(stmt.variable)
-                    asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt))
-                    asmgen.assignExpressionToRegister(range.to, RegisterOrPair.A, false)
+
+        asmgen.assignExpressionToVariable(range.from, varname, iterableDt.elementType())
+        when (stepsize) {
+            -1 if range.to.asConstInteger()==0 -> {
+                // simple loop downto 0 step -1
+                asmgen.out(loopLabel)
+                asmgen.translate(stmt.statements)
+                asmgen.out("""
+                    dec  $varname
+                    lda  $varname
+                    cmp  #255
+                    bne  $loopLabel""")
+            }
+            -1 if range.to.asConstInteger()==1 -> {
+                // simple loop downto 1 step -1
+                asmgen.out(loopLabel)
+                asmgen.translate(stmt.statements)
+                asmgen.out("""
+                    dec  $varname
+                    bne  $loopLabel""")
+            }
+            1, -1 -> forOverBytesRangeStepOne(range, varname, iterableDt, loopLabel, endLabel, stmt)
+            else -> forOverBytesRangeStepGreaterOne(range, varname, iterableDt, loopLabel, endLabel, stmt)
+        }
+    }
+
+    private fun forOverBytesRangeStepOne(range: PtRange, varname: String, iterableDt: DataType, loopLabel: String, endLabel: String, forloop: PtForLoop) {
+        // bytes range, step 1 or -1
+
+        val stepsize = range.step.asConstInteger()!!
+        val incdec = if(stepsize==1) "inc" else "dec"
+
+        if(asmgen.options.romable) {
+            // cannot use self-modifying code, cannot use cpu stack (because loop can be interrupted halfway)
+            // so we need to store the loop end value in a newly allocated temporary variable
+            val toValueVar = asmgen.createTempVarReused(iterableDt.elementType().base, false, range)
+            asmgen.assignExpressionToRegister(range.to, RegisterOrPair.A)
+            asmgen.out("  sta  $toValueVar")
             // pre-check for end already reached
-                    if(iterableDt==DataType.ARRAY_B) {
-                        asmgen.out("  sta  $modifiedLabel+1")
-                        if(stepsize<0)
+            if(iterableDt.isSignedByteArray) {
+                if(stepsize<0) {
                     asmgen.out("""
                         clc
                         sbc  $varname
                         bvc  +
-                                eor  #${'$'}80
+                        eor  #$80
 +                       bpl  $endLabel""")
-                        else
+                }
+                else {
                     asmgen.out("""
                         sec
                         sbc  $varname
                         bvc  +
-                                eor  #${'$'}80
+                        eor  #$80
 +                       bmi  $endLabel""")
+                }
             } else {
-                        if(stepsize<0)
+                if(stepsize<0) {
                     asmgen.out("""
                         cmp  $varname
                         beq  +
                         bcs  $endLabel
 +""")
-                        else
+                }
+                else {
                     asmgen.out("  cmp  $varname  |  bcc  $endLabel")
-                        asmgen.out("  sta  $modifiedLabel+1")
+                }
             }
             asmgen.out(loopLabel)
-                    asmgen.translate(stmt.statements)
+            asmgen.translate(forloop.statements)
             asmgen.out("""
                 lda  $varname
-$modifiedLabel          cmp  #0         ; modified 
+                cmp  $toValueVar
                 beq  $endLabel
                 $incdec  $varname""")
             asmgen.jmp(loopLabel)
@@ -97,28 +134,75 @@ $modifiedLabel          cmp  #0         ; modified
 
         } else {
 
-                    // bytes, step >= 2 or <= -2
-
-                    // loop over byte range via loopvar
-                    val varname = asmgen.asmVariableName(stmt.variable)
-                    asmgen.assignExpressionToVariable(range.from, varname, ArrayToElementTypes.getValue(iterableDt))
-                    asmgen.assignExpressionToRegister(range.to, RegisterOrPair.A, false)
+            // use self-modifying code to store the loop end comparison value
+            val modifiedLabel = asmgen.makeLabel("for_modified")
+            asmgen.assignExpressionToRegister(range.to, RegisterOrPair.A)
             // pre-check for end already reached
-                    if(iterableDt==DataType.ARRAY_B) {
+            if(iterableDt.isSignedByteArray) {
+                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(forloop.statements)
+            asmgen.out("""
+                lda  $varname
+$modifiedLabel  cmp  #0         ; modified 
+                beq  $endLabel
+                $incdec  $varname""")
+            asmgen.jmp(loopLabel)
+            asmgen.out(endLabel)
+        }
+    }
+
+    private fun forOverBytesRangeStepGreaterOne(range: PtRange, varname: String, iterableDt: DataType, loopLabel: String, endLabel: String, forloop: PtForLoop) {
+        // bytes range, step >= 2 or <= -2
+
+        val stepsize = range.step.asConstInteger()!!
+
+        val modifiedLabel = asmgen.makeLabel("for_modified")
+        asmgen.assignExpressionToRegister(range.to, RegisterOrPair.A)
+        // pre-check for end already reached
+        if(iterableDt.isSignedByteArray) {
             asmgen.out("  sta  $modifiedLabel+1")
             if(stepsize<0)
                 asmgen.out("""
                     clc
                     sbc  $varname
                     bvc  +
-                                eor  #${'$'}80
+                    eor  #$80
 +                   bpl  $endLabel""")
             else
                 asmgen.out("""
                     sec
                     sbc  $varname
                     bvc  +
-                                eor  #${'$'}80
+                    eor  #$80
 +                   bmi  $endLabel""")
         } else {
             if(stepsize<0)
@@ -127,12 +211,15 @@ $modifiedLabel          cmp  #0         ; modified
                     beq  +
                     bcs  $endLabel
 +""")
-                        else
+            else {
                 asmgen.out("  cmp  $varname  |  bcc  $endLabel")
+            }
             asmgen.out("  sta  $modifiedLabel+1")
         }
         asmgen.out(loopLabel)
-                    asmgen.translate(stmt.statements)
+        asmgen.translate(forloop.statements)
+
+        asmgen.romableError("self-modifying code (forloop over bytes range)", forloop.position)  // TODO fix romable; there is self-modifying code below
         if(stepsize>0) {
             asmgen.out("""
                 lda  $varname
@@ -153,22 +240,103 @@ $modifiedLabel              cmp  #0     ; modified
         }
         asmgen.out(endLabel)
     }
-            }
-            DataType.ARRAY_W, DataType.ARRAY_UW -> {
-                when {
 
-                    // words, step 1 or -1
-
-                    stepsize == 1 || stepsize == -1 -> {
+    private fun forOverNonconstWordRange(stmt: PtForLoop, iterableDt: DataType, range: PtRange) {
+        val stepsize = range.step.asConstInteger()!!
+        val loopLabel = asmgen.makeLabel("for_loop")
+        val endLabel = asmgen.makeLabel("for_end")
+        asmgen.loopEndLabels.add(endLabel)
         val varname = asmgen.asmVariableName(stmt.variable)
         assignLoopvarWord(stmt, range)
+        if(stepsize==-1 && range.to.asConstInteger()==0) {
+            // simple loop downto 0 step -1 (words)
+            asmgen.out(loopLabel)
+            asmgen.translate(stmt.statements)
+            asmgen.out("""
+                lda  $varname
+                bne  ++
+                lda  $varname+1
+                beq  $endLabel
++               lda  $varname
+                bne  +
+                dec  $varname+1
++               dec  $varname""")
+            asmgen.jmp(loopLabel)
+            asmgen.out(endLabel)
+        }
+        else if (stepsize==-1 && range.to.asConstInteger()==1) {
+            // simple loop downto 1 step -1 (words)
+            asmgen.out(loopLabel)
+            asmgen.translate(stmt.statements)
+            asmgen.out("""
+                lda  $varname
+                cmp  #1
+                bne  +
+                lda  $varname+1
+                beq  $endLabel
++               lda  $varname
+                bne  +
+                dec  $varname+1
++               dec  $varname""")
+            asmgen.jmp(loopLabel)
+            asmgen.out(endLabel)
+        }
+        else if (stepsize == 1 || stepsize == -1)
+            forOverWordsRangeStepOne(range, varname, iterableDt, loopLabel, endLabel, stmt)
+        else if (stepsize > 0)
+            forOverWordsRangeStepGreaterOne(range, varname, iterableDt, loopLabel, endLabel, stmt)
+        else
+            forOverWordsRangeStepGreaterOneDescending(range, varname, iterableDt, loopLabel, endLabel, stmt)
+    }
+
+    private fun forOverWordsRangeStepOne(range: PtRange, varname: String, iterableDt: DataType, loopLabel: String, endLabel: String, forloop: PtForLoop) {
+        // words range, step 1 or -1
+        val stepsize = range.step.asConstInteger()!!
+
+        if(asmgen.options.romable) {
+            // cannot use self-modifying code, cannot use cpu stack (because loop can be interrupted halfway)
+            // so we need to store the loop end value in a newly allocated temporary variable
+            val toValueVar = asmgen.createTempVarReused(iterableDt.elementType().base, false, range)
+            asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
+            precheckFromToWord(iterableDt, stepsize, varname, endLabel)
+            asmgen.out("  sta  $toValueVar")
+            asmgen.out("  sty  $toValueVar+1")
+            asmgen.out(loopLabel)
+            asmgen.translate(forloop.statements)
+            asmgen.out("""
+                lda  $varname+1
+                cmp  $toValueVar+1
+                bne  +
+                lda  $varname
+                cmp  $toValueVar
+                beq  $endLabel""")
+            if(stepsize==1) {
+                asmgen.out("""
++                   inc  $varname
+                    bne  $loopLabel
+                    inc  $varname+1""")
+                asmgen.jmp(loopLabel)
+            } else {
+                asmgen.out("""
++                   lda  $varname
+                    bne  +
+                    dec  $varname+1
++                   dec  $varname""")
+                asmgen.jmp(loopLabel)
+            }
+            asmgen.out(endLabel)
+
+        } else {
+
+            val modifiedLabel = asmgen.makeLabel("for_modified")
+            val modifiedLabel2 = asmgen.makeLabel("for_modifiedb")
             asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
             precheckFromToWord(iterableDt, stepsize, varname, endLabel)
             asmgen.out("""
                 sty  $modifiedLabel+1
                 sta  $modifiedLabel2+1
 $loopLabel""")
-                        asmgen.translate(stmt.statements)
+            asmgen.translate(forloop.statements)
             asmgen.out("""
                 lda  $varname+1
 $modifiedLabel  cmp  #0    ; modified 
@@ -192,11 +360,13 @@ $modifiedLabel2 cmp  #0    ; modified
             }
             asmgen.out(endLabel)
         }
-                    stepsize > 0 -> {
+    }
 
+    private fun forOverWordsRangeStepGreaterOne(range: PtRange, varname: String, iterableDt: DataType, loopLabel: String, endLabel: String, stmt: PtForLoop) {
         // (u)words, step >= 2
-                        val varname = asmgen.asmVariableName(stmt.variable)
-                        assignLoopvarWord(stmt, range)
+        val stepsize = range.step.asConstInteger()!!
+        val modifiedLabel = asmgen.makeLabel("for_modified")
+        val modifiedLabel2 = asmgen.makeLabel("for_modifiedb")
         asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
         precheckFromToWord(iterableDt, stepsize, varname, endLabel)
         asmgen.out("""
@@ -205,7 +375,8 @@ $modifiedLabel2 cmp  #0    ; modified
 $loopLabel""")
         asmgen.translate(stmt.statements)
 
-                        if (iterableDt == DataType.ARRAY_UW) {
+        asmgen.romableError("self-modifying code (forloop over word range)", stmt.position)  // TODO fix romable; there is self-modifying code below
+        if (iterableDt.isUnsignedWordArray) {
             asmgen.out("""
                 lda  $varname
                 clc
@@ -241,11 +412,12 @@ $modifiedLabel  lda  #0   ; modified
 $endLabel""")
         }
     }
-                    else -> {
 
+    private fun forOverWordsRangeStepGreaterOneDescending(range: PtRange, varname: String, iterableDt: DataType, loopLabel: String, endLabel: String, stmt: PtForLoop) {
         // (u)words, step <= -2
-                        val varname = asmgen.asmVariableName(stmt.variable)
-                        assignLoopvarWord(stmt, range)
+        val stepsize = range.step.asConstInteger()!!
+        val modifiedLabel = asmgen.makeLabel("for_modified")
+        val modifiedLabel2 = asmgen.makeLabel("for_modifiedb")
         asmgen.assignExpressionToRegister(range.to, RegisterOrPair.AY)
         precheckFromToWord(iterableDt, stepsize, varname, endLabel)
         asmgen.out("""
@@ -253,7 +425,6 @@ $endLabel""")
                 sta  $modifiedLabel2+1
 $loopLabel""")
         asmgen.translate(stmt.statements)
-
         asmgen.out("""
                 lda  $varname
                 sec
@@ -271,19 +442,13 @@ $modifiedLabel  sbc  #0    ; modified
                 eor  #$80
 +               bpl  $loopLabel                
 $endLabel""")
-                    }
-                }
-            }
-            else -> throw AssemblyError("range expression can only be byte or word")
-        }
-
-        asmgen.loopEndLabels.pop()
+        asmgen.romableError("self-modifying code (forloop over words range)", stmt.position)  // TODO fix romable
     }
 
     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(iterableDt.isSignedWordArray) {
             if(stepsize<0)
                 asmgen.out("""
                     sta  P8ZP_SCRATCH_W2        ; to
@@ -293,7 +458,7 @@ $endLabel""")
                     lda  $fromVar+1
                     sbc  P8ZP_SCRATCH_W2+1
                     bvc  +
-	                eor  #${'$'}80
+                    eor  #$80
 +                   bmi  $endLabel
                     lda  P8ZP_SCRATCH_W2
                     ldy  P8ZP_SCRATCH_W2+1""")
@@ -304,7 +469,7 @@ $endLabel""")
                     tya
                     sbc  $fromVar+1
                     bvc  +
-	                eor  #${'$'}80
+                    eor  #$80
 +                   bmi  $endLabel
                     lda  P8ZP_SCRATCH_REG""")
         } else {
@@ -333,36 +498,53 @@ $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)
+        asmgen.loopEndLabels.add(endLabel)
         val iterableName = asmgen.asmVariableName(ident)
-        val symbol = asmgen.symbolTable.lookup(ident.name)
-        val numElements = when(symbol) {
+        val numElements = when(val symbol = asmgen.symbolTable.lookup(ident.name)) {
             is StStaticVariable -> symbol.length!!
             is StMemVar -> symbol.length!!
             else -> 0
         }
-        when(iterableDt) {
-            DataType.STR -> {
+        when {
+            iterableDt.isString -> {
+                if(asmgen.options.romable) {
+                    val indexVar = asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
                     asmgen.out("""
-                    lda  #<$iterableName
-                    ldy  #>$iterableName
-                    sta  $loopLabel+1
-                    sty  $loopLabel+2
-$loopLabel          lda  ${65535.toHex()}       ; modified
+                        ldy  #0
+                        sty  $indexVar
+$loopLabel              lda  $iterableName,y
                         beq  $endLabel
                         sta  ${asmgen.asmVariableName(stmt.variable)}""")
                     asmgen.translate(stmt.statements)
                     asmgen.out("""
-                    inc  $loopLabel+1
-                    bne  $loopLabel
-                    inc  $loopLabel+2
+                        inc  $indexVar
+                        ldy  $indexVar
                         bne  $loopLabel
 $endLabel""")
-            }
-            DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                } else {
                     val indexVar = asmgen.makeLabel("for_index")
                     asmgen.out("""
                         ldy  #0
+                        sty  $indexVar
+$loopLabel              lda  $iterableName,y
+                        beq  $endLabel
+                        sta  ${asmgen.asmVariableName(stmt.variable)}""")
+                    asmgen.translate(stmt.statements)
+                    asmgen.out("""
+                        inc  $indexVar
+                        ldy  $indexVar
+                        bne  $loopLabel
+$indexVar   .byte  0                        
+$endLabel""")
+                }
+            }
+            iterableDt.isByteArray || iterableDt.isBoolArray -> {
+                val indexVar = if(asmgen.options.romable)
+                    asmgen.createTempVarReused(iterableDt.elementType().base, false, stmt)
+                else
+                    asmgen.makeLabel("for_index")
+                asmgen.out("""
+                    ldy  #0
 $loopLabel          sty  $indexVar
                     lda  $iterableName,y
                     sta  ${asmgen.asmVariableName(stmt.variable)}""")
@@ -382,8 +564,9 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
+                if(!asmgen.options.romable) {
                     if(numElements>=16) {
-                    // allocate index var on ZP if possible
+                        // allocate index var on ZP if possible, otherwise inline
                         val result = zeropage.allocate(indexVar, DataType.UBYTE, null, stmt.position, asmgen.errors)
                         result.fold(
                             success = { (address, _, _)-> asmgen.out("""$indexVar = $address  ; auto zp UBYTE""") },
@@ -392,51 +575,14 @@ $loopLabel          sty  $indexVar
                     } else {
                         asmgen.out("$indexVar    .byte  0")
                     }
-                asmgen.out(endLabel)
-            }
-            DataType.ARRAY_W, DataType.ARRAY_UW -> {
-                val length = numElements * 2
-                val indexVar = asmgen.makeLabel("for_index")
-                val loopvarName = asmgen.asmVariableName(stmt.variable)
-                asmgen.out("""
-                    ldy  #0
-$loopLabel          sty  $indexVar
-                    lda  $iterableName,y
-                    sta  $loopvarName
-                    lda  $iterableName+1,y
-                    sta  $loopvarName+1""")
-                asmgen.translate(stmt.statements)
-                if(length<=127) {
-                    asmgen.out("""
-                        ldy  $indexVar
-                        iny
-                        iny
-                        cpy  #$length
-                        beq  $endLabel
-                        bne  $loopLabel""")
-                } else {
-                    // length is 128 words, 256 bytes
-                    asmgen.out("""
-                        ldy  $indexVar
-                        iny
-                        iny
-                        bne  $loopLabel
-                        beq  $endLabel""")
-                }
-                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""") },
-                        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")
+            iterableDt.isSplitWordArray -> {
+                val indexVar = if(asmgen.options.romable)
+                    asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
+                else
+                    asmgen.makeLabel("for_index")
                 val loopvarName = asmgen.asmVariableName(stmt.variable)
                 asmgen.out("""
                     ldy  #0
@@ -461,34 +607,83 @@ $loopLabel          sty  $indexVar
                         bne  $loopLabel
                         beq  $endLabel""")
                 }
+                if(!asmgen.options.romable) {
                     if(numElements>=16) {
-                    // allocate index var on ZP if possible
+                        // allocate index var on ZP if possible, otherwise inline
                         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_F -> {
+            iterableDt.isWordArray -> {
+                val indexVar = if(asmgen.options.romable)
+                    asmgen.createTempVarReused(BaseDataType.UBYTE, false, stmt)
+                else
+                    asmgen.makeLabel("for_index")
+                val loopvarName = asmgen.asmVariableName(stmt.variable)
+                asmgen.out("""
+                    ldy  #0
+$loopLabel          sty  $indexVar
+                    lda  $iterableName,y
+                    sta  $loopvarName
+                    lda  $iterableName+1,y
+                    sta  $loopvarName+1""")
+                asmgen.translate(stmt.statements)
+                if(numElements<=127) {
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        iny
+                        cpy  #${numElements*2}
+                        beq  $endLabel
+                        bne  $loopLabel""")
+                } else {
+                    // array size is 128 words, 256 bytes
+                    asmgen.out("""
+                        ldy  $indexVar
+                        iny
+                        iny
+                        bne  $loopLabel
+                        beq  $endLabel""")
+                }
+                if(!asmgen.options.romable) {
+                    if(numElements>=16) {
+                        // allocate index var on ZP if possible, otherwise inline
+                        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 {
+                        asmgen.out("$indexVar    .byte  0")
+                    }
+                }
+                asmgen.out(endLabel)
+            }
+            iterableDt.isFloatArray -> {
                 throw AssemblyError("for loop with floating point variables is not supported")
             }
             else -> throw AssemblyError("can't iterate over $iterableDt")
         }
-        asmgen.loopEndLabels.pop()
+        asmgen.loopEndLabels.removeLast()
     }
 
     private fun translateForOverConstRange(stmt: PtForLoop, iterableDt: DataType, range: IntProgression) {
         if (range.isEmpty() || range.step==0)
             throw AssemblyError("empty range or step 0")
-        if(iterableDt==DataType.ARRAY_B || iterableDt==DataType.ARRAY_UB) {
+        if(iterableDt.isByteArray) {
+            if(range.last==range.first) return translateForSimpleByteRangeAsc(stmt, range)
             if(range.step==1 && range.last>range.first) return translateForSimpleByteRangeAsc(stmt, range)
-            if(range.step==-1 && range.last<range.first) return translateForSimpleByteRangeDesc(stmt, range)
+            if(range.step==-1 && range.last<range.first) return translateForSimpleByteRangeDesc(stmt, range, iterableDt.isUnsignedByteArray)
         }
-        else if(iterableDt==DataType.ARRAY_W || iterableDt==DataType.ARRAY_UW) {
+        else if(iterableDt.isWordArray) {
+            if(range.last==range.first) return translateForSimpleWordRangeAsc(stmt, range)
             if(range.step==1 && range.last>range.first) return translateForSimpleWordRangeAsc(stmt, range)
             if(range.step==-1 && range.last<range.first) return translateForSimpleWordRangeDesc(stmt, range)
         }
@@ -496,9 +691,9 @@ $loopLabel          sty  $indexVar
         // not one of the easy cases, generate more complex code...
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
-        asmgen.loopEndLabels.push(endLabel)
-        when(iterableDt) {
-            DataType.ARRAY_B, DataType.ARRAY_UB -> {
+        asmgen.loopEndLabels.add(endLabel)
+        when {
+            iterableDt.isByteArray -> {
                 // loop over byte range via loopvar, step >= 2 or <= -2
                 val varname = asmgen.asmVariableName(stmt.variable)
                 asmgen.out("""
@@ -508,7 +703,7 @@ $loopLabel""")
                 asmgen.translate(stmt.statements)
                 when (range.step) {
                     0, 1, -1 -> {
-                        throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $stmt")
+                        throw AssemblyError("step 0, 1 and -1 should have been handled specifically  $range ${stmt.position}")
                     }
                     2 -> {
                         if(range.last==255 || range.last==254) {
@@ -563,7 +758,7 @@ $loopLabel""")
                 }
                 asmgen.out(endLabel)
             }
-            DataType.ARRAY_W, DataType.ARRAY_UW -> {
+            iterableDt.isWordArray && !iterableDt.isSplitWordArray -> {
                 // loop over word range via loopvar, step >= 2 or <= -2
                 val varname = asmgen.asmVariableName(stmt.variable)
                 when (range.step) {
@@ -602,13 +797,13 @@ $loopLabel""")
             }
             else -> throw AssemblyError("range expression can only be byte or word")
         }
-        asmgen.loopEndLabels.pop()
+        asmgen.loopEndLabels.removeLast()
     }
 
     private fun translateForSimpleByteRangeAsc(stmt: PtForLoop, range: IntProgression) {
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
-        asmgen.loopEndLabels.push(endLabel)
+        asmgen.loopEndLabels.add(endLabel)
         val varname = asmgen.asmVariableName(stmt.variable)
         asmgen.out("""
                 lda  #${range.first}
@@ -628,13 +823,11 @@ $endLabel""")
                 bne  $loopLabel
 $endLabel""")
         }
-        asmgen.loopEndLabels.pop()
+        asmgen.loopEndLabels.removeLast()
     }
 
-    private fun translateForSimpleByteRangeDesc(stmt: PtForLoop, range: IntProgression) {
+    private fun translateForSimpleByteRangeDesc(stmt: PtForLoop, range: IntProgression, unsigned: Boolean) {
         val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
-        asmgen.loopEndLabels.push(endLabel)
         val varname = asmgen.asmVariableName(stmt.variable)
         asmgen.out("""
             lda  #${range.first}
@@ -643,35 +836,37 @@ $loopLabel""")
         asmgen.translate(stmt.statements)
         when (range.last) {
             0 -> {
+                if(!unsigned || range.first<=127) {
                     asmgen.out("""
+                        dec  $varname
+                        bpl  $loopLabel""")
+                } else {
+                    asmgen.out("""
+                        dec  $varname
                         lda  $varname
-                    beq  $endLabel
-                    dec  $varname""")
-                asmgen.jmp(loopLabel)
-                asmgen.out(endLabel)
+                        cmp  #255
+                        bne  $loopLabel""")
+                }
             }
             1 -> {
                 asmgen.out("""
                     dec  $varname
-                    bne  $loopLabel
-$endLabel""")
+                    bne  $loopLabel""")
             }
             else -> {
                 asmgen.out("""
                     dec  $varname
                     lda  $varname
                     cmp  #${range.last-1}
-                    bne  $loopLabel
-$endLabel""")
+                    bne  $loopLabel""")
             }
         }
-        asmgen.loopEndLabels.pop()
     }
 
     private fun translateForSimpleWordRangeAsc(stmt: PtForLoop, range: IntProgression) {
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
-        asmgen.loopEndLabels.push(endLabel)
+        asmgen.loopEndLabels.add(endLabel)
         val varname = asmgen.asmVariableName(stmt.variable)
         asmgen.out("""
             lda  #<${range.first}
@@ -692,13 +887,13 @@ $loopLabel""")
             inc  $varname+1""")
         asmgen.jmp(loopLabel)
         asmgen.out(endLabel)
-        asmgen.loopEndLabels.pop()
+        asmgen.loopEndLabels.removeLast()
     }
 
     private fun translateForSimpleWordRangeDesc(stmt: PtForLoop, range: IntProgression) {
         val loopLabel = asmgen.makeLabel("for_loop")
         val endLabel = asmgen.makeLabel("for_end")
-        asmgen.loopEndLabels.push(endLabel)
+        asmgen.loopEndLabels.add(endLabel)
         val varname = asmgen.asmVariableName(stmt.variable)
         asmgen.out("""
             lda  #<${range.first}
@@ -707,20 +902,29 @@ $loopLabel""")
             sty  $varname+1
 $loopLabel""")
         asmgen.translate(stmt.statements)
+        if(range.last==0) {
+            asmgen.out("""
+                lda  $varname
+                bne  ++
+                lda  $varname+1
+                beq  $endLabel""")
+        } else {
             asmgen.out("""
                 lda  $varname
                 cmp  #<${range.last}
                 bne  +
                 lda  $varname+1
                 cmp  #>${range.last}
-            beq  $endLabel
+                beq  $endLabel""")
+        }
+        asmgen.out("""
 +           lda  $varname
             bne  +
             dec  $varname+1
 +           dec  $varname""")
         asmgen.jmp(loopLabel)
         asmgen.out(endLabel)
-        asmgen.loopEndLabels.pop()
+        asmgen.loopEndLabels.removeLast()
     }
 
     private fun assignLoopvarWord(stmt: PtForLoop, range: PtRange) =

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

@@ -1,5 +1,6 @@
 package prog8.codegen.cpu6502
 
+import prog8.code.StNodeType
 import prog8.code.ast.*
 import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.AsmAssignSource
@@ -15,9 +16,16 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         // just ignore any result values from the function call.
     }
 
-    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)
+    internal fun optimizeIntArgsViaCpuRegisters(params: List<PtSubroutineParameter>): Boolean {
+        // When the parameter(s) are passed via an explicit register or register pair,
+        // we consider them NOT to be optimized into (possibly different) CPU registers.
+        // Just load them in whatever the register spec says.
+        return when (params.size) {
+            1 -> params[0].type.isIntegerOrBool && params[0].register == null
+            2 -> params[0].type.isByteOrBool && params[1].type.isByteOrBool && params[0].register == null && params[1].register == null
+            else -> false
+        }
+    }
 
     internal fun translateFunctionCall(call: PtFunctionCall) {
         // Output only the code to set up the parameters and perform the actual call
@@ -25,8 +33,14 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         // NOTE: does NOT output code to save/restore the X register for this call! Every caller should deal with this in their own way!!
         //       (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 symbol = asmgen.symbolTable.lookup(call.name)!!
+        if(symbol.type == StNodeType.LABEL) {
+            require(call.void)
+            asmgen.out("  jsr  ${asmgen.asmSymbolName(symbol.scopedName)}")
+            return
+        }
+
+        val sub = symbol.astNode as IPtSubroutine
         val subAsmName = asmgen.asmSymbolName(call.name)
 
         if(sub is PtAsmSub) {
@@ -39,28 +53,110 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                 asmgen.out("  \t; inlined routine follows: ${sub.name}")
                 sub.children.forEach { asmgen.translate(it as PtInlineAssembly) }
                 asmgen.out("  \t; inlined routine end: ${sub.name}")
+            } else {
+                val bank = sub.address?.constbank?.toString()
+                if(bank==null) {
+                    val varbank = if(sub.address?.varbank==null) null else asmgen.asmVariableName(sub.address!!.varbank!!)
+                    if(varbank!=null) {
+                        if(asmgen.options.romable)
+                            TODO("no codegen yet for non-const bank in subroutine call that's usable in ROM  ${call.position}")
+
+                        // self-modifying code: set jsrfar bank argument
+                        when(asmgen.options.compTarget.name) {
+                            "cx16" -> {
+                                // JSRFAR can jump to a banked RAM address as well!
+                                asmgen.out("""
+                                php
+                                pha
+                                lda  $varbank
+                                sta  +
+                                pla
+                                plp
+                                jsr  cx16.JSRFAR
+                                .word  $subAsmName    ; ${sub.address!!.address.toHex()}
++                               .byte  0    ; modified"""
+                                )
+                            }
+                            "c64" -> {
+                                asmgen.out("""
+                                php
+                                pha
+                                lda  $varbank
+                                sta  +
+                                pla
+                                plp
+                                jsr  c64.x16jsrfar
+                                .word  $subAsmName    ; ${sub.address!!.address.toHex()}
++                               .byte  0    ; modified"""
+                                )
+                            }
+                            "c128" -> {
+                                asmgen.out("""
+                                php
+                                pha
+                                lda  $varbank
+                                sta  +
+                                pla
+                                plp
+                                jsr  c128.x16jsrfar
+                                .word  $subAsmName    ; ${sub.address!!.address.toHex()}
++                               .byte  0    ; modified"""
+                                )
+                            }
+                            else -> throw AssemblyError("callfar is not supported on the selected compilation target")
+                        }
                     } else {
                         asmgen.out("  jsr  $subAsmName")
                     }
                 }
-        else if(sub is PtSub) {
-            if(optimizeIntArgsViaRegisters(sub)) {
-                if(sub.parameters.size==1) {
-                    val register = if (sub.parameters[0].type in ByteDatatypes) RegisterOrPair.A else RegisterOrPair.AY
-                    argumentViaRegister(sub, IndexedValue(0, sub.parameters[0]), call.args[0], register)
-                } else {
-                    // 2 byte params, second in Y, first in A
-                    argumentViaRegister(sub, IndexedValue(0, sub.parameters[0]), call.args[0], RegisterOrPair.A)
-                    if(asmgen.needAsaveForExpr(call.args[1]))
-                        asmgen.out("  pha")
-                    argumentViaRegister(sub, IndexedValue(1, sub.parameters[1]), call.args[1], RegisterOrPair.Y)
-                    if(asmgen.needAsaveForExpr(call.args[1]))
-                        asmgen.out("  pla")
+                else {
+                    when(asmgen.options.compTarget.name) {
+                        "cx16" -> {
+                            // JSRFAR can jump to a banked RAM address as well!
+                            asmgen.out("""
+                                jsr cx16.JSRFAR
+                                .word  $subAsmName    ; ${sub.address!!.address.toHex()}
+                                .byte  $bank"""
+                            )
                         }
+                        "c64" -> {
+                            asmgen.out("""
+                                jsr  c64.x16jsrfar
+                                .word  $subAsmName    ; ${sub.address!!.address.toHex()}
+                                .byte  $bank"""
+                            )
+                        }
+                        "c128" -> {
+                            asmgen.out("""
+                                jsr  c128.x16jsrfar
+                                .word  $subAsmName    ; ${sub.address!!.address.toHex()}
+                                .byte  $bank"""
+                            )
+                        }
+                        else -> throw AssemblyError("callfar is not supported on the selected compilation target")
+                    }
+                }
+            }
+        }
+        else if(sub is PtSub) {
+            if(optimizeIntArgsViaCpuRegisters(sub.parameters)) {
+                // Note that if the args fit into cpu registers, we don't concern ourselves here
+                // if they should be put into regular subroutine parameter variables, or the R0-R15 register variables.
+                // That is now up to the subroutine itself.
+                useCpuRegistersForArgs(call.args, sub)
             } else {
                 // arguments via variables
-                for(arg in sub.parameters.withIndex().zip(call.args))
-                    argumentViaVariable(sub, arg.first.value, arg.second)
+                val paramValues = sub.parameters.zip(call.args)
+                val (normalParams, registerParams) = paramValues.partition { it.first.register == null }
+                if (normalParams.isNotEmpty()) {
+                    for (p in normalParams)
+                        argumentViaVariable(sub, p.first, p.second)
+                }
+                if (registerParams.isNotEmpty()) {
+                    // the R0-R15 'registers' are not really registers. They're just special variables.
+                    for (p in registerParams)
+                        argumentViaVariable(sub, p.first, p.second)
+                }
             }
             asmgen.out("  jsr  $subAsmName")
         }
@@ -69,11 +165,45 @@ 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 useCpuRegistersForArgs(args: List<PtExpression>, sub: PtSub) {
+        val params = sub.parameters
+        when(params.size) {
+            1 -> {
+                val register = if (params[0].type.isByteOrBool) RegisterOrPair.A else RegisterOrPair.AY
+                argumentViaRegister(sub, IndexedValue(0, params[0]), args[0], register)
+            }
+            2 -> {
+                if(params[0].type.isByteOrBool && params[1].type.isByteOrBool) {
+                    // 2 byte params, second in Y, first in A
+                    if(asmgen.needAsaveForExpr(args[0]) && !asmgen.needAsaveForExpr(args[1])) {
+                        // first 0 then 1
+                        argumentViaRegister(sub, IndexedValue(0, params[0]), args[0], RegisterOrPair.A)
+                        argumentViaRegister(sub, IndexedValue(1, params[1]), args[1], RegisterOrPair.Y)
+                    } else if(!asmgen.needAsaveForExpr(args[0]) && asmgen.needAsaveForExpr(args[1])) {
+                        // first 1 then 0
+                        argumentViaRegister(sub, IndexedValue(1, params[1]), args[1], RegisterOrPair.Y)
+                        argumentViaRegister(sub, IndexedValue(0, params[0]), args[0], RegisterOrPair.A)
+                    } else {
+                        argumentViaRegister(sub, IndexedValue(0, params[0]), args[0], RegisterOrPair.A)
+                        if (asmgen.needAsaveForExpr(args[1]))
+                            asmgen.out("  pha")
+                        argumentViaRegister(sub, IndexedValue(1, params[1]), args[1], RegisterOrPair.Y)
+                        if (asmgen.needAsaveForExpr(args[1]))
+                            asmgen.out("  pla")
+                    }
+                } else {
+                    throw AssemblyError("cannot use registers for word+byte")
+                }
+            }
+            else -> throw AssemblyError("cannot use cpu registers for >2 arguments")
+        }
+    }
+
 
     private fun usesOtherRegistersWhileEvaluating(arg: PtExpression): Boolean {
         return when(arg) {
             is PtBuiltinFunctionCall -> {
-                if (arg.name == "lsb" || arg.name == "msb")
+                if (arg.name in arrayOf("lsb", "msb", "lsw", "msw"))
                     return usesOtherRegistersWhileEvaluating(arg.args[0])
                 if (arg.name == "mkword")
                     return usesOtherRegistersWhileEvaluating(arg.args[0]) || usesOtherRegistersWhileEvaluating(arg.args[1])
@@ -81,15 +211,16 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
             }
             is PtAddressOf -> false
             is PtIdentifier -> false
-            is PtMachineRegister -> false
-            is PtMemoryByte -> false
+            is PtIrRegister -> false
+            is PtMemoryByte -> arg.address !is PtNumber && arg.address !is PtIdentifier
             is PtNumber -> false
+            is PtBool -> false
             else -> true
         }
     }
 
     private fun argumentsViaRegisters(sub: PtAsmSub, call: PtFunctionCall) {
-        val registersUsed = mutableListOf<RegisterOrStatusflag>();
+        val registersUsed = mutableListOf<RegisterOrStatusflag>()
 
         fun usedA() = registersUsed.any {it.registerOrPair==RegisterOrPair.A || it.registerOrPair==RegisterOrPair.AX || it.registerOrPair==RegisterOrPair.AY}
         fun usedX() = registersUsed.any {it.registerOrPair==RegisterOrPair.X || it.registerOrPair==RegisterOrPair.AX || it.registerOrPair==RegisterOrPair.XY}
@@ -103,15 +234,15 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                 val param = sub.parameters[it]
                 val arg = call.args[it]
                 registersUsed += if(usesOtherRegistersWhileEvaluating(arg)) {
-                    if(!registersUsed.any{it.statusflag!=null || it.registerOrPair in CpuRegisters})
+                    if(!registersUsed.any{r -> r.statusflag!=null || r.registerOrPair in CpuRegisters})
                         argumentViaRegister(sub, IndexedValue(it, param.second), arg)
-                    else if(registersUsed.any {it.statusflag!=null}) {
+                    else if(registersUsed.any { r-> r.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)
+                        if(usedX()) asmgen.saveRegisterStack(CpuRegister.X, usedA())
+                        if(usedY()) asmgen.saveRegisterStack(CpuRegister.Y, usedA())
+                        if(usedA()) asmgen.saveRegisterStack(CpuRegister.A, usedA())
                         val used = argumentViaRegister(sub, IndexedValue(it, param.second), arg)
                         if(usedA()) asmgen.restoreRegisterStack(CpuRegister.A, false)
                         if(usedY()) asmgen.restoreRegisterStack(CpuRegister.Y, true)
@@ -130,9 +261,16 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         if(!isArgumentTypeCompatible(value.type, parameter.type))
             throw AssemblyError("argument type incompatible")
 
+        val reg = parameter.register
+        if(reg!=null) {
+            require(reg in Cx16VirtualRegisters) { "can only use R0-R15 'registers' here" }
+            val varName = "cx16.${reg.name.lowercase()}"
+            asmgen.assignExpressionToVariable(value, varName, parameter.type)
+        } else {
             val varName = asmgen.asmVariableName(sub.scopedName + "." + parameter.name)
             asmgen.assignExpressionToVariable(value, varName, parameter.type)
         }
+    }
 
     private fun argumentViaRegister(sub: IPtSubroutine, parameter: IndexedValue<PtSubroutineParameter>, value: PtExpression, registerOverride: RegisterOrPair? = null): RegisterOrStatusflag {
         // pass argument via a register parameter
@@ -147,12 +285,12 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         val register = paramRegister.registerOrPair
         val requiredDt = parameter.value.type
         if(requiredDt!=value.type) {
-            if(value.type largerThan requiredDt)
+            if(value.type.largerSizeThan(requiredDt))
                 throw AssemblyError("can only convert byte values to word param types")
         }
         if (statusflag!=null) {
             if(requiredDt!=value.type)
-                throw AssemblyError("for statusflag, byte value is required")
+                throw AssemblyError("for statusflag, byte or bool value is required")
             if (statusflag == Statusflag.Pc) {
                 // 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
@@ -161,6 +299,9 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                         val carrySet = value.number.toInt() != 0
                         asmgen.out(if(carrySet) "  sec" else "  clc")
                     }
+                    is PtBool -> {
+                        asmgen.out(if(value.value) "  sec" else "  clc")
+                    }
                     is PtIdentifier -> {
                         val sourceName = asmgen.asmVariableName(value)
                         // note: cannot use X register here to store A because it might be used for other arguments
@@ -183,25 +324,24 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
         else {
             // via register or register pair
             register!!
-            if(requiredDt largerThan value.type) {
+            if(requiredDt.largerSizeThan(value.type)) {
                 // we need to sign extend the source, do this via temporary word variable
                 asmgen.assignExpressionToVariable(value, "P8ZP_SCRATCH_W1", DataType.UBYTE)
-                asmgen.signExtendVariableLsb("P8ZP_SCRATCH_W1", value.type)
+                asmgen.signExtendVariableLsb("P8ZP_SCRATCH_W1", value.type.base)
                 asmgen.assignVariableToRegister("P8ZP_SCRATCH_W1", register, null, Position.DUMMY)
             } else {
                 val scope = value.definingISub()
                 val target: AsmAssignTarget =
-                    if(parameter.value.type in ByteDatatypes && (register==RegisterOrPair.AX || register == RegisterOrPair.AY || register==RegisterOrPair.XY || register in Cx16VirtualRegisters))
+                    if(parameter.value.type.isByte && (register==RegisterOrPair.AX || register == RegisterOrPair.AY || register==RegisterOrPair.XY || register in Cx16VirtualRegisters))
                         AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, parameter.value.type, scope, value.position, register = register)
                     else {
-                        val signed = parameter.value.type == DataType.BYTE || parameter.value.type == DataType.WORD
-                        AsmAssignTarget.fromRegisters(register, signed, value.position, scope, asmgen)
+                        AsmAssignTarget.fromRegisters(register, parameter.value.type.isSigned, value.position, scope, asmgen)
                     }
-                val src = if(value.type in PassByReferenceDatatypes) {
+                val src = if(value.type.isPassByRef) {
                     if(value is PtIdentifier) {
                         val addr = PtAddressOf(Position.DUMMY)
                         addr.add(value)
-                        addr.parent = sub as PtNode
+                        addr.parent = scope as PtNode
                         AsmAssignSource.fromAstSource(addr, program, asmgen).adjustSignedUnsigned(target)
                     } else {
                         AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(target)
@@ -209,7 +349,7 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
                 } else {
                     AsmAssignSource.fromAstSource(value, program, asmgen).adjustSignedUnsigned(target)
                 }
-                asmgen.translateNormalAssignment(AsmAssignment(src, target, program.memsizer, Position.DUMMY), scope)
+                asmgen.translateNormalAssignment(AsmAssignment(src, listOf(target), program.memsizer, target.position), scope)
             }
             return RegisterOrStatusflag(register, null)
         }
@@ -218,16 +358,18 @@ internal class FunctionCallAsmGen(private val program: PtProgram, private val as
     private fun isArgumentTypeCompatible(argType: DataType, paramType: DataType): Boolean {
         if(argType isAssignableTo paramType)
             return true
-        if(argType in ByteDatatypes && paramType in ByteDatatypes)
+        if(argType.isBool && paramType.isBool)
             return true
-        if(argType in WordDatatypes && paramType in WordDatatypes)
+        if(argType.isByte && paramType.isByte)
+            return true
+        if(argType.isWord && paramType.isWord)
             return true
 
         // we have a special rule for some types.
         // strings are assignable to UWORD, for example, and vice versa
-        if(argType==DataType.STR && paramType==DataType.UWORD)
+        if(argType.isString && paramType.isUnsignedWord)
             return true
-        if(argType==DataType.UWORD && paramType == DataType.STR)
+        if(argType.isUnsignedWord && paramType.isString)
             return true
 
         return false

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

@@ -0,0 +1,362 @@
+package prog8.codegen.cpu6502
+
+import prog8.code.ast.*
+import prog8.code.core.*
+import prog8.codegen.cpu6502.assignment.AsmAssignTarget
+import prog8.codegen.cpu6502.assignment.AssignmentAsmGen
+import prog8.codegen.cpu6502.assignment.TargetStorageKind
+
+internal class IfExpressionAsmGen(private val asmgen: AsmGen6502Internal, private val assignmentAsmGen: AssignmentAsmGen, private val errors: IErrorReporter) {
+
+    internal fun assignIfExpression(target: AsmAssignTarget, expr: PtIfExpression) {
+        require(target.datatype==expr.type || target.datatype.isUnsignedWord && expr.type.isString)
+        val falseLabel = asmgen.makeLabel("ifexpr_false")
+        val endLabel = asmgen.makeLabel("ifexpr_end")
+        evalIfExpressionConditonAndBranchWhenFalse(expr.condition, falseLabel)
+        when {
+            expr.type.isByteOrBool -> {
+                asmgen.assignExpressionToRegister(expr.truevalue, RegisterOrPair.A)
+                asmgen.jmp(endLabel)
+                asmgen.out(falseLabel)
+                asmgen.assignExpressionToRegister(expr.falsevalue, RegisterOrPair.A)
+                asmgen.out(endLabel)
+                assignmentAsmGen.assignRegisterByte(target, CpuRegister.A, false, false)
+            }
+            expr.type.isWord || expr.type.isString -> {
+                asmgen.assignExpressionToRegister(expr.truevalue, RegisterOrPair.AY)
+                asmgen.jmp(endLabel)
+                asmgen.out(falseLabel)
+                asmgen.assignExpressionToRegister(expr.falsevalue, RegisterOrPair.AY)
+                asmgen.out(endLabel)
+                assignmentAsmGen.assignRegisterpairWord(target, RegisterOrPair.AY)
+            }
+            expr.type.isFloat -> {
+                asmgen.assignExpressionToRegister(expr.truevalue, RegisterOrPair.FAC1, true)
+                asmgen.jmp(endLabel)
+                asmgen.out(falseLabel)
+                asmgen.assignExpressionToRegister(expr.falsevalue, RegisterOrPair.FAC1, true)
+                asmgen.out(endLabel)
+                asmgen.assignRegister(RegisterOrPair.FAC1, target)
+            }
+            else -> throw AssemblyError("weird dt")
+        }
+    }
+
+    private fun evalIfExpressionConditonAndBranchWhenFalse(condition: PtExpression, falseLabel: String) {
+        when (condition) {
+            is PtBinaryExpression -> {
+                val rightDt = condition.right.type
+                return when {
+                    rightDt.isByteOrBool -> translateIfExpressionByteConditionBranch(condition, falseLabel)
+                    rightDt.isWord -> translateIfExpressionWordConditionBranch(condition, falseLabel)
+                    rightDt.isFloat -> translateIfExpressionFloatConditionBranch(condition, falseLabel)
+                    else -> throw AssemblyError("weird dt")
+                }
+            }
+
+            is PtPrefix if condition.operator=="not" -> {
+                throw AssemblyError("not prefix in ifexpression should have been replaced by swapped values")
+            }
+
+            else -> {
+                // the condition is "simple" enough to just assign its 0/1 value to a register and branch on that
+                asmgen.assignConditionValueToRegisterAndTest(condition)
+                asmgen.out("  beq  $falseLabel")
+            }
+        }
+    }
+
+    private fun translateIfExpressionByteConditionBranch(condition: PtBinaryExpression, falseLabel: String) {
+        val signed = condition.left.type.isSigned
+        val constValue = condition.right.asConstInteger()
+        if(constValue==0) {
+            return translateIfCompareWithZeroByteBranch(condition, signed, falseLabel)
+        }
+
+        when(condition.operator) {
+            "==" -> {
+                // if X==value
+                asmgen.assignExpressionToRegister(condition.left, RegisterOrPair.A, signed)
+                asmgen.cmpAwithByteValue(condition.right, false)
+                asmgen.out("  bne  $falseLabel")
+            }
+            "!=" -> {
+                // if X!=value
+                asmgen.assignExpressionToRegister(condition.left, RegisterOrPair.A, signed)
+                asmgen.cmpAwithByteValue(condition.right, false)
+                asmgen.out("  beq  $falseLabel")
+            }
+            in LogicalOperators -> {
+                val regAtarget = AsmAssignTarget(TargetStorageKind.REGISTER, asmgen, DataType.BOOL, condition.definingISub(), condition.position, register=RegisterOrPair.A)
+                if (assignmentAsmGen.optimizedLogicalExpr(condition, regAtarget)) {
+                    asmgen.out("  beq  $falseLabel")
+                } else {
+                    errors.warn("SLOW FALLBACK FOR 'IFEXPR' CODEGEN - ask for support", condition.position)      //  should not occur ;-)
+                    asmgen.assignConditionValueToRegisterAndTest(condition)
+                    asmgen.out("  beq  $falseLabel")
+                }
+            }
+            else -> {
+                // TODO don't store condition as expression result but just use the flags, like a normal PtIfElse translation does
+                // TODO: special cases for <, <=, >, >= above.
+                asmgen.assignConditionValueToRegisterAndTest(condition)
+                asmgen.out("  beq  $falseLabel")
+            }
+        }
+    }
+
+    private fun translateIfExpressionWordConditionBranch(condition: PtBinaryExpression, falseLabel: String) {
+        // TODO can we reuse this whole thing from IfElse ?
+        val constValue = condition.right.asConstInteger()
+        if(constValue!=null) {
+            if (constValue == 0) {
+                when (condition.operator) {
+                    "==" -> return translateWordExprIsZero(condition.left, falseLabel)
+                    "!=" -> return translateWordExprIsNotZero(condition.left, falseLabel)
+                }
+            }
+            if (constValue != 0) {
+                when (condition.operator) {
+                    "==" -> return translateWordExprEqualsNumber(condition.left, constValue, falseLabel)
+                    "!=" -> return translateWordExprNotEqualsNumber(condition.left, constValue, falseLabel)
+                }
+            }
+        }
+        val variable = condition.right as? PtIdentifier
+        if(variable!=null) {
+            when (condition.operator) {
+                "==" -> return translateWordExprEqualsVariable(condition.left, variable, falseLabel)
+                "!=" -> return translateWordExprNotEqualsVariable(condition.left, variable, falseLabel)
+            }
+        }
+
+        // TODO don't store condition as expression result but just use the flags, like a normal PtIfElse translation does
+        asmgen.assignConditionValueToRegisterAndTest(condition)
+        asmgen.out("  beq  $falseLabel")
+    }
+
+    private fun translateIfExpressionFloatConditionBranch(condition: PtBinaryExpression, elseLabel: String) {
+        val constValue = (condition.right as? PtNumber)?.number
+        if(constValue==0.0) {
+            if (condition.operator == "==") {
+                // if FL==0.0
+                asmgen.assignExpressionToRegister(condition.left, RegisterOrPair.FAC1, true)
+                asmgen.out("  jsr  floats.SIGN |  cmp  #0 |  bne  $elseLabel")
+                return
+            } else if(condition.operator=="!=") {
+                // if FL!=0.0
+                asmgen.assignExpressionToRegister(condition.left, RegisterOrPair.FAC1, true)
+                asmgen.out("  jsr  floats.SIGN |  cmp  #0 |  beq  $elseLabel")
+                return
+            }
+        }
+
+        when(condition.operator) {
+            "==" -> {
+                asmgen.translateFloatsEqualsConditionIntoA(condition.left, condition.right)
+                asmgen.out("  beq  $elseLabel")
+            }
+            "!=" -> {
+                asmgen.translateFloatsEqualsConditionIntoA(condition.left, condition.right)
+                asmgen.out("  bne  $elseLabel")
+            }
+            "<" -> {
+                asmgen.translateFloatsLessConditionIntoA(condition.left, condition.right, false)
+                asmgen.out("  beq  $elseLabel")
+            }
+            "<=" -> {
+                asmgen.translateFloatsLessConditionIntoA(condition.left, condition.right, true)
+                asmgen.out("  beq  $elseLabel")
+            }
+            ">" -> {
+                asmgen.translateFloatsLessConditionIntoA(condition.left, condition.right, true)
+                asmgen.out("  bne  $elseLabel")
+            }
+            ">=" -> {
+                asmgen.translateFloatsLessConditionIntoA(condition.left, condition.right, false)
+                asmgen.out("  bne  $elseLabel")
+            }
+            else -> throw AssemblyError("expected comparison operator")
+        }
+    }
+
+    private fun translateWordExprNotEqualsVariable(expr: PtExpression, variable: PtIdentifier, falseLabel: String) {
+        // if w!=variable
+        // TODO reuse code from ifElse?
+        val varRight = asmgen.asmVariableName(variable)
+        if(expr is PtIdentifier) {
+            val varLeft = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varLeft
+                cmp  $varRight
+                bne  +
+                lda  $varLeft+1
+                cmp  $varRight+1
+                beq  $falseLabel
++""")
+        } else {
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY)
+            asmgen.out("""
+                cmp  $varRight
+                bne  +
+                cpy  $varRight+1
+                beq  $falseLabel
++""")
+        }
+    }
+
+    private fun translateWordExprEqualsVariable(expr: PtExpression, variable: PtIdentifier, falseLabel: String) {
+        // if w==variable
+        // TODO reuse code from ifElse?
+        val varRight = asmgen.asmVariableName(variable)
+        if(expr is PtIdentifier) {
+            val varLeft = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varLeft
+                cmp  $varRight
+                bne  $falseLabel
+                lda  $varLeft+1
+                cmp  $varRight+1
+                bne  $falseLabel""")
+        } else {
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY)
+            asmgen.out("""
+                cmp  $varRight
+                bne  $falseLabel
+                cpy  $varRight+1
+                bne  $falseLabel""")
+        }
+    }
+
+    private fun translateWordExprNotEqualsNumber(expr: PtExpression, number: Int, falseLabel: String) {
+        // if w!=number
+        // TODO reuse code from ifElse?
+        if(expr is PtIdentifier) {
+            val varname = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varname
+                cmp  #<$number
+                bne  +
+                lda  $varname+1
+                cmp  #>$number
+                beq  $falseLabel
++""")
+        } else {
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY)
+            asmgen.out("""
+                cmp  #<$number
+                bne  +
+                cpy  #>$number
+                beq  $falseLabel
++""")
+        }
+    }
+
+    private fun translateWordExprEqualsNumber(expr: PtExpression, number: Int, falseLabel: String) {
+        // if w==number
+        // TODO reuse code from ifElse?
+        if(expr is PtIdentifier) {
+            val varname = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varname
+                cmp  #<$number
+                bne  $falseLabel
+                lda  $varname+1
+                cmp  #>$number
+                bne  $falseLabel""")
+        } else {
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY)
+            asmgen.out(                """
+                cmp  #<$number
+                bne  $falseLabel
+                cpy  #>$number
+                bne  $falseLabel""")
+        }
+    }
+
+    private fun translateWordExprIsNotZero(expr: PtExpression, falseLabel: String) {
+        // if w!=0
+        // TODO reuse code from ifElse?
+        if(expr is PtIdentifier) {
+            val varname = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varname
+                ora  $varname+1
+                beq  $falseLabel""")
+        } else {
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY)
+            asmgen.out("  sty  P8ZP_SCRATCH_REG |  ora  P8ZP_SCRATCH_REG |  beq  $falseLabel")
+        }
+    }
+
+    private fun translateWordExprIsZero(expr: PtExpression, falseLabel: String) {
+        // if w==0
+        // TODO reuse code from ifElse?
+        if(expr is PtIdentifier) {
+            val varname = asmgen.asmVariableName(expr)
+            asmgen.out("""
+                lda  $varname
+                ora  $varname+1
+                bne  $falseLabel""")
+        } else {
+            asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY)
+            asmgen.out("  sty  P8ZP_SCRATCH_REG |  ora  P8ZP_SCRATCH_REG |  bne  $falseLabel")
+        }
+    }
+
+    private fun translateIfCompareWithZeroByteBranch(condition: PtBinaryExpression, signed: Boolean, falseLabel: String) {
+        // optimized code for byte comparisons with 0
+
+        val useBIT = asmgen.checkIfConditionCanUseBIT(condition)
+        if(useBIT!=null) {
+            // use a BIT instruction to test for bit 7 or 6 set/clear
+            val (testForBitSet, variable, bitmask) = useBIT
+            when (bitmask) {
+                128 -> {
+                    // test via bit + N flag
+                    asmgen.out("  bit  ${variable.name}")
+                    if(testForBitSet) asmgen.out("  bpl  $falseLabel")
+                    else asmgen.out("  bmi  $falseLabel")
+                    return
+                }
+                64 -> {
+                    // test via bit + V flag
+                    asmgen.out("  bit  ${variable.name}")
+                    if(testForBitSet) asmgen.out("  bvc  $falseLabel")
+                    else asmgen.out("  bvs  $falseLabel")
+                    return
+                }
+                else -> throw AssemblyError("BIT can only work on bits 7 and 6")
+            }
+        }
+
+        asmgen.assignConditionValueToRegisterAndTest(condition.left)
+        when (condition.operator) {
+            "==" -> asmgen.out("  bne  $falseLabel")
+            "!=" -> asmgen.out("  beq  $falseLabel")
+            ">" -> {
+                if(signed) asmgen.out("  bmi  $falseLabel |  beq  $falseLabel")
+                else asmgen.out("  beq  $falseLabel")
+            }
+            ">=" -> {
+                if(signed) asmgen.out("  bmi  $falseLabel")
+                else { /* always true for unsigned */ }
+            }
+            "<" -> {
+                if(signed) asmgen.out("  bpl  $falseLabel")
+                else asmgen.jmp(falseLabel)
+            }
+            "<=" -> {
+                if(signed) {
+                    // inverted '>'
+                    asmgen.out("""
+                        beq  +
+                        bpl  $falseLabel
++""")
+                } else asmgen.out("  bne  $falseLabel")
+            }
+            else -> throw AssemblyError("expected comparison operator")
+        }
+    }
+
+}