version 8.0

.idea/compiler.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <option name="BUILD_PROCESS_HEAP_SIZE" value="1200" />
+    <option name="BUILD_PROCESS_HEAP_SIZE" value="3000" />
     <bytecodeTargetLevel target="11" />
   </component>
-</project>
+</project>

.idea/libraries/antlr_antlr4.xml

@@ -1,15 +1,15 @@
 <component name="libraryTable">
   <library name="antlr.antlr4" type="repository">
-    <properties maven-id="org.antlr:antlr4:4.9.2">
+    <properties maven-id="org.antlr:antlr4:4.9.3">
       <exclude>
         <dependency maven-id="com.ibm.icu:icu4j" />
       </exclude>
     </properties>
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.9.2/antlr4-4.9.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.9.2/antlr4-runtime-4.9.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.9.3/antlr4-4.9.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.9.3/antlr4-runtime-4.9.3.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr-runtime/3.5.2/antlr-runtime-3.5.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/ST4/4.3/ST4-4.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/ST4/4.3.1/ST4-4.3.1.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/abego/treelayout/org.abego.treelayout.core/1.0.3/org.abego.treelayout.core-1.0.3.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/glassfish/javax.json/1.0.4/javax.json-1.0.4.jar!/" />
     </CLASSES>

.idea/libraries/io_kotest_assertions_core_jvm.xml

@@ -1,20 +1,21 @@
 <component name="libraryTable">
   <library name="io.kotest.assertions.core.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-assertions-core-jvm:4.6.3" />
+    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.1.0" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/4.6.3/kotest-assertions-core-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.5.0/kotlin-stdlib-jdk8-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.5.0/kotlin-stdlib-1.5.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.1.0/kotest-assertions-core-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.10/kotlin-stdlib-jdk8-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.10/kotlin-stdlib-1.6.10.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.5.0/kotlin-stdlib-jdk7-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/4.6.3/kotest-assertions-shared-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.9/java-diff-utils-4.9.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.5.0/kotlinx-coroutines-jdk8-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.5.0/kotlin-reflect-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.5.0/kotlin-stdlib-common-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/4.6.3/kotest-common-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/4.6.3/kotest-assertions-api-jvm-4.6.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.10/kotlin-stdlib-jdk7-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.1.0/kotest-assertions-shared-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.0/kotlinx-coroutines-jdk8-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.10/kotlin-reflect-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.0/kotlinx-coroutines-core-jvm-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.1.0/kotest-common-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.1.0/kotest-assertions-api-jvm-5.1.0.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/io_kotest_property_jvm.xml

@@ -1,22 +1,22 @@
 <component name="libraryTable">
   <library name="io.kotest.property.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-property-jvm:4.6.3" />
+    <properties maven-id="io.kotest:kotest-property-jvm:5.1.0" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-property-jvm/4.6.3/kotest-property-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.5.0/kotlin-stdlib-jdk8-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.5.0/kotlin-stdlib-1.5.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-property-jvm/5.1.0/kotest-property-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.1.0/kotest-common-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.1.0/kotest-assertions-shared-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.1.0/kotest-assertions-api-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.0/kotlinx-coroutines-jdk8-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.10/kotlin-stdlib-jdk8-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.10/kotlin-stdlib-1.6.10.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.5.0/kotlin-stdlib-jdk7-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/4.6.3/kotest-common-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/4.6.3/kotest-assertions-shared-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/4.6.3/kotest-assertions-api-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.5.0/kotlinx-coroutines-jdk8-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.9/java-diff-utils-4.9.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/com/github/mifmif/generex/1.0.2/generex-1.0.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/dk/brics/automaton/automaton/1.11-8/automaton-1.11-8.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.5.0/kotlin-reflect-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.5.0/kotlin-stdlib-common-1.5.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.10/kotlin-stdlib-jdk7-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.10/kotlin-reflect-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.0/kotlinx-coroutines-core-jvm-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/github/curious-odd-man/rgxgen/1.3/rgxgen-1.3.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/io_kotest_runner_junit5_jvm.xml

@@ -1,54 +1,51 @@
 <component name="libraryTable">
   <library name="io.kotest.runner.junit5.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:4.6.3" />
+    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.1.0" />
     <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/4.6.3/kotest-runner-junit5-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/4.6.3/kotest-framework-api-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/4.6.3/kotest-assertions-shared-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.9/java-diff-utils-4.9.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/4.6.3/kotest-common-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/4.6.3/kotest-framework-engine-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.105/classgraph-4.8.105.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.1.0/kotest-runner-junit5-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.1.0/kotest-framework-api-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.6.0/kotlinx-coroutines-test-jvm-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.1.0/kotest-assertions-shared-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.1.0/kotest-common-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.1.0/kotest-framework-engine-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.138/classgraph-4.8.138.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/jetbrains/kotlin/kotlin-script-util/1.5.0/kotlin-script-util-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/intellij/deps/trove4j/1.0.20181211/trove4j-1.0.20181211.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-daemon-client/1.5.0/kotlin-daemon-client-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core/1.3.8/kotlinx-coroutines-core-1.3.8.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-scripting-jvm/1.5.0/kotlin-scripting-jvm-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-scripting-common/1.5.0/kotlin-scripting-common-1.5.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.6.0/kotlinx-coroutines-debug-1.6.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$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/4.6.3/kotest-framework-discovery-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/4.6.3/kotest-assertions-core-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.5.0/kotlinx-coroutines-jdk8-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/4.6.3/kotest-assertions-api-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/4.6.3/kotest-extensions-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/commons-io/commons-io/2.6/commons-io-2.6.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk/1.9.3/mockk-1.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-common/1.9.3/mockk-common-1.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl/1.9.3/mockk-dsl-1.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl-jvm/1.9.3/mockk-dsl-jvm-1.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-jvm/1.9.3/mockk-agent-jvm-1.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-api/1.9.3/mockk-agent-api-1.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-common/1.9.3/mockk-agent-common-1.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/objenesis/objenesis/3.0.1/objenesis-3.0.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.9.10/byte-buddy-1.9.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.9.10/byte-buddy-agent-1.9.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/4.6.3/kotest-framework-concurrency-jvm-4.6.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.5.0/kotlin-stdlib-common-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.6.2/junit-platform-engine-1.6.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.1.0/kotest-framework-discovery-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.1.0/kotest-assertions-core-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.0/kotlinx-coroutines-jdk8-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.1.0/kotest-assertions-api-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.1.0/kotest-extensions-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/commons-io/commons-io/2.11.0/commons-io-2.11.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk/1.12.2/mockk-1.12.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl-jvm/1.12.2/mockk-dsl-jvm-1.12.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl/1.12.2/mockk-dsl-1.12.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-common/1.12.2/mockk-common-1.12.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-jvm/1.12.2/mockk-agent-jvm-1.12.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-api/1.12.2/mockk-agent-api-1.12.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-common/1.12.2/mockk-agent-common-1.12.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/objenesis/objenesis/3.1/objenesis-3.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.12.5/byte-buddy-1.12.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.12.5/byte-buddy-agent-1.12.5.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.1.0/kotest-framework-concurrency-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.0/kotlinx-coroutines-core-jvm-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.7.2/junit-platform-engine-1.7.2.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.0/apiguardian-api-1.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.6.2/junit-platform-commons-1.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-suite-api/1.6.2/junit-platform-suite-api-1.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-launcher/1.6.2/junit-platform-launcher-1.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.6.2/junit-jupiter-api-5.6.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.5.0/kotlin-stdlib-jdk8-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.5.0/kotlin-stdlib-1.5.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.7.2/junit-platform-commons-1.7.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-suite-api/1.7.2/junit-platform-suite-api-1.7.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-launcher/1.7.2/junit-platform-launcher-1.7.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.7.2/junit-jupiter-api-5.7.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.10/kotlin-stdlib-jdk8-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.10/kotlin-stdlib-1.6.10.jar!/" />
       <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.5.0/kotlin-stdlib-jdk7-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-script-runtime/1.5.0/kotlin-script-runtime-1.5.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.5.0/kotlin-reflect-1.5.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.10/kotlin-stdlib-jdk7-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.10/kotlin-reflect-1.6.10.jar!/" />
     </CLASSES>
     <JAVADOC />
     <SOURCES />

.idea/libraries/jetbrains_kotlinx_cli_jvm.xml

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

.idea/libraries/michael_bull_kotlin_result_jvm.xml

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

.idea/libraries/slf4j_simple.xml

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

.idea/modules.xml

@@ -2,18 +2,20 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
+      <module fileurl="file://$PROJECT_DIR$/codeAst/codeAst.iml" filepath="$PROJECT_DIR$/codeAst/codeAst.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$/codeGenExperimental6502/codeGenExperimental6502.iml" filepath="$PROJECT_DIR$/codeGenExperimental6502/codeGenExperimental6502.iml" />
-      <module fileurl="file://$PROJECT_DIR$/codeGenTargets/codeGenTargets.iml" filepath="$PROJECT_DIR$/codeGenTargets/codeGenTargets.iml" />
+      <module fileurl="file://$PROJECT_DIR$/codeGenExperimental/codeGenExperimental.iml" filepath="$PROJECT_DIR$/codeGenExperimental/codeGenExperimental.iml" />
+      <module fileurl="file://$PROJECT_DIR$/codeGenVirtual/codeGenVirtual.iml" filepath="$PROJECT_DIR$/codeGenVirtual/codeGenVirtual.iml" />
       <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$/compilerInterfaces/compilerInterfaces.iml" filepath="$PROJECT_DIR$/compilerInterfaces/compilerInterfaces.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$/parser/parser.iml" filepath="$PROJECT_DIR$/parser/parser.iml" />
+      <module fileurl="file://$PROJECT_DIR$/virtualmachine/virtualmachine.iml" filepath="$PROJECT_DIR$/virtualmachine/virtualmachine.iml" />
     </modules>
   </component>
 </project>

.idea/vcs.xml

@@ -3,4 +3,4 @@
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
   </component>
-</project>
+</project>

codeAst/build.gradle

@@ -0,0 +1,42 @@
+
+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 {
+    implementation project(':codeCore')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+}
+
+sourceSets {
+    main {
+        java {
+            srcDirs = ["${project.projectDir}/src"]
+        }
+        resources {
+            srcDirs = ["${project.projectDir}/res"]
+        }
+    }
+}
+
+// note: there are no unit tests in this module!

codeAst/codeAst.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+    <orderEntry type="module" module-name="codeCore" />
+  </component>
+</module>

codeAst/src/prog8/code/SymbolTable.kt

@@ -0,0 +1,217 @@
+package prog8.code
+
+import prog8.code.core.*
+
+
+/**
+ * Tree structure containing all symbol definitions in the program
+ * (blocks, subroutines, variables (all types) and labels).
+ */
+class SymbolTable : StNode("", StNodeType.GLOBAL, Position.DUMMY) {
+    fun print() = printIndented(0)
+
+    override fun printProperties() { }
+
+    /**
+     * The table as a flat mapping of scoped names to the StNode.
+     * This gives the fastest lookup possible (no need to traverse tree nodes)
+     */
+    val flat: Map<List<String>, StNode> by lazy {
+        val result = mutableMapOf<List<String>, StNode>()
+        fun flatten(node: StNode) {
+            result[node.scopedName] = node
+            node.children.values.forEach { flatten(it) }
+        }
+        children.values.forEach { flatten(it) }
+        result
+    }
+
+    val allVariables: Collection<StStaticVariable> by lazy {
+        val vars = mutableListOf<StStaticVariable>()
+        fun collect(node: StNode) {
+            for(child in node.children) {
+                if(child.value.type== StNodeType.STATICVAR)
+                    vars.add(child.value as StStaticVariable)
+                else
+                    collect(child.value)
+            }
+        }
+        collect(this)
+        vars
+    }
+
+    override fun lookup(scopedName: List<String>) = flat[scopedName]
+}
+
+
+enum class StNodeType {
+    GLOBAL,
+    // MODULE,     // not used with current scoping rules
+    BLOCK,
+    SUBROUTINE,
+    ROMSUB,
+    LABEL,
+    STATICVAR,
+    MEMVAR,
+    CONSTANT,
+    BUILTINFUNC
+}
+
+
+open class StNode(val name: String,
+                  val type: StNodeType,
+                  val position: Position,
+                  val children: MutableMap<String, StNode> = mutableMapOf()
+) {
+
+    lateinit var parent: StNode
+
+    val scopedName: List<String> by lazy {
+        if(type== StNodeType.GLOBAL)
+            emptyList()
+        else
+            parent.scopedName + name
+    }
+
+    fun lookup(name: String) =
+        lookupUnqualified(name)
+    open fun lookup(scopedName: List<String>) =
+        if(scopedName.size>1) lookupQualified(scopedName) else lookupUnqualified(scopedName[0])
+    fun lookupOrElse(name: String, default: () -> StNode) =
+        lookupUnqualified(name) ?: default()
+    fun lookupOrElse(scopedName: List<String>, default: () -> StNode) =
+        lookup(scopedName) ?: default()
+
+    private fun lookupQualified(scopedName: List<String>): StNode? {
+        // a scoped name refers to a name in another namespace, and always stars from the root.
+        var node = this
+        while(node.type!= StNodeType.GLOBAL)
+            node = node.parent
+
+        for(name in scopedName) {
+            if(name in node.children)
+                node = node.children.getValue(name)
+            else
+                return null
+        }
+        return node
+    }
+
+    private fun lookupUnqualified(name: String): StNode? {
+        // first consider the builtin functions
+        var globalscope = this
+        while(globalscope.type!= StNodeType.GLOBAL)
+            globalscope = globalscope.parent
+        val globalNode = globalscope.children[name]
+        if(globalNode!=null && globalNode.type== StNodeType.BUILTINFUNC)
+            return globalNode
+
+        // search for the unqualified name in the current scope or its parent scopes
+        var scope=this
+        while(true) {
+            val node = scope.children[name]
+            if(node!=null)
+                return node
+            if(scope.type== StNodeType.GLOBAL)
+                return null
+            else
+                scope = scope.parent
+        }
+    }
+
+    fun printIndented(indent: Int) {
+        print("    ".repeat(indent))
+        when(type) {
+            StNodeType.GLOBAL -> print("SYMBOL-TABLE:")
+            StNodeType.BLOCK -> print("(B) ")
+            StNodeType.SUBROUTINE -> print("(S) ")
+            StNodeType.LABEL -> print("(L) ")
+            StNodeType.STATICVAR -> print("(V) ")
+            StNodeType.MEMVAR -> print("(M) ")
+            StNodeType.CONSTANT -> print("(C) ")
+            StNodeType.BUILTINFUNC -> print("(F) ")
+            StNodeType.ROMSUB -> print("(R) ")
+        }
+        printProperties()
+        println()
+        children.forEach { (_, node) -> node.printIndented(indent+1) }
+    }
+
+    open fun printProperties() {
+        print("$name  ")
+    }
+
+    fun add(child: StNode) {
+        children[child.name] = child
+        child.parent = this
+    }
+}
+
+class StStaticVariable(name: String,
+                       val dt: DataType,
+                       val initialNumericValue: Double?,
+                       val initialStringValue: StString?,
+                       val initialArrayValue: StArray?,
+                       val length: Int?,             // for arrays: the number of elements, for strings: number of characters *including* the terminating 0-byte
+                       val zpwish: ZeropageWish,
+                       position: Position) : StNode(name, StNodeType.STATICVAR, position) {
+
+    init {
+        if(length!=null) {
+            require(initialNumericValue == null)
+            if(initialArrayValue!=null)
+                require(length == initialArrayValue.size)
+        }
+        if(initialNumericValue!=null)
+            require(dt in NumericDatatypes)
+        if(initialArrayValue!=null)
+            require(dt in ArrayDatatypes)
+        if(initialStringValue!=null) {
+            require(dt == DataType.STR)
+            require(length == initialStringValue.first.length+1)
+        }
+    }
+
+    override fun printProperties() {
+        print("$name  dt=$dt  zpw=$zpwish")
+    }
+}
+
+
+class StConstant(name: String, val dt: DataType, val value: Double, position: Position) :
+    StNode(name, StNodeType.CONSTANT, position) {
+    override fun printProperties() {
+        print("$name  dt=$dt value=$value")
+    }
+}
+
+
+class StMemVar(name: String, val dt: DataType, val address: UInt, position: Position) :
+    StNode(name, StNodeType.MEMVAR, position) {
+    override fun printProperties() {
+        print("$name  dt=$dt address=${address.toHex()}")
+    }
+}
+
+
+class StSub(name: String, val parameters: List<StSubroutineParameter>, position: Position) :
+        StNode(name, StNodeType.SUBROUTINE, position) {
+    override fun printProperties() {
+        print(name)
+    }
+}
+
+
+class StRomSub(name: String, val address: UInt, parameters: List<StSubroutineParameter>, position: Position) :
+    StNode(name, StNodeType.ROMSUB, position) {
+    override fun printProperties() {
+        print("$name  address=${address.toHex()}")
+    }
+}
+
+
+class StSubroutineParameter(val name: String, val type: DataType)
+class StArrayElement(val number: Double?, val addressOf: List<String>?)
+
+typealias StString = Pair<String, Encoding>
+typealias StArray = List<StArrayElement>

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

@@ -0,0 +1,118 @@
+package prog8.code.ast
+
+import prog8.code.core.*
+import java.nio.file.Path
+
+// New (work-in-progress) simplified AST for the code generator.
+
+
+sealed class PtNode(val position: Position) {
+
+    val children = mutableListOf<PtNode>()
+    lateinit var parent: PtNode
+
+    fun printIndented(indent: Int) {
+        print("    ".repeat(indent))
+        print("${this.javaClass.simpleName}  ")
+        printProperties()
+        println()
+        children.forEach { it.printIndented(indent+1) }
+    }
+
+    abstract fun printProperties()
+
+    fun add(child: PtNode) {
+        children.add(child)
+        child.parent = this
+    }
+
+    fun add(index: Int, child: PtNode) {
+        children.add(index, child)
+        child.parent = this
+    }
+}
+
+
+class PtNodeGroup : PtNode(Position.DUMMY) {
+    override fun printProperties() {}
+}
+
+
+abstract class PtNamedNode(val name: String, position: Position): PtNode(position) {
+    val scopedName: List<String> by lazy {
+        var namedParent: PtNode = this.parent
+        if(namedParent is PtProgram)
+            listOf(name)
+        else {
+            while (namedParent !is PtNamedNode)
+                namedParent = namedParent.parent
+            namedParent.scopedName + name
+        }
+    }
+}
+
+
+class PtProgram(
+    val name: String,
+    val memsizer: IMemSizer,
+    val encoding: IStringEncoding
+) : PtNode(Position.DUMMY) {
+    fun print() = printIndented(0)
+    override fun printProperties() {
+        print("'$name'")
+    }
+
+//    fun allModuleDirectives(): Sequence<PtDirective> =
+//        children.asSequence().flatMap { it.children }.filterIsInstance<PtDirective>().distinct()
+
+    fun allBlocks(): Sequence<PtBlock> =
+        children.asSequence().filterIsInstance<PtBlock>()
+
+    fun entrypoint(): PtSub? =
+        allBlocks().firstOrNull { it.name == "main" }?.children?.firstOrNull { it is PtSub && it.name == "start" } as PtSub?
+}
+
+
+class PtBlock(name: String,
+              val address: UInt?,
+              val library: Boolean,
+              position: Position
+) : PtNamedNode(name, position) {
+    override fun printProperties() {
+        print("$name  addr=$address  library=$library")
+    }
+}
+
+
+class PtInlineAssembly(val assembly: String, position: Position) : PtNode(position) {
+    override fun printProperties() {}
+}
+
+
+class PtLabel(name: String, position: Position) : PtNamedNode(name, position) {
+    override fun printProperties() {
+        print(name)
+    }
+}
+
+
+class PtBreakpoint(position: Position): PtNode(position) {
+    override fun printProperties() {}
+}
+
+
+class PtIncludeBinary(val file: Path, val offset: UInt?, val length: UInt?, position: Position) : PtNode(position) {
+    override fun printProperties() {
+        print("filename=$file  offset=$offset  length=$length")
+    }
+}
+
+
+class PtNop(position: Position): PtNode(position) {
+    override fun printProperties() {}
+}
+
+
+class PtScopeVarsDecls(position: Position): PtNode(position) {
+    override fun printProperties() {}
+}

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

@@ -0,0 +1,146 @@
+package prog8.code.ast
+
+import prog8.code.core.DataType
+import prog8.code.core.Encoding
+import prog8.code.core.Position
+
+
+sealed class PtExpression(val type: DataType, position: Position) : PtNode(position) {
+    override fun printProperties() {
+        print(type)
+    }
+}
+
+
+class PtAddressOf(position: Position) : PtExpression(DataType.UWORD, position) {
+    val identifier: PtIdentifier
+        get() = children.single() as PtIdentifier
+}
+
+
+class PtArrayIndexer(type: DataType, position: Position): PtExpression(type, position) {
+    val variable: PtIdentifier
+        get() = children[0] as PtIdentifier
+    val index: PtExpression
+        get() = children[1] as PtExpression
+}
+
+
+class PtArray(type: DataType, position: Position): PtExpression(type, position)
+
+
+class PtBuiltinFunctionCall(val name: String, val void: Boolean, type: DataType, position: Position) : PtExpression(type, position) {
+    init {
+        if(!void)
+            require(type!=DataType.UNDEFINED)
+    }
+
+    val args: List<PtExpression>
+        get() = children.map { it as PtExpression }
+    override fun printProperties() {
+        print("$name void=$void")
+    }
+}
+
+
+class PtBinaryExpression(val operator: String, type: DataType, position: Position): PtExpression(type, position) {
+    val left: PtExpression
+        get() = children[0] as PtExpression
+    val right: PtExpression
+        get() = children[1] as PtExpression
+
+    override fun printProperties() {
+        print("$operator -> $type")
+    }
+}
+
+
+class PtContainmentCheck(position: Position): PtExpression(DataType.UBYTE, position) {
+    val element: PtExpression
+        get() = children[0] as PtExpression
+    val iterable: PtIdentifier
+        get() = children[1] as PtIdentifier
+}
+
+
+class PtFunctionCall(val functionName: List<String>,
+                     val void: Boolean,
+                     type: DataType,
+                     position: Position) : PtExpression(type, position) {
+    init {
+        if(!void)
+            require(type!=DataType.UNDEFINED)
+    }
+
+    val args: List<PtExpression>
+        get() = children.map { it as PtExpression }
+    override fun printProperties() {
+        print("${functionName.joinToString(".")} void=$void")
+    }
+}
+
+
+class PtIdentifier(val ref: List<String>, val targetName: List<String>, type: DataType, position: Position) : PtExpression(type, position) {
+    override fun printProperties() {
+        print("$ref --> $targetName  $type")
+    }
+}
+
+
+class PtMemoryByte(position: Position) : PtExpression(DataType.UBYTE, position) {
+    val address: PtExpression
+        get() = children.single() as PtExpression
+    override fun printProperties() {}
+}
+
+
+class PtNumber(type: DataType, val number: Double, position: Position) : PtExpression(type, position) {
+    override fun printProperties() {
+        print("$number ($type)")
+    }
+}
+
+
+class PtPipe(type: DataType, val void: Boolean, position: Position) : PtExpression(type, position) {
+    init {
+        if(!void)
+            require(type!=DataType.UNDEFINED)
+    }
+
+    override fun printProperties() {}
+}
+
+
+class PtPrefix(val operator: String, type: DataType, position: Position): PtExpression(type, position) {
+    val value: PtExpression
+        get() = children.single() as PtExpression
+
+    override fun printProperties() {
+        print(operator)
+    }
+}
+
+
+class PtRange(type: DataType, position: Position) : PtExpression(type, position) {
+    val from: PtExpression
+        get() = children[0] as PtExpression
+    val to: PtExpression
+        get() = children[1] as PtExpression
+    val step: PtNumber
+        get() = children[2] as PtNumber
+
+    override fun printProperties() {}
+}
+
+
+class PtString(val value: String, val encoding: Encoding, position: Position) : PtExpression(DataType.STR, position) {
+    override fun printProperties() {
+        print("$encoding:\"$value\"")
+    }
+}
+
+
+class PtTypeCast(type: DataType, position: Position) : PtExpression(type, position) {
+    val value: PtExpression
+        get() = children.single() as PtExpression
+}

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

@@ -0,0 +1,194 @@
+package prog8.code.ast
+
+import prog8.code.core.*
+
+
+class PtAsmSub(
+    name: String,
+    val address: UInt?,
+    val clobbers: Set<CpuRegister>,
+    val parameters: List<Pair<PtSubroutineParameter, RegisterOrStatusflag>>,
+    val retvalRegisters: List<RegisterOrStatusflag>,
+    val inline: Boolean,
+    position: Position
+) : PtNamedNode(name, position) {
+    override fun printProperties() {
+        print("$name  inline=$inline")
+    }
+}
+
+
+class PtSub(
+    name: String,
+    val parameters: List<PtSubroutineParameter>,
+    val returntype: DataType?,
+    val inline: Boolean,
+    position: Position
+) : PtNamedNode(name, position) {
+    override fun printProperties() {
+        print(name)
+    }
+}
+
+
+class PtSubroutineParameter(val name: String, val type: DataType, position: Position): PtNode(position) {
+    override fun printProperties() {
+        print("$type $name")
+    }
+}
+
+
+class PtAssignment(val augmentable: Boolean, position: Position) : PtNode(position) {
+    val target: PtAssignTarget
+        get() = children[0] as PtAssignTarget
+    val value: PtExpression
+        get() = children[1] as PtExpression
+
+    override fun printProperties() {
+        print("aug=$augmentable")
+    }
+}
+
+
+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       // TODO array to elt type?
+                is PtMemoryByte -> tgt.type
+                else -> throw AssemblyError("weird dt")
+            }
+        }
+
+    override fun printProperties() {}
+}
+
+
+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
+
+    override fun printProperties() {
+        print(condition)
+    }
+}
+
+
+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
+
+    override fun printProperties() {}
+}
+
+
+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
+
+    override fun printProperties() {}
+}
+
+
+class PtJump(val identifier: PtIdentifier?,
+             val address: UInt?,
+             val generatedLabel: String?,
+             position: Position) : PtNode(position) {
+    override fun printProperties() {
+        identifier?.printProperties()
+        if(address!=null) print(address.toHex())
+        if(generatedLabel!=null) print(generatedLabel)
+    }
+}
+
+
+class PtPostIncrDecr(val operator: String, position: Position) : PtNode(position) {
+    val target: PtAssignTarget
+        get() = children.single() as PtAssignTarget
+
+    override fun printProperties() {
+        print(operator)
+    }
+}
+
+
+class PtRepeatLoop(position: Position) : PtNode(position) {
+    val count: PtExpression
+        get() = children[0] as PtExpression
+    val statements: PtNodeGroup
+        get() = children[1] as PtNodeGroup
+
+    override fun printProperties() {}
+}
+
+
+class PtReturn(position: Position) : PtNode(position) {
+    val hasValue = children.any()
+    val value: PtExpression?
+        get() {
+            return if(children.any())
+                children.single() as PtExpression
+            else
+                null
+        }
+
+    override fun printProperties() {}
+}
+
+
+class PtVariable(name: String, val type: DataType, var value: PtExpression?, var arraySize: UInt?, position: Position) : PtNamedNode(name, position) {
+    override fun printProperties() {
+        print("$type  $name")
+    }
+}
+
+
+class PtConstant(name: String, val type: DataType, val value: Double, position: Position) : PtNamedNode(name, position) {
+    override fun printProperties() {
+        print("$type $name = $value")
+    }
+}
+
+
+class PtMemMapped(name: String, val type: DataType, val address: UInt, position: Position) : PtNamedNode(name, position) {
+    override fun printProperties() {
+        print("&$type $name = ${address.toHex()}")
+    }
+}
+
+
+class PtWhen(position: Position) : PtNode(position) {
+    val value: PtExpression
+        get() = children[0] as PtExpression
+    val choices: PtNodeGroup
+        get() = children[1] as PtNodeGroup
+
+    override fun printProperties() {}
+}
+
+
+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
+    override fun printProperties() {}
+}

codeCore/build.gradle

@@ -24,12 +24,9 @@ compileTestKotlin {
 }
 
 dependencies {
-    implementation project(':compilerInterfaces')
-    implementation project(':compilerAst')
+    implementation project(':virtualmachine')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.12"
-
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
 }
 
 sourceSets {

codeCore/codeCore.iml

@@ -10,7 +10,6 @@
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
     <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
-    <orderEntry type="module" module-name="compilerInterfaces" />
-    <orderEntry type="module" module-name="compilerAst" />
+    <orderEntry type="module" module-name="virtualmachine" />
   </component>
 </module>

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

@@ -1,26 +1,8 @@
-package prog8.compilerinterface
+package prog8.code.core
 
 import java.nio.file.Path
 import kotlin.io.path.Path
 
-enum class OutputType {
-    RAW,
-    PRG,
-    XEX
-}
-
-enum class CbmPrgLauncherType {
-    BASIC,
-    NONE
-}
-
-enum class ZeropageType {
-    BASICSAFE,
-    FLOATSAFE,
-    KERNALSAFE,
-    FULL,
-    DONTUSE
-}
 
 class CompilationOptions(val output: OutputType,
                          val launcher: CbmPrgLauncherType,
@@ -29,7 +11,8 @@ class CompilationOptions(val output: OutputType,
                          val floats: Boolean,
                          val noSysInit: Boolean,
                          val compTarget: ICompilationTarget,
-                         // these are set based on command line arguments:
+                         // these are set later, based on command line arguments or options in the source code:
+                         var loadAddress: UInt,
                          var slowCodegenWarnings: Boolean = false,
                          var optimize: Boolean = false,
                          var optimizeFloatExpressions: Boolean = false,

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

@@ -0,0 +1,181 @@
+package prog8.code.core
+
+enum class DataType {
+    UBYTE,              // pass by value
+    BYTE,               // pass by value
+    UWORD,              // pass by value
+    WORD,               // pass by value
+    FLOAT,              // pass by value
+    STR,                // pass by reference
+    ARRAY_UB,           // pass by reference
+    ARRAY_B,            // pass by reference
+    ARRAY_UW,           // pass by reference
+    ARRAY_W,            // pass by reference
+    ARRAY_F,            // pass by reference
+    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) {
+            UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT)
+            BYTE -> targetType.oneOf(BYTE, WORD, FLOAT)
+            UWORD -> targetType.oneOf(UWORD, FLOAT)
+            WORD -> targetType.oneOf(WORD, FLOAT)
+            FLOAT -> targetType == 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) =
+        when {
+            this == other -> false
+            this in ByteDatatypes -> false
+            this in WordDatatypes -> other in ByteDatatypes
+            this== STR && other== UWORD || this== UWORD && other== STR -> false
+            else -> true
+        }
+
+    infix fun equalsSize(other: DataType) =
+        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
+            else -> false
+        }
+}
+
+enum class CpuRegister {
+    A,
+    X,
+    Y;
+
+    fun asRegisterOrPair(): RegisterOrPair = when(this) {
+        A -> RegisterOrPair.A
+        X -> RegisterOrPair.X
+        Y -> RegisterOrPair.Y
+    }
+}
+
+enum class RegisterOrPair {
+    A,
+    X,
+    Y,
+    AX,
+    AY,
+    XY,
+    FAC1,
+    FAC2,
+    // cx16 virtual registers:
+    R0, R1, R2, R3, R4, R5, R6, R7,
+    R8, R9, R10, R11, R12, R13, R14, R15;
+
+    companion object {
+        val names by lazy { values().map { it.toString()} }
+    }
+
+    fun asCpuRegister(): CpuRegister = when(this) {
+        A -> CpuRegister.A
+        X -> CpuRegister.X
+        Y -> CpuRegister.Y
+        else -> throw IllegalArgumentException("no cpu hardware register for $this")
+    }
+
+}       // only used in parameter and return value specs in asm subroutines
+
+enum class Statusflag {
+    Pc,
+    Pz,     // don't use
+    Pv,
+    Pn;     // don't use
+
+    companion object {
+        val names by lazy { values().map { it.toString()} }
+    }
+}
+
+enum class BranchCondition {
+    CS,
+    CC,
+    EQ,
+    Z,
+    NE,
+    NZ,
+    VS,
+    VC,
+    MI,
+    NEG,
+    PL,
+    POS
+}
+
+
+val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE)
+val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD)
+val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
+val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
+val SignedDatatypes =  arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT)
+val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
+val StringlyDatatypes = arrayOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD)
+val IterableDatatypes = arrayOf(
+    DataType.STR,
+    DataType.ARRAY_UB, DataType.ARRAY_B,
+    DataType.ARRAY_UW, DataType.ARRAY_W,
+    DataType.ARRAY_F
+)
+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_F to DataType.FLOAT
+)
+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
+)
+val Cx16VirtualRegisters = arrayOf(
+    RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3,
+    RegisterOrPair.R4, RegisterOrPair.R5, RegisterOrPair.R6, RegisterOrPair.R7,
+    RegisterOrPair.R8, RegisterOrPair.R9, RegisterOrPair.R10, RegisterOrPair.R11,
+    RegisterOrPair.R12, RegisterOrPair.R13, RegisterOrPair.R14, RegisterOrPair.R15
+)
+
+
+
+enum class OutputType {
+    RAW,
+    PRG,
+    XEX
+}
+
+enum class CbmPrgLauncherType {
+    BASIC,
+    NONE
+}
+
+enum class ZeropageType {
+    BASICSAFE,
+    FLOATSAFE,
+    KERNALSAFE,
+    FULL,
+    DONTUSE
+}
+
+enum class ZeropageWish {
+    REQUIRE_ZEROPAGE,
+    PREFER_ZEROPAGE,
+    DONTCARE,
+    NOT_IN_ZEROPAGE
+}

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

@@ -1,7 +1,7 @@
-package prog8.compilerinterface
+package prog8.code.core
 
 class InternalCompilerException(message: String?) : Exception(message)
 
-class AbortCompilation(message: String?) : Exception(message)
-
 class AssemblyError(msg: String) : RuntimeException(msg)
+
+class ErrorsReportedException(message: String?) : Exception(message)

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

@@ -1,5 +1,4 @@
-package prog8.compilerinterface
-
+package prog8.code.core
 
 interface IAssemblyGenerator {
     fun compileToAssembly(): IAssemblyProgram?

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

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

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

@@ -1,7 +1,4 @@
-package prog8.compilerinterface
-
-import prog8.ast.base.Position
-
+package prog8.code.core
 
 interface IErrorReporter {
     fun err(msg: String, position: Position)
@@ -10,7 +7,6 @@ interface IErrorReporter {
     fun report()
     fun finalizeNumErrors(numErrors: Int, numWarnings: Int) {
         if(numErrors>0)
-            throw AbortCompilation("There are $numErrors errors and $numWarnings warnings.")
+            throw ErrorsReportedException("There are $numErrors errors and $numWarnings warnings.")
     }
 }
-

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

@@ -1,4 +1,4 @@
-package prog8.compilerinterface
+package prog8.code.core
 
 import java.nio.file.Path
 
@@ -10,7 +10,8 @@ interface IMachineFloat {
 
 enum class CpuType {
     CPU6502,
-    CPU65c02
+    CPU65c02,
+    VIRTUAL
 }
 
 interface IMachineDefinition {

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

@@ -0,0 +1,6 @@
+package prog8.code.core
+
+interface IMemSizer {
+    fun memorySize(dt: DataType): Int
+    fun memorySize(arrayDt: DataType, numElements: Int): Int
+}

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

@@ -1,4 +1,4 @@
-package prog8.compilerinterface
+package prog8.code.core
 
 enum class Encoding(val prefix: String) {
     DEFAULT("default"),         // depends on compilation target

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

@@ -0,0 +1,16 @@
+package prog8.code.core
+
+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 {
+        val path = Path(file).absolute().normalize()
+        return "file://$path:$line:$startCol:"
+    }
+
+    companion object {
+        val DUMMY = Position("<dummy>", 0, 0, 0)
+    }
+}

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

@@ -0,0 +1,3 @@
+package prog8.code.core
+
+data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?)

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

@@ -1,4 +1,4 @@
-package prog8.parser
+package prog8.code.core
 
 import java.io.File
 import java.io.IOException
@@ -6,6 +6,10 @@ import java.nio.file.Path
 import kotlin.io.path.Path
 import kotlin.io.path.readText
 
+
+const val internedStringsModuleName = "prog8_interned_strings"
+
+
 /**
  * Encapsulates - and ties together - actual source code (=text) and its [origin].
  */

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

@@ -0,0 +1,31 @@
+package prog8.code.core
+
+import kotlin.math.abs
+
+fun Number.toHex(): String {
+    //  0..15 -> "0".."15"
+    //  16..255 -> "$10".."$ff"
+    //  256..65536 -> "$0100".."$ffff"
+    // negative values are prefixed with '-'.
+    val integer = this.toInt()
+    if(integer<0)
+        return '-' + abs(integer).toHex()
+    return when (integer) {
+        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")
+    }
+}
+
+fun UInt.toHex(): String {
+    //  0..15 -> "0".."15"
+    //  16..255 -> "$10".."$ff"
+    //  256..65536 -> "$0100".."$ffff"
+    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")
+    }
+}

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

@@ -1,13 +1,8 @@
-package prog8.compilerinterface
+package prog8.code.core
 
 import com.github.michaelbull.result.Err
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
-import prog8.ast.INameScope
-import prog8.ast.base.*
-import prog8.ast.expressions.ArrayLiteral
-import prog8.ast.expressions.Expression
-import prog8.ast.expressions.StringLiteral
 
 
 class ZeropageAllocationError(message: String) : Exception(message)
@@ -20,12 +15,7 @@ abstract class Zeropage(protected val options: CompilationOptions) {
     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
 
-    data class ZpAllocation(val address: UInt,
-                            val dt: DataType,
-                            val size: Int,
-                            val originalScope: INameScope,
-                            val initialStringValue: StringLiteral?,
-                            val initialArrayValue: ArrayLiteral?)
+    data class ZpAllocation(val address: UInt, val dt: DataType, val size: Int)
 
     // the variables allocated into Zeropage.
     // name (scoped) ==> pair of address to (Datatype + bytesize)
@@ -53,11 +43,10 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
     fun allocate(name: List<String>,
                  datatype: DataType,
-                 originalScope: INameScope,
                  numElements: Int?,
-                 initValue: Expression?,
                  position: Position?,
-                 errors: IErrorReporter): Result<Pair<UInt, Int>, ZeropageAllocationError> {
+                 errors: IErrorReporter
+    ): Result<Pair<UInt, Int>, ZeropageAllocationError> {
 
         require(name.isEmpty() || name !in allocatedVariables) {"name can't be allocated twice"}
 
@@ -68,7 +57,7 @@ abstract class Zeropage(protected val options: CompilationOptions) {
                 when (datatype) {
                     in IntegerDatatypes -> options.compTarget.memorySize(datatype)
                     DataType.STR, in ArrayDatatypes  -> {
-                        val memsize = numElements!! * options.compTarget.memorySize(ArrayToElementTypes.getValue(datatype))
+                        val memsize = options.compTarget.memorySize(datatype, numElements!!)
                         if(position!=null)
                             errors.warn("allocating a large value in zeropage; str/array $memsize bytes", position)
                         else
@@ -93,13 +82,13 @@ abstract class Zeropage(protected val options: CompilationOptions) {
                 if(size==1) {
                     for(candidate in free.minOrNull()!! .. free.maxOrNull()!!+1u) {
                         if(oneSeparateByteFree(candidate))
-                            return Ok(Pair(makeAllocation(candidate, 1, datatype, name, initValue, originalScope), 1))
+                            return Ok(Pair(makeAllocation(candidate, 1, datatype, name), 1))
                     }
-                    return Ok(Pair(makeAllocation(free[0], 1, datatype, name, initValue, originalScope), 1))
+                    return Ok(Pair(makeAllocation(free[0], 1, datatype, name), 1))
                 }
                 for(candidate in free.minOrNull()!! .. free.maxOrNull()!!+1u) {
                     if (sequentialFree(candidate, size))
-                        return Ok(Pair(makeAllocation(candidate, size, datatype, name, initValue, originalScope), size))
+                        return Ok(Pair(makeAllocation(candidate, size, datatype, name), size))
                 }
             }
         }
@@ -109,14 +98,14 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
     private fun reserve(range: UIntRange) = free.removeAll(range)
 
-    private fun makeAllocation(address: UInt, size: Int, datatype: DataType, name: List<String>, initValue: Expression?, originalScope: INameScope): UInt {
+    private fun makeAllocation(address: UInt, size: Int, datatype: DataType, name: List<String>): UInt {
         require(size>=0)
         free.removeAll(address until address+size.toUInt())
         if(name.isNotEmpty()) {
             allocatedVariables[name] = when(datatype) {
-                in NumericDatatypes -> ZpAllocation(address, datatype, size, originalScope, null, null)        // numerical variables in zeropage never have an initial value here because they are set in separate initializer assignments
-                DataType.STR -> ZpAllocation(address, datatype, size, originalScope, initValue as? StringLiteral, null)
-                in ArrayDatatypes -> ZpAllocation(address, datatype, size, originalScope, null, initValue as? ArrayLiteral)
+                in NumericDatatypes -> ZpAllocation(address, datatype, size)        // numerical variables in zeropage never have an initial value here because they are set in separate initializer assignments
+                DataType.STR -> ZpAllocation(address, datatype, size)
+                in ArrayDatatypes -> ZpAllocation(address, datatype, size)
                 else -> throw AssemblyError("invalid dt")
             }
         }

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

@@ -0,0 +1,28 @@
+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 supportedEncodings = setOf(Encoding.ATASCII)
+    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 -> Int.MIN_VALUE
+        }
+    }
+
+    override fun memorySize(arrayDt: DataType, numElements: Int) =
+        memorySize(ArrayToElementTypes.getValue(arrayDt)) * numElements
+}

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

@@ -0,0 +1,20 @@
+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
+
+
+class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+    override val name = NAME
+    override val machine = C128MachineDefinition()
+    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES)
+    override val defaultEncoding = Encoding.PETSCII
+
+    companion object {
+        const val NAME = "c128"
+    }
+}

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

@@ -0,0 +1,20 @@
+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
+
+
+class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+    override val name = NAME
+    override val machine = C64MachineDefinition()
+    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES)
+    override val defaultEncoding = Encoding.PETSCII
+
+    companion object {
+        const val NAME = "c64"
+    }
+}

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

@@ -0,0 +1,20 @@
+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
+
+
+class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
+    override val name = NAME
+    override val machine = CX16MachineDefinition()
+    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES, Encoding.ISO)
+    override val defaultEncoding = Encoding.PETSCII
+
+    companion object {
+        const val NAME = "cx16"
+    }
+}

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

@@ -1,14 +1,15 @@
-package prog8.codegen.target
+package prog8.code.target
 
 import com.github.michaelbull.result.fold
-import prog8.codegen.target.cbm.AtasciiEncoding
-import prog8.codegen.target.cbm.IsoEncoding
-import prog8.codegen.target.cbm.PetsciiEncoding
-import prog8.compilerinterface.Encoding
-import prog8.compilerinterface.IStringEncoding
-import prog8.compilerinterface.InternalCompilerException
+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
 
-internal object Encoder: IStringEncoding {
+
+object Encoder: IStringEncoding {
     override fun encodeString(str: String, encoding: Encoding): List<UByte> {
         val coded = when(encoding) {
             Encoding.PETSCII -> PetsciiEncoding.encodePetscii(str, true)

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

@@ -0,0 +1,27 @@
+package prog8.code.target
+
+import prog8.code.core.*
+import prog8.code.target.virtual.VirtualMachineDefinition
+
+class VMTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
+    override val name = NAME
+    override val machine = VirtualMachineDefinition()
+    override val supportedEncodings = setOf(Encoding.ISO)
+    override val defaultEncoding = Encoding.ISO
+
+    companion object {
+        const val NAME = "virtual"
+    }
+
+    override fun memorySize(dt: DataType): Int {
+        return when(dt) {
+            in ByteDatatypes -> 1
+            in WordDatatypes, in PassByReferenceDatatypes -> 2
+            DataType.FLOAT -> machine.FLOAT_MEM_SIZE
+            else -> Int.MIN_VALUE
+        }
+    }
+
+    override fun memorySize(arrayDt: DataType, numElements: Int) =
+        memorySize(ArrayToElementTypes.getValue(arrayDt)) * numElements
+}

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

@@ -1,7 +1,7 @@
-package prog8.codegen.target.atari
+package prog8.code.target.atari
 
-import prog8.codegen.target.c64.normal6502instructions
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.code.target.c64.normal6502instructions
 import java.nio.file.Path
 
 
@@ -23,7 +23,7 @@ class AtariMachineDefinition: IMachineDefinition {
     override fun getFloat(num: Number) = TODO("float from number")
 
     override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
-        return if (compilerOptions.launcher == CbmPrgLauncherType.BASIC || compilerOptions.output == OutputType.PRG)
+        return if (compilerOptions.output == OutputType.XEX)
             listOf("syslib")
         else
             emptyList()

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

@@ -1,9 +1,9 @@
-package prog8.codegen.target.atari
+package prog8.code.target.atari
 
-import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.InternalCompilerException
-import prog8.compilerinterface.Zeropage
-import prog8.compilerinterface.ZeropageType
+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) {
 

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

@@ -1,8 +1,8 @@
-package prog8.codegen.target.c128
+package prog8.code.target.c128
 
-import prog8.codegen.target.c64.normal6502instructions
-import prog8.codegen.target.cbm.Mflpt5
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.code.target.c64.normal6502instructions
+import prog8.code.target.cbm.Mflpt5
 import java.nio.file.Path
 
 

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

@@ -1,9 +1,10 @@
-package prog8.codegen.target.c128
+package prog8.code.target.c128
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.InternalCompilerException
+import prog8.code.core.Zeropage
+import prog8.code.core.ZeropageType
 
-import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.InternalCompilerException
-import prog8.compilerinterface.Zeropage
-import prog8.compilerinterface.ZeropageType
 
 class C128Zeropage(options: CompilationOptions) : Zeropage(options) {
 

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

@@ -1,7 +1,7 @@
-package prog8.codegen.target.c64
+package prog8.code.target.c64
 
-import prog8.codegen.target.cbm.Mflpt5
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.code.target.cbm.Mflpt5
 import java.io.IOException
 import java.nio.file.Path
 

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

@@ -1,9 +1,10 @@
-package prog8.codegen.target.c64
+package prog8.code.target.c64
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.InternalCompilerException
+import prog8.code.core.Zeropage
+import prog8.code.core.ZeropageType
 
-import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.InternalCompilerException
-import prog8.compilerinterface.Zeropage
-import prog8.compilerinterface.ZeropageType
 
 class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
 

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

@@ -1,4 +1,4 @@
-package prog8.codegen.target.cbm
+package prog8.code.target.cbm
 
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
@@ -195,7 +195,17 @@ object AtasciiEncoding {
 
 
     fun encode(str: String): Result<List<UByte>, CharConversionException> {
-        return Ok(str.map { encodeTable.getValue(it).toUByte() })
+        val mapped = str.map { chr ->
+            when (chr) {
+                '\u0000' -> 0u
+                in '\u8000'..'\u80ff' -> {
+                    // special case: take the lower 8 bit hex value directly
+                    (chr.code - 0x8000).toUByte()
+                }
+                else -> encodeTable.getValue(chr).toUByte()
+            }
+        }
+        return Ok(mapped)
     }
 
     fun decode(bytes: List<UByte>): Result<String, CharConversionException> {

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

@@ -0,0 +1,18 @@
+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 -> Int.MIN_VALUE
+        }
+    }
+
+    override fun memorySize(arrayDt: DataType, numElements: Int) =
+        memorySize(ArrayToElementTypes.getValue(arrayDt)) * numElements
+}

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

@@ -1,4 +1,4 @@
-package prog8.codegen.target.cbm
+package prog8.code.target.cbm
 
 import com.github.michaelbull.result.Err
 import com.github.michaelbull.result.Ok
@@ -11,7 +11,17 @@ object IsoEncoding {
 
     fun encode(str: String): Result<List<UByte>, CharConversionException> {
         return try {
-            Ok(str.toByteArray(charset).map { it.toUByte() })
+            val mapped = str.map { chr ->
+                when (chr) {
+                    '\u0000' -> 0u
+                    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)
         }

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

@@ -1,7 +1,7 @@
-package prog8.codegen.target.cbm
+package prog8.code.target.cbm
 
-import prog8.compilerinterface.IMachineFloat
-import prog8.compilerinterface.InternalCompilerException
+import prog8.code.core.IMachineFloat
+import prog8.code.core.InternalCompilerException
 import kotlin.math.absoluteValue
 import kotlin.math.pow
 

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

@@ -1,9 +1,8 @@
-package prog8.codegen.target.cbm
+package prog8.code.target.cbm
 
 import com.github.michaelbull.result.Err
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
-import prog8.ast.antlr.escape
 import java.io.CharConversionException
 
 object PetsciiEncoding {
@@ -1077,7 +1076,7 @@ object PetsciiEncoding {
                 }
                 else -> {
                     val case = if (lowercase) "lower" else "upper"
-                    throw CharConversionException("no ${case}Petscii character for '${escape(chr.toString())}' (${chr.code})")
+                    throw CharConversionException("no ${case}Petscii character for '${chr}' (${chr.code})")
                 }
             }
         }
@@ -1120,7 +1119,7 @@ object PetsciiEncoding {
                 }
                 else -> {
                     val case = if (lowercase) "lower" else "upper"
-                    throw CharConversionException("no ${case}Screencode character for '${escape(chr.toString())}' (${chr.code})")
+                    throw CharConversionException("no ${case}Screencode character for '${chr}' (${chr.code})")
                 }
             }
         }

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

@@ -1,7 +1,7 @@
-package prog8.codegen.target.cx16
+package prog8.code.target.cx16
 
-import prog8.codegen.target.cbm.Mflpt5
-import prog8.compilerinterface.*
+import prog8.code.core.*
+import prog8.code.target.cbm.Mflpt5
 import java.nio.file.Path
 
 
@@ -60,7 +60,7 @@ class CX16MachineDefinition: IMachineDefinition {
         zeropage = CX16Zeropage(compilerOptions)
     }
 
-    // 6502 opcodes (including aliases and illegal opcodes), these cannot be used as variable or label names
+    // 65c02 opcodes, these cannot be used as variable or label names
     override val opcodeNames = setOf("adc", "and", "asl", "bcc", "bcs",
             "beq", "bge", "bit", "blt", "bmi", "bne", "bpl", "brk", "bvc", "bvs", "clc",
             "cld", "cli", "clv", "cmp", "cpx", "cpy", "dec", "dex", "dey",

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

@@ -1,11 +1,7 @@
-package prog8.codegen.target.cx16
+package prog8.code.target.cx16
+
+import prog8.code.core.*
 
-import prog8.ast.GlobalNamespace
-import prog8.ast.base.DataType
-import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.InternalCompilerException
-import prog8.compilerinterface.Zeropage
-import prog8.compilerinterface.ZeropageType
 
 class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
 
@@ -16,8 +12,12 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
 
 
     init {
-        if (options.floats && options.zeropage !in arrayOf(ZeropageType.BASICSAFE, ZeropageType.DONTUSE))
-            throw InternalCompilerException("when floats are enabled, zero page type should be 'basicsafe' or 'dontuse'")
+        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'")
 
         // the addresses 0x02 to 0x21 (inclusive) are taken for sixteen virtual 16-bit api registers.
 
@@ -30,6 +30,10 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
                     free.addAll(0x22u..0x7fu)
                     free.addAll(0xa9u..0xffu)
                 }
+                ZeropageType.FLOATSAFE -> {
+                    free.addAll(0x22u..0x7fu)
+                    free.addAll(0xd4u..0xffu)
+                }
                 ZeropageType.BASICSAFE -> {
                     free.addAll(0x22u..0x7fu)
                 }
@@ -43,14 +47,13 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {
 
             // 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.
-            val dummyscope = GlobalNamespace(emptyList())
             for(reg in 0..15) {
-                allocatedVariables[listOf("cx16", "r${reg}")]   = ZpAllocation((2+reg*2).toUInt(), DataType.UWORD, 2, dummyscope, null, null)        // cx16.r0 .. cx16.r15
-                allocatedVariables[listOf("cx16", "r${reg}s")]  = ZpAllocation((2+reg*2).toUInt(), DataType.WORD, 2, dummyscope, null, null)        // cx16.r0s .. cx16.r15s
-                allocatedVariables[listOf("cx16", "r${reg}L")]  = ZpAllocation((2+reg*2).toUInt(), DataType.UBYTE, 1, dummyscope, null, null)       // cx16.r0L .. cx16.r15L
-                allocatedVariables[listOf("cx16", "r${reg}H")]  = ZpAllocation((3+reg*2).toUInt(), DataType.UBYTE, 1, dummyscope, null, null)       // cx16.r0H .. cx16.r15H
-                allocatedVariables[listOf("cx16", "r${reg}sL")] = ZpAllocation((2+reg*2).toUInt(), DataType.BYTE, 1, dummyscope, null, null)       // cx16.r0sL .. cx16.r15sL
-                allocatedVariables[listOf("cx16", "r${reg}sH")] = ZpAllocation((3+reg*2).toUInt(), DataType.BYTE, 1, dummyscope, null, null)       // cx16.r0sH .. cx16.r15sH
+                allocatedVariables[listOf("cx16", "r${reg}")]   = ZpAllocation((2+reg*2).toUInt(), DataType.UWORD, 2)        // cx16.r0 .. cx16.r15
+                allocatedVariables[listOf("cx16", "r${reg}s")]  = ZpAllocation((2+reg*2).toUInt(), DataType.WORD, 2)        // cx16.r0s .. cx16.r15s
+                allocatedVariables[listOf("cx16", "r${reg}L")]  = ZpAllocation((2+reg*2).toUInt(), DataType.UBYTE, 1)       // cx16.r0L .. cx16.r15L
+                allocatedVariables[listOf("cx16", "r${reg}H")]  = ZpAllocation((3+reg*2).toUInt(), DataType.UBYTE, 1)       // cx16.r0H .. cx16.r15H
+                allocatedVariables[listOf("cx16", "r${reg}sL")] = ZpAllocation((2+reg*2).toUInt(), DataType.BYTE, 1)       // cx16.r0sL .. cx16.r15sL
+                allocatedVariables[listOf("cx16", "r${reg}sH")] = ZpAllocation((3+reg*2).toUInt(), DataType.BYTE, 1)       // cx16.r0sH .. cx16.r15sH
             }
         }
     }

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

@@ -0,0 +1,51 @@
+package prog8.code.target.virtual
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.CpuType
+import prog8.code.core.IMachineDefinition
+import prog8.code.core.Zeropage
+import prog8.vm.Assembler
+import prog8.vm.Memory
+import prog8.vm.VirtualMachine
+import java.io.File
+import java.nio.file.Path
+
+
+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 = 4
+    override val PROGRAM_LOAD_ADDRESS = 0u      // not actually used
+
+    override val ESTACK_LO = 0u                 // not actually used
+    override val ESTACK_HI = 0u                 // not actually used
+
+    override lateinit var zeropage: Zeropage     // not actually used
+
+    override fun getFloat(num: Number) = TODO("float from number")
+
+    override fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String> {
+        return listOf("syslib")
+    }
+
+    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
+        println("\nStarting Virtual Machine...")
+        val source = File("$programNameWithPath.p8virt").readText()
+        val (memsrc, programsrc) = source.split("------PROGRAM------".toRegex(), 2)
+        val memory = Memory()
+        val assembler = Assembler()
+        assembler.initializeMemory(memsrc, memory)
+        val program = assembler.assembleProgram(programsrc)
+        val vm = VirtualMachine(memory, program)
+        vm.run(throttle = true)
+    }
+
+    override fun isIOAddress(address: UInt): Boolean = false
+
+    override fun initializeZeropage(compilerOptions: CompilationOptions) {}
+
+    override val opcodeNames = emptySet<String>()
+}

codeGenCpu6502/build.gradle

@@ -24,11 +24,12 @@ compileTestKotlin {
 }
 
 dependencies {
-    implementation project(':compilerInterfaces')
+    implementation project(':codeAst')
+    implementation project(':codeCore')
     implementation project(':compilerAst')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.12"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
 
 }
 

codeGenCpu6502/codeGenCpu6502.iml

@@ -9,8 +9,9 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+    <orderEntry type="module" module-name="codeAst" />
+    <orderEntry type="module" module-name="codeCore" />
     <orderEntry type="module" module-name="compilerAst" />
-    <orderEntry type="module" module-name="compilerInterfaces" />
     <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
   </component>
 </module>

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

@@ -1,16 +1,16 @@
 package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
-import prog8.ast.IFunctionCall
-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.base.*
+import prog8.ast.*
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
-import prog8.ast.toHex
+import prog8.code.SymbolTable
+import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
-import prog8.compilerinterface.*
-import prog8.parser.SourceCode
+import prog8.compiler.BuiltinFunctions
+import prog8.compiler.builtinFunctionReturnType
+import prog8.code.core.SourceCode
 import java.util.*
 import kotlin.io.path.Path
 import kotlin.io.path.writeLines
@@ -22,22 +22,23 @@ internal const val subroutineFloatEvalResultVar2 = "prog8_float_eval_result2"
 
 
 class AsmGen(internal val program: Program,
-             internal val errors: IErrorReporter,
-             internal val variables: IVariablesAndConsts,
-             internal val options: CompilationOptions): IAssemblyGenerator {
+             internal val symbolTable: SymbolTable,
+             internal val options: CompilationOptions,
+             internal val errors: IErrorReporter
+): IAssemblyGenerator {
 
     internal val optimizedByteMultiplications = setOf(3,5,6,7,9,10,11,12,13,14,15,20,25,40,50,80,100)
     internal val optimizedWordMultiplications = setOf(3,5,6,7,9,10,12,15,20,25,40,50,80,100,320,640)
     internal val loopEndLabels = ArrayDeque<String>()
     private val zeropage = options.compTarget.machine.zeropage
-    private val allocator = VariableAllocator(variables, options, errors)
+    private val allocator = VariableAllocator(symbolTable, options, errors)
     private val assemblyLines = mutableListOf<String>()
     private val breakpointLabels = mutableListOf<String>()
     private val forloopsAsmGen = ForLoopsAsmGen(program, this, zeropage)
     private val postincrdecrAsmGen = PostIncrDecrAsmGen(program, this)
     private val functioncallAsmGen = FunctionCallAsmGen(program, this)
     private val expressionsAsmGen = ExpressionsAsmGen(program, this, allocator)
-    private val programGen = ProgramAndVarsGen(program, variables, options, errors, functioncallAsmGen, this, allocator, zeropage)
+    private val programGen = ProgramAndVarsGen(program, options, errors, symbolTable, functioncallAsmGen, this, allocator, zeropage)
     private val assignmentAsmGen = AssignmentAsmGen(program, this, allocator)
     private val builtinFunctionsAsmGen = BuiltinFunctionsAsmGen(program, this, assignmentAsmGen, allocator)
 
@@ -69,12 +70,6 @@ class AsmGen(internal val program: Program,
     }
 
     internal fun isTargetCpu(cpu: CpuType) = options.compTarget.machine.cpu == cpu
-    internal fun haveFPWRcall() = options.compTarget.name=="cx16"
-
-    internal fun asmsubArgsEvalOrder(sub: Subroutine) =
-        options.compTarget.asmsubArgsEvalOrder(sub)
-    internal fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
-        options.compTarget.asmsubArgsHaveRegisterClobberRisk(args, paramRegisters)
 
     private var generatedLabelSequenceNumber: Int = 0
 
@@ -234,11 +229,11 @@ class AsmGen(internal val program: Program,
                 }
                 CpuRegister.X -> {
                     out("  stx  prog8_regsaveX")
-                    allocator.subroutineExtra(scope).usedRegsaveX = true
+                    subroutineExtra(scope).usedRegsaveX = true
                 }
                 CpuRegister.Y -> {
                     out("  sty  prog8_regsaveY")
-                    allocator.subroutineExtra(scope).usedRegsaveY = true
+                    subroutineExtra(scope).usedRegsaveY = true
                 }
             }
         }
@@ -582,14 +577,7 @@ class AsmGen(internal val program: Program,
         loopEndLabels.push(endLabel)
 
         when (stmt.iterations) {
-            null -> {
-                // endless loop
-                val repeatLabel = makeLabel("repeat")
-                out(repeatLabel)
-                translate(stmt.body)
-                jmp(repeatLabel)
-                out(endLabel)
-            }
+            null -> throw AssemblyError("repeat-forever loop should have been replaced by label+jump")
             is NumericLiteral -> {
                 val iterations = (stmt.iterations as NumericLiteral).number.toInt()
                 when {
@@ -737,7 +725,7 @@ $repeatLabel    lda  $counterVar
 
     private fun createRepeatCounterVar(dt: DataType, preferZeropage: Boolean, stmt: RepeatLoop): String {
         val scope = stmt.definingSubroutine!!
-        val asmInfo = allocator.subroutineExtra(scope)
+        val asmInfo = subroutineExtra(scope)
         var parent = stmt.parent
         while(parent !is ParentSentinel) {
             if(parent is RepeatLoop)
@@ -758,7 +746,7 @@ $repeatLabel    lda  $counterVar
         val counterVar = makeLabel("counter")
         when(dt) {
             DataType.UBYTE, DataType.UWORD -> {
-                val result = zeropage.allocate(listOf(counterVar), dt, scope,null, null, stmt.position, errors)
+                val result = zeropage.allocate(listOf(counterVar), dt, null, stmt.position, errors)
                 result.fold(
                     success = { (address, _) -> asmInfo.extraVars.add(Triple(dt, counterVar, address)) },
                     failure = { asmInfo.extraVars.add(Triple(dt, counterVar, null)) }  // allocate normally
@@ -898,7 +886,7 @@ $repeatLabel    lda  $counterVar
     }
 
     private fun translate(gosub: GoSub) {
-        val tgt = gosub.identifier!!.targetSubroutine(program)
+        val tgt = gosub.identifier.targetSubroutine(program)
         if(tgt!=null && tgt.isAsmSubroutine) {
             // no need to rescue X , this has been taken care of already
             out("  jsr  ${getJumpTarget(gosub)}")
@@ -928,17 +916,7 @@ $repeatLabel    lda  $counterVar
         }
     }
 
-    private fun getJumpTarget(gosub: GoSub): String {
-        val ident = gosub.identifier
-        val label = gosub.generatedLabel
-        val addr = gosub.address
-        return when {
-            ident!=null -> asmSymbolName(ident)
-            label!=null -> label
-            addr!=null -> addr.toHex()
-            else -> "????"
-        }
-    }
+    private fun getJumpTarget(gosub: GoSub): String = asmSymbolName(gosub.identifier)
 
     private fun translate(ret: Return, withRts: Boolean=true) {
         ret.value?.let { returnvalue ->
@@ -1458,7 +1436,7 @@ $repeatLabel    lda  $counterVar
                 beq  $jumpIfFalseLabel""")
         } else {
             val subroutine = left.definingSubroutine!!
-            allocator.subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
+            subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
             assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
             assignExpressionToRegister(left, RegisterOrPair.FAC1)
             out("""
@@ -1503,7 +1481,7 @@ $repeatLabel    lda  $counterVar
                 beq  $jumpIfFalseLabel""")
         } else {
             val subroutine = left.definingSubroutine!!
-            allocator.subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
+            subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
             assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
             assignExpressionToRegister(left, RegisterOrPair.FAC1)
             out("""
@@ -1548,7 +1526,7 @@ $repeatLabel    lda  $counterVar
                 beq  $jumpIfFalseLabel""")
         } else {
             val subroutine = left.definingSubroutine!!
-            allocator.subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
+            subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
             assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
             assignExpressionToRegister(left, RegisterOrPair.FAC1)
             out("""
@@ -1593,7 +1571,7 @@ $repeatLabel    lda  $counterVar
                 beq  $jumpIfFalseLabel""")
         } else {
             val subroutine = left.definingSubroutine!!
-            allocator.subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
+            subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
             assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
             assignExpressionToRegister(left, RegisterOrPair.FAC1)
             out("""
@@ -2533,7 +2511,7 @@ $repeatLabel    lda  $counterVar
                 beq  $jumpIfFalseLabel""")
         } else {
             val subroutine = left.definingSubroutine!!
-            allocator.subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
+            subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
             assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
             assignExpressionToRegister(left, RegisterOrPair.FAC1)
             out("""
@@ -2618,7 +2596,7 @@ $repeatLabel    lda  $counterVar
                 bne  $jumpIfFalseLabel""")
         } else {
             val subroutine = left.definingSubroutine!!
-            allocator.subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
+            subroutineExtra(subroutine).usedFloatEvalResultVar1 = true
             assignExpressionToVariable(right, subroutineFloatEvalResultVar1, DataType.FLOAT, subroutine)
             assignExpressionToRegister(left, RegisterOrPair.FAC1)
             out("""
@@ -3049,4 +3027,34 @@ $repeatLabel    lda  $counterVar
                 out("  pha |  tya |  pha")
         }
     }
+
+    private val subroutineExtrasCache = mutableMapOf<Subroutine, SubroutineExtraAsmInfo>()
+
+    internal fun subroutineExtra(sub: Subroutine): SubroutineExtraAsmInfo {
+        var extra = subroutineExtrasCache[sub]
+        return if(extra==null) {
+            extra = SubroutineExtraAsmInfo()
+            subroutineExtrasCache[sub] = extra
+            extra
+        }
+        else
+            extra
+    }
 }
+
+
+/**
+ * Contains various attributes that influence the assembly code generator.
+ * Conceptually it should be part of any INameScope.
+ * But because the resulting code only creates "real" scopes on a subroutine level,
+ * it's more consistent to only define these attributes on a Subroutine node.
+ */
+internal class SubroutineExtraAsmInfo {
+    var usedRegsaveA = false
+    var usedRegsaveX = false
+    var usedRegsaveY = false
+    var usedFloatEvalResultVar1 = false
+    var usedFloatEvalResultVar2 = false
+
+    val extraVars = mutableListOf<Triple<DataType, String, UInt?>>()
+}

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

@@ -1,10 +1,10 @@
 package prog8.codegen.cpu6502
 
 import prog8.ast.Program
-import prog8.ast.base.VarDeclType
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.VarDecl
-import prog8.compilerinterface.IMachineDefinition
+import prog8.ast.statements.VarDeclType
+import prog8.code.core.IMachineDefinition
 
 
 // note: see https://wiki.nesdev.org/w/index.php/6502_assembly_optimisations

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

@@ -1,15 +1,15 @@
-package prog8.codegen.target.cbm
+package prog8.codegen.cpu6502
 
-import prog8.ast.base.Cx16VirtualRegisters
-import prog8.ast.base.RegisterOrPair
 import prog8.ast.expressions.ArrayIndexedExpression
 import prog8.ast.expressions.BuiltinFunctionCall
 import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
 import prog8.ast.statements.Subroutine
+import prog8.code.core.Cx16VirtualRegisters
+import prog8.code.core.RegisterOrPair
+import prog8.code.core.RegisterOrStatusflag
 
 
-internal fun asmsub6502ArgsEvalOrder(sub: Subroutine): List<Int> {
+fun asmsub6502ArgsEvalOrder(sub: Subroutine): List<Int> {
     val order = mutableListOf<Int>()
     // order is:
     //  1) cx16 virtual word registers,
@@ -37,7 +37,7 @@ internal fun asmsub6502ArgsEvalOrder(sub: Subroutine): List<Int> {
     return order
 }
 
-internal fun asmsub6502ArgsHaveRegisterClobberRisk(args: List<Expression>,
+fun asmsub6502ArgsHaveRegisterClobberRisk(args: List<Expression>,
                                                    paramRegisters: List<RegisterOrStatusflag>): Boolean {
     fun isClobberRisk(expr: Expression): Boolean {
         when (expr) {

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

@@ -3,8 +3,8 @@ package prog8.codegen.cpu6502
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
 import com.github.michaelbull.result.mapError
-import prog8.compilerinterface.*
-import prog8.parser.SourceCode
+import prog8.code.core.*
+import prog8.code.core.SourceCode
 import java.io.File
 import java.nio.file.Path
 import kotlin.io.path.Path

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

@@ -3,15 +3,16 @@ package prog8.codegen.cpu6502
 import prog8.ast.IFunctionCall
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.ArrayIndex
 import prog8.ast.statements.BuiltinFunctionCallStatement
 import prog8.ast.statements.DirectMemoryWrite
 import prog8.ast.statements.Subroutine
-import prog8.ast.toHex
+import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
-import prog8.compilerinterface.*
+import prog8.compiler.BuiltinFunctions
+import prog8.compiler.FSignature
+import prog8.compiler.builtinFunctionReturnType
 
 
 internal class BuiltinFunctionsAsmGen(private val program: Program,
@@ -128,6 +129,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
             "cmp" -> funcCmp(fcall)
             "callfar" -> funcCallFar(fcall)
             "callrom" -> funcCallRom(fcall)
+            "syscall", "syscall1", "syscall2", "syscall3" -> throw AssemblyError("6502 assembly target doesn't use syscall function interface")
             else -> throw AssemblyError("missing asmgen for builtin func ${func.name}")
         }
     }
@@ -1607,7 +1609,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
 
     private fun translateArguments(args: MutableList<Expression>, signature: FSignature, scope: Subroutine?) {
         val callConv = signature.callConvention(args.map {
-            it.inferType(program).getOrElse { throw AssemblyError("unknown dt")}
+            it.inferType(program).getOrElse { throw AssemblyError("unknown dt") }
         })
 
         fun getSourceForFloat(value: Expression): AsmAssignSource {
@@ -1623,7 +1625,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                     if(scope==null)
                         throw AssemblyError("cannot use float arguments outside of a subroutine scope")
 
-                    allocations.subroutineExtra(scope).usedFloatEvalResultVar2 = true
+                    asmgen.subroutineExtra(scope).usedFloatEvalResultVar2 = true
                     val variable = IdentifierReference(listOf(subroutineFloatEvalResultVar2), value.position)
                     val addr = AddressOf(variable, value.position)
                     addr.linkParents(value)

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

@@ -1,11 +1,8 @@
 package prog8.codegen.cpu6502
 
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.*
-import prog8.ast.toHex
-import prog8.compilerinterface.AssemblyError
-import prog8.compilerinterface.CpuType
+import prog8.code.core.*
 import kotlin.math.absoluteValue
 
 internal class ExpressionsAsmGen(private val program: Program,
@@ -671,6 +668,15 @@ internal class ExpressionsAsmGen(private val program: Program,
             }
             "not" -> {
                 when(type) {
+                    // if reg==0 ->
+                    /*
+        lda  P8ESTACK_LO+1,x
+		beq  +
+		lda  #1
++		eor  #1
+		sta  P8ESTACK_LO+1,x
+		rts
+                     */
                     in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.not_byte")
                     in WordDatatypes -> asmgen.out("  jsr  prog8_lib.not_word")
                     else -> throw AssemblyError("weird type")
@@ -729,7 +735,6 @@ internal class ExpressionsAsmGen(private val program: Program,
 
     private fun translateBinaryOperatorBytes(operator: String, types: DataType) {
         when(operator) {
-            "**" -> throw AssemblyError("** operator requires floats")
             "*" -> asmgen.out("  jsr  prog8_lib.mul_byte")  //  the optimized routines should have been checked earlier
             "/" -> asmgen.out(if(types==DataType.UBYTE) "  jsr  prog8_lib.idiv_ub" else "  jsr  prog8_lib.idiv_b")
             "%" -> {
@@ -771,7 +776,6 @@ internal class ExpressionsAsmGen(private val program: Program,
 
     private fun translateBinaryOperatorWords(operator: String, dt: DataType) {
         when(operator) {
-            "**" -> throw AssemblyError("** operator requires floats")
             "*" -> asmgen.out("  jsr  prog8_lib.mul_word")
             "/" -> asmgen.out(if(dt==DataType.UWORD) "  jsr  prog8_lib.idiv_uw" else "  jsr  prog8_lib.idiv_w")
             "%" -> {
@@ -806,7 +810,6 @@ internal class ExpressionsAsmGen(private val program: Program,
 
     private fun translateBinaryOperatorFloats(operator: String) {
         when(operator) {
-            "**" -> asmgen.out(" jsr  floats.pow_f")
             "*" -> asmgen.out("  jsr  floats.mul_f")
             "/" -> asmgen.out("  jsr  floats.div_f")
             "+" -> asmgen.out("  jsr  floats.add_f")

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

@@ -2,15 +2,10 @@ package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
 import prog8.ast.Program
-import prog8.ast.base.ArrayToElementTypes
-import prog8.ast.base.DataType
-import prog8.ast.base.RegisterOrPair
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.RangeExpression
 import prog8.ast.statements.ForLoop
-import prog8.ast.toHex
-import prog8.compilerinterface.AssemblyError
-import prog8.compilerinterface.Zeropage
+import prog8.code.core.*
 import kotlin.math.absoluteValue
 
 internal class ForLoopsAsmGen(private val program: Program, private val asmgen: AsmGen, private val zeropage: Zeropage) {
@@ -292,7 +287,7 @@ $loopLabel          sty  $indexVar
                 }
                 if(length>=16) {
                     // allocate index var on ZP if possible
-                    val result = zeropage.allocate(listOf(indexVar), DataType.UBYTE, stmt.definingScope, null, null, stmt.position, asmgen.errors)
+                    val result = zeropage.allocate(listOf(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") }
@@ -333,7 +328,7 @@ $loopLabel          sty  $indexVar
                 }
                 if(length>=16) {
                     // allocate index var on ZP if possible
-                    val result = zeropage.allocate(listOf(indexVar), DataType.UBYTE, stmt.definingScope, null, null, stmt.position, asmgen.errors)
+                    val result = zeropage.allocate(listOf(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") }

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

@@ -3,17 +3,16 @@ package prog8.codegen.cpu6502
 import prog8.ast.IFunctionCall
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.AddressOf
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.*
+import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.AsmAssignSource
 import prog8.codegen.cpu6502.assignment.AsmAssignTarget
 import prog8.codegen.cpu6502.assignment.AsmAssignment
 import prog8.codegen.cpu6502.assignment.TargetStorageKind
-import prog8.compilerinterface.AssemblyError
 
 
 internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) {
@@ -37,7 +36,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
     }
 
     internal fun saveXbeforeCall(gosub: GoSub) {
-        val sub = gosub.identifier?.targetSubroutine(program)
+        val sub = gosub.identifier.targetSubroutine(program)
         if(sub?.shouldSaveX()==true) {
             val regSaveOnStack = sub.asmAddress==null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
             if(regSaveOnStack)
@@ -59,7 +58,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
     }
 
     internal fun restoreXafterCall(gosub: GoSub) {
-        val sub = gosub.identifier?.targetSubroutine(program)
+        val sub = gosub.identifier.targetSubroutine(program)
         if(sub?.shouldSaveX()==true) {
             val regSaveOnStack = sub.asmAddress==null       // rom-routines don't require registers to be saved on stack, normal subroutines do because they can contain nested calls
             if(regSaveOnStack)
@@ -133,10 +132,10 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
         if(sub.parameters.size==1) {
             argumentViaRegister(sub, IndexedValue(0, sub.parameters.single()), call.args[0])
         } else {
-            if(asmgen.asmsubArgsHaveRegisterClobberRisk(call.args, sub.asmParameterRegisters)) {
+            if(asmsub6502ArgsHaveRegisterClobberRisk(call.args, sub.asmParameterRegisters)) {
                 registerArgsViaCpuStackEvaluation(call, sub)
             } else {
-                asmgen.asmsubArgsEvalOrder(sub).forEach {
+                asmsub6502ArgsEvalOrder(sub).forEach {
                     val param = sub.parameters[it]
                     val arg = call.args[it]
                     argumentViaRegister(sub, IndexedValue(it, param), arg)
@@ -154,7 +153,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
             return
 
         // use the cpu hardware stack as intermediate storage for the arguments.
-        val argOrder = asmgen.options.compTarget.asmsubArgsEvalOrder(callee)
+        val argOrder = asmsub6502ArgsEvalOrder(callee)
         argOrder.reversed().forEach {
             asmgen.pushCpuStack(callee.parameters[it].type, call.args[it])
         }

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

@@ -1,12 +1,10 @@
 package prog8.codegen.cpu6502
 
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.PostIncrDecr
-import prog8.ast.toHex
-import prog8.compilerinterface.AssemblyError
+import prog8.code.core.*
 
 
 internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) {

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

@@ -1,15 +1,13 @@
 package prog8.codegen.cpu6502
 
-import prog8.ast.INameScope
 import prog8.ast.Program
 import prog8.ast.antlr.escape
-import prog8.ast.base.*
-import prog8.ast.expressions.*
 import prog8.ast.statements.*
-import prog8.ast.toHex
+import prog8.code.*
+import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.AsmAssignTarget
 import prog8.codegen.cpu6502.assignment.TargetStorageKind
-import prog8.compilerinterface.*
+import prog8.compiler.CallGraph
 import java.time.LocalDate
 import java.time.LocalDateTime
 import kotlin.math.absoluteValue
@@ -24,9 +22,9 @@ import kotlin.math.absoluteValue
  */
 internal class ProgramAndVarsGen(
     val program: Program,
-    val variables: IVariablesAndConsts,
     val options: CompilationOptions,
     val errors: IErrorReporter,
+    private val symboltable: SymbolTable,
     private val functioncallAsmGen: FunctionCallAsmGen,
     private val asmgen: AsmGen,
     private val allocator: VariableAllocator,
@@ -40,8 +38,6 @@ internal class ProgramAndVarsGen(
         val allInitializers = blockVariableInitializers.asSequence().flatMap { it.value }
         require(allInitializers.all { it.origin==AssignmentOrigin.VARINIT }) {"all block-level assignments must be a variable initializer"}
 
-        allocator.allocateZeropageVariables()
-
         header()
         val allBlocks = program.allBlocks
         if(allBlocks.first().name != "main")
@@ -69,32 +65,6 @@ internal class ProgramAndVarsGen(
         asmgen.out("")
         asmgen.out(".cpu  '$cpu'\n.enc  'none'\n")
 
-        program.actualLoadAddress = program.definedLoadAddress
-        if (program.actualLoadAddress == 0u) {
-            when(options.output) {
-                OutputType.RAW -> {
-                    errors.err("load address must be specified with %address when using raw output type", program.toplevelModule.position)
-                    return
-                }
-                OutputType.PRG -> {
-                    when(options.launcher) {
-                        CbmPrgLauncherType.BASIC -> {
-                            program.actualLoadAddress = compTarget.machine.PROGRAM_LOAD_ADDRESS
-                        }
-                        CbmPrgLauncherType.NONE -> {
-                            errors.err("load address must be specified with %address when not using basic launcher", program.toplevelModule.position)
-                            return
-                        }
-                    }
-                }
-                OutputType.XEX -> {
-                    if(options.launcher!=CbmPrgLauncherType.NONE)
-                        throw AssemblyError("atari xex output can't contain BASIC launcher")
-                    program.actualLoadAddress = compTarget.machine.PROGRAM_LOAD_ADDRESS
-                }
-            }
-        }
-
         // the global prog8 variables needed
         val zp = zeropage
         asmgen.out("P8ZP_SCRATCH_B1 = ${zp.SCRATCH_B1}")
@@ -107,16 +77,16 @@ internal class ProgramAndVarsGen(
         when(options.output) {
             OutputType.RAW -> {
                 asmgen.out("; ---- raw assembler program ----")
-                asmgen.out("* = ${program.actualLoadAddress.toHex()}\n")
+                asmgen.out("* = ${options.loadAddress.toHex()}\n")
             }
             OutputType.PRG -> {
                 when(options.launcher) {
                     CbmPrgLauncherType.BASIC -> {
-                        if (program.actualLoadAddress != options.compTarget.machine.PROGRAM_LOAD_ADDRESS) {
+                        if (options.loadAddress != options.compTarget.machine.PROGRAM_LOAD_ADDRESS) {
                             errors.err("BASIC output must have load address ${options.compTarget.machine.PROGRAM_LOAD_ADDRESS.toHex()}", program.toplevelModule.position)
                         }
                         asmgen.out("; ---- basic program with sys call ----")
-                        asmgen.out("* = ${program.actualLoadAddress.toHex()}")
+                        asmgen.out("* = ${options.loadAddress.toHex()}")
                         val year = LocalDate.now().year
                         asmgen.out("  .word  (+), $year")
                         asmgen.out("  .null  $9e, format(' %d ', prog8_entrypoint), $3a, $8f, ' prog8'")
@@ -128,7 +98,7 @@ internal class ProgramAndVarsGen(
                     }
                     CbmPrgLauncherType.NONE -> {
                         asmgen.out("; ---- program without basic sys call ----")
-                        asmgen.out("* = ${program.actualLoadAddress.toHex()}\n")
+                        asmgen.out("* = ${options.loadAddress.toHex()}\n")
                         if(!options.noSysInit)
                             asmgen.out("  jsr  ${compTarget.name}.init_system")
                         asmgen.out("  jsr  ${compTarget.name}.init_system_phase2")
@@ -137,7 +107,7 @@ internal class ProgramAndVarsGen(
             }
             OutputType.XEX -> {
                 asmgen.out("; ---- atari xex program ----")
-                asmgen.out("* = ${program.actualLoadAddress.toHex()}\n")
+                asmgen.out("* = ${options.loadAddress.toHex()}\n")
                 if(!options.noSysInit)
                     asmgen.out("  jsr  ${compTarget.name}.init_system")
                 asmgen.out("  jsr  ${compTarget.name}.init_system_phase2")
@@ -202,13 +172,10 @@ internal class ProgramAndVarsGen(
         }
 
         asmgen.out("${block.name}\t" + (if("force_output" in block.options()) ".block\n" else ".proc\n"))
-
         asmgen.outputSourceLine(block)
 
-        zeropagevars2asm(block)
-        memdefsAndConsts2asm(block)
+        createBlockVariables(block)
         asmsubs2asm(block.statements)
-        nonZpVariables2asm(block)
 
         asmgen.out("")
         asmgen.out("; subroutines in this block")
@@ -234,6 +201,34 @@ internal class ProgramAndVarsGen(
         asmgen.out(if("force_output" in block.options()) "\n\t.bend\n" else "\n\t.pend\n")
     }
 
+    private fun getVars(scope: StNode): Map<String, StNode> =
+        scope.children.filter { it.value.type in arrayOf(StNodeType.STATICVAR, StNodeType.CONSTANT, StNodeType.MEMVAR) }
+
+    private fun createBlockVariables(block: Block) {
+        val scope = symboltable.lookupOrElse(block.name) { throw AssemblyError("lookup") }
+        require(scope.type==StNodeType.BLOCK)
+        val varsInBlock = getVars(scope)
+
+        // Zeropage Variables
+        val varnames = varsInBlock.filter { it.value.type==StNodeType.STATICVAR }.map { it.value.scopedName }.toSet()
+        zeropagevars2asm(varnames)
+
+        // MemDefs and Consts
+        val mvs = varsInBlock
+            .filter { it.value.type==StNodeType.MEMVAR }
+            .map { it.value as StMemVar }
+        val consts = varsInBlock
+            .filter { it.value.type==StNodeType.CONSTANT }
+            .map { it.value as StConstant }
+        memdefsAndConsts2asm(mvs, consts)
+
+        // normal statically allocated variables
+        val variables = varsInBlock
+            .filter { it.value.type==StNodeType.STATICVAR && !allocator.isZpVar(it.value.scopedName) }
+            .map { it.value as StStaticVariable }
+        nonZpVariables2asm(variables)
+    }
+
     internal fun translateSubroutine(sub: Subroutine) {
         var onlyVariables = false
 
@@ -262,8 +257,24 @@ internal class ProgramAndVarsGen(
         } else {
             // regular subroutine
             asmgen.out("${sub.name}\t.proc")
-            zeropagevars2asm(sub)
-            memdefsAndConsts2asm(sub)
+
+            val scope = symboltable.lookupOrElse(sub.scopedName) { throw AssemblyError("lookup") }
+            require(scope.type==StNodeType.SUBROUTINE)
+            val varsInSubroutine = getVars(scope)
+
+            // Zeropage Variables
+            val varnames = varsInSubroutine.filter { it.value.type==StNodeType.STATICVAR }.map { it.value.scopedName }.toSet()
+            zeropagevars2asm(varnames)
+
+            // MemDefs and Consts
+            val mvs = varsInSubroutine
+                .filter { it.value.type==StNodeType.MEMVAR }
+                .map { it.value as StMemVar }
+            val consts = varsInSubroutine
+                .filter { it.value.type==StNodeType.CONSTANT }
+                .map { it.value as StConstant }
+            memdefsAndConsts2asm(mvs, consts)
+
             asmsubs2asm(sub.statements)
 
             // the main.start subroutine is the program's entrypoint and should perform some initialization logic
@@ -295,7 +306,7 @@ internal class ProgramAndVarsGen(
             }
 
             asmgen.out("; variables")
-            val asmGenInfo = allocator.subroutineExtra(sub)
+            val asmGenInfo = asmgen.subroutineExtra(sub)
             for((dt, name, addr) in asmGenInfo.extraVars) {
                 if(addr!=null)
                     asmgen.out("$name = $addr")
@@ -315,7 +326,13 @@ internal class ProgramAndVarsGen(
                 asmgen.out("$subroutineFloatEvalResultVar1    .byte  0,0,0,0,0")
             if(asmGenInfo.usedFloatEvalResultVar2)
                 asmgen.out("$subroutineFloatEvalResultVar2    .byte  0,0,0,0,0")
-            nonZpVariables2asm(sub)
+
+            // normal statically allocated variables
+            val variables = varsInSubroutine
+                .filter { it.value.type==StNodeType.STATICVAR && !allocator.isZpVar(it.value.scopedName) }
+                .map { it.value as StStaticVariable }
+            nonZpVariables2asm(variables)
+
             asmgen.out("  .pend\n")
         }
     }
@@ -331,12 +348,12 @@ internal class ProgramAndVarsGen(
         }
 
         // string and array variables in zeropage that have initializer value, should be initialized
-        val stringVarsWithInitInZp = allocator.zeropageVars.filter { it.value.dt==DataType.STR && it.value.initialStringValue!=null }
-        val arrayVarsWithInitInZp = allocator.zeropageVars.filter { it.value.dt in ArrayDatatypes && it.value.initialArrayValue!=null }
+        val stringVarsWithInitInZp = getZpStringVarsWithInitvalue()
+        val arrayVarsWithInitInZp = getZpArrayVarsWithInitvalue()
         if(stringVarsWithInitInZp.isNotEmpty() || arrayVarsWithInitInZp.isNotEmpty()) {
             asmgen.out("; zp str and array initializations")
             stringVarsWithInitInZp.forEach {
-                val name = asmgen.asmVariableName(it.key)
+                val name = asmgen.asmVariableName(it.name)
                 asmgen.out("""
                     lda  #<${name}
                     ldy  #>${name}
@@ -347,8 +364,8 @@ internal class ProgramAndVarsGen(
                     jsr  prog8_lib.strcpy""")
             }
             arrayVarsWithInitInZp.forEach {
-                val size = it.value.size
-                val name = asmgen.asmVariableName(it.key)
+                val size = it.alloc.size
+                val name = asmgen.asmVariableName(it.name)
                 asmgen.out("""
                     lda  #<${name}_init_value
                     ldy  #>${name}_init_value
@@ -366,14 +383,13 @@ internal class ProgramAndVarsGen(
         }
 
         stringVarsWithInitInZp.forEach {
-            val varname = asmgen.asmVariableName(it.key)+"_init_value"
-            val stringvalue = it.value.initialStringValue!!
-            outputStringvar(varname, it.value.dt, stringvalue.encoding, stringvalue.value)
+            val varname = asmgen.asmVariableName(it.name)+"_init_value"
+            outputStringvar(varname, it.value.second, it.value.first)
         }
 
         arrayVarsWithInitInZp.forEach {
-            val varname = asmgen.asmVariableName(it.key)+"_init_value"
-            arrayVariable2asm(varname, it.value.dt, it.value.initialArrayValue!!, null)
+            val varname = asmgen.asmVariableName(it.name)+"_init_value"
+            arrayVariable2asm(varname, it.alloc.dt, it.value, null)
         }
 
         asmgen.out("""+       tsx
@@ -383,8 +399,42 @@ internal class ProgramAndVarsGen(
                     clc""")
     }
 
-    private fun zeropagevars2asm(scope: INameScope) {
-        val zpVariables = allocator.zeropageVars.filter { it.value.originalScope==scope }
+    private class ZpStringWithInitial(
+        val name: List<String>,
+        val alloc: Zeropage.ZpAllocation,
+        val value: Pair<String, Encoding>
+    )
+
+    private class ZpArrayWithInitial(
+        val name: List<String>,
+        val alloc: Zeropage.ZpAllocation,
+        val value: StArray
+    )
+
+    private fun getZpStringVarsWithInitvalue(): Collection<ZpStringWithInitial> {
+        val result = mutableListOf<ZpStringWithInitial>()
+        val vars = allocator.zeropageVars.filter { it.value.dt==DataType.STR }
+        for (variable in vars) {
+            val svar = symboltable.lookup(variable.key) as StStaticVariable        // TODO faster in flat lookup table
+            if(svar.initialStringValue!=null)
+                result.add(ZpStringWithInitial(variable.key, variable.value, svar.initialStringValue!!))
+        }
+        return result
+    }
+
+    private fun getZpArrayVarsWithInitvalue(): Collection<ZpArrayWithInitial> {
+        val result = mutableListOf<ZpArrayWithInitial>()
+        val vars = allocator.zeropageVars.filter { it.value.dt in ArrayDatatypes }
+        for (variable in vars) {
+            val svar = symboltable.lookup(variable.key) as StStaticVariable        // TODO faster in flat lookup table
+            if(svar.initialArrayValue!=null)
+                result.add(ZpArrayWithInitial(variable.key, variable.value, svar.initialArrayValue!!))
+        }
+        return result
+    }
+
+    private fun zeropagevars2asm(varNames: Set<List<String>>) {
+        val zpVariables = allocator.zeropageVars.filter { it.key in varNames }
         for ((scopedName, zpvar) in zpVariables) {
             if (scopedName.size == 2 && scopedName[0] == "cx16" && scopedName[1][0] == 'r' && scopedName[1][1].isDigit())
                 continue        // The 16 virtual registers of the cx16 are not actual variables in zp, they're memory mapped
@@ -392,70 +442,52 @@ internal class ProgramAndVarsGen(
         }
     }
 
-    private fun nonZpVariables2asm(block: Block) {
-        val variables = variables.blockVars[block]?.filter { !allocator.isZpVar(it.scopedname) } ?: emptyList()
-        nonZpVariables2asm(variables)
-    }
-
-    private fun nonZpVariables2asm(sub: Subroutine) {
-        val variables = variables.subroutineVars[sub]?.filter { !allocator.isZpVar(it.scopedname) } ?: emptyList()
-        nonZpVariables2asm(variables)
-    }
-
-    private fun nonZpVariables2asm(variables: List<IVariablesAndConsts.StaticVariable>) {
+    private fun nonZpVariables2asm(variables: List<StStaticVariable>) {
         asmgen.out("")
         asmgen.out("; non-zeropage variables")
-        val (stringvars, othervars) = variables.partition { it.type==DataType.STR }
+        val (stringvars, othervars) = variables.partition { it.dt==DataType.STR }
         stringvars.forEach {
-            val stringvalue = it.initialValue as StringLiteral
-            outputStringvar(it.scopedname.last(), it.type, stringvalue.encoding, stringvalue.value)
+            outputStringvar(it.name, it.initialStringValue!!.second, it.initialStringValue!!.first)
         }
         othervars.sortedBy { it.type }.forEach {
             staticVariable2asm(it)
         }
     }
 
-    private fun staticVariable2asm(variable: IVariablesAndConsts.StaticVariable) {
-        val name = variable.scopedname.last()
-        val value = variable.initialValue
-        val staticValue: Number =
-            if(value!=null) {
-                if(value is NumericLiteral) {
-                    if(value.type== DataType.FLOAT)
-                        value.number
-                    else
-                        value.number.toInt()
-                } else {
-                    if(variable.type in NumericDatatypes)
-                        throw AssemblyError("can only deal with constant numeric values for global vars")
-                    else 0
-                }
+    private fun staticVariable2asm(variable: StStaticVariable) {
+        val name = variable.name
+        val initialValue: Number =
+            if(variable.initialNumericValue!=null) {
+                if(variable.dt== DataType.FLOAT)
+                    variable.initialNumericValue!!
+                else
+                    variable.initialNumericValue!!.toInt()
             } else 0
 
-        when (variable.type) {
-            DataType.UBYTE -> asmgen.out("$name\t.byte  ${staticValue.toHex()}")
-            DataType.BYTE -> asmgen.out("$name\t.char  $staticValue")
-            DataType.UWORD -> asmgen.out("$name\t.word  ${staticValue.toHex()}")
-            DataType.WORD -> asmgen.out("$name\t.sint  $staticValue")
+        when (variable.dt) {
+            DataType.UBYTE -> asmgen.out("$name\t.byte  ${initialValue.toHex()}")
+            DataType.BYTE -> asmgen.out("$name\t.char  $initialValue")
+            DataType.UWORD -> asmgen.out("$name\t.word  ${initialValue.toHex()}")
+            DataType.WORD -> asmgen.out("$name\t.sint  $initialValue")
             DataType.FLOAT -> {
-                if(staticValue==0) {
+                if(initialValue==0) {
                     asmgen.out("$name\t.byte  0,0,0,0,0  ; float")
                 } else {
-                    val floatFill = compTarget.machine.getFloat(staticValue).makeFloatFillAsm()
-                    asmgen.out("$name\t.byte  $floatFill  ; float $staticValue")
+                    val floatFill = compTarget.machine.getFloat(initialValue).makeFloatFillAsm()
+                    asmgen.out("$name\t.byte  $floatFill  ; float $initialValue")
                 }
             }
             DataType.STR -> {
                 throw AssemblyError("all string vars should have been interned into prog")
             }
-            in ArrayDatatypes -> arrayVariable2asm(name, variable.type, value as? ArrayLiteral, variable.arraysize)
+            in ArrayDatatypes -> arrayVariable2asm(name, variable.dt, variable.initialArrayValue, variable.length)
             else -> {
                 throw AssemblyError("weird dt")
             }
         }
     }
 
-    private fun arrayVariable2asm(varname: String, dt: DataType, value: ArrayLiteral?, orNumberOfZeros: Int?) {
+    private fun arrayVariable2asm(varname: String, dt: DataType, value: StArray?, orNumberOfZeros: Int?) {
         when(dt) {
             DataType.ARRAY_UB -> {
                 val data = makeArrayFillDataUnsigned(dt, value, orNumberOfZeros)
@@ -498,11 +530,9 @@ internal class ProgramAndVarsGen(
                 }
             }
             DataType.ARRAY_F -> {
-                val array = value?.value ?:
-                                Array(orNumberOfZeros!!) { defaultZero(ArrayToElementTypes.getValue(dt), Position.DUMMY) }
+                val array = value ?: zeroFilledArray(orNumberOfZeros!!)
                 val floatFills = array.map {
-                    val number = (it as NumericLiteral).number
-                    compTarget.machine.getFloat(number).makeFloatFillAsm()
+                    compTarget.machine.getFloat(it.number!!).makeFloatFillAsm()
                 }
                 asmgen.out(varname)
                 for (f in array.zip(floatFills))
@@ -512,30 +542,23 @@ internal class ProgramAndVarsGen(
         }
     }
 
-    private fun memdefsAndConsts2asm(block: Block) {
-        val mvs = variables.blockMemvars[block] ?: emptySet()
-        val consts = variables.blockConsts[block] ?: emptySet()
-        memdefsAndConsts2asm(mvs, consts)
+    private fun zeroFilledArray(numElts: Int): StArray {
+        val values = mutableListOf<StArrayElement>()
+        repeat(numElts) {
+            values.add(StArrayElement(0.0, null))
+        }
+        return values
     }
 
-    private fun memdefsAndConsts2asm(sub: Subroutine) {
-        val mvs = variables.subroutineMemvars[sub] ?: emptySet()
-        val consts = variables.subroutineConsts[sub] ?: emptySet()
-        memdefsAndConsts2asm(mvs, consts)
-    }
-
-    private fun memdefsAndConsts2asm(
-        memvars: Set<IVariablesAndConsts.MemoryMappedVariable>,
-        consts: Set<IVariablesAndConsts.ConstantNumberSymbol>
-    ) {
+    private fun memdefsAndConsts2asm(memvars: Collection<StMemVar>, consts: Collection<StConstant>) {
         memvars.forEach {
-            asmgen.out("  ${it.scopedname.last()} = ${it.address.toHex()}")
+            asmgen.out("  ${it.name} = ${it.address.toHex()}")
         }
         consts.forEach {
-            if(it.type==DataType.FLOAT)
-                asmgen.out("  ${it.scopedname.last()} = ${it.value}")
+            if(it.dt==DataType.FLOAT)
+                asmgen.out("  ${it.name} = ${it.value}")
             else
-                asmgen.out("  ${it.scopedname.last()} = ${it.value.toHex()}")
+                asmgen.out("  ${it.name} = ${it.value.toHex()}")
         }
     }
 
@@ -548,56 +571,49 @@ internal class ProgramAndVarsGen(
             }
     }
 
-    private fun outputStringvar(varname: String, dt: DataType, encoding: Encoding, value: String) {
-        asmgen.out("$varname\t; $dt $encoding:\"${escape(value).replace("\u0000", "<NULL>")}\"")
+    private fun outputStringvar(varname: String, encoding: Encoding, value: String) {
+        asmgen.out("$varname\t; $encoding:\"${escape(value).replace("\u0000", "<NULL>")}\"")
         val bytes = compTarget.encodeString(value, encoding).plus(0.toUByte())
         val outputBytes = bytes.map { "$" + it.toString(16).padStart(2, '0') }
         for (chunk in outputBytes.chunked(16))
             asmgen.out("  .byte  " + chunk.joinToString())
     }
 
-    private fun makeArrayFillDataUnsigned(dt: DataType, value: ArrayLiteral?, orNumberOfZeros: Int?): List<String> {
-        val array = value?.value ?:
-                        Array(orNumberOfZeros!!) { defaultZero(ArrayToElementTypes.getValue(dt), Position.DUMMY) }
+    private fun makeArrayFillDataUnsigned(dt: DataType, value: StArray?, orNumberOfZeros: Int?): List<String> {
+        val array = value ?: zeroFilledArray(orNumberOfZeros!!)
         return when (dt) {
             DataType.ARRAY_UB ->
                 // byte array can never contain pointer-to types, so treat values as all integers
                 array.map {
-                    val number = (it as NumericLiteral).number.toInt()
+                    val number = it.number!!.toInt()
                     "$"+number.toString(16).padStart(2, '0')
                 }
             DataType.ARRAY_UW -> array.map {
-                when (it) {
-                    is NumericLiteral -> {
-                        "$" + it.number.toInt().toString(16).padStart(4, '0')
-                    }
-                    is AddressOf -> {
-                        asmgen.asmSymbolName(it.identifier)
-                    }
-                    is IdentifierReference -> {
-                        asmgen.asmSymbolName(it)
-                    }
-                    else -> throw AssemblyError("weird array elt dt")
+                if(it.number!=null) {
+                    "$" + it.number!!.toInt().toString(16).padStart(4, '0')
                 }
+                else if(it.addressOf!=null) {
+                    asmgen.asmSymbolName(it.addressOf!!)
+                }
+                else
+                    throw AssemblyError("weird array elt")
             }
             else -> throw AssemblyError("invalid dt")
         }
     }
 
-    private fun makeArrayFillDataSigned(dt: DataType, value: ArrayLiteral?, orNumberOfZeros: Int?): List<String> {
-        val array = value?.value ?:
-                        Array(orNumberOfZeros!!) { defaultZero(ArrayToElementTypes.getValue(dt), Position.DUMMY) }
+    private fun makeArrayFillDataSigned(dt: DataType, value: StArray?, orNumberOfZeros: Int?): List<String> {
+        val array = value ?: zeroFilledArray(orNumberOfZeros!!)
         return when (dt) {
+            // byte array can never contain pointer-to types, so treat values as all integers
             DataType.ARRAY_UB ->
-                // byte array can never contain pointer-to types, so treat values as all integers
                 array.map {
-                    val number = (it as NumericLiteral).number.toInt()
+                    val number = it.number!!.toInt()
                     "$"+number.toString(16).padStart(2, '0')
                 }
             DataType.ARRAY_B ->
-                // byte array can never contain pointer-to types, so treat values as all integers
                 array.map {
-                    val number = (it as NumericLiteral).number.toInt()
+                    val number = it.number!!.toInt()
                     val hexnum = number.absoluteValue.toString(16).padStart(2, '0')
                     if(number>=0)
                         "$$hexnum"
@@ -605,11 +621,11 @@ internal class ProgramAndVarsGen(
                         "-$$hexnum"
                 }
             DataType.ARRAY_UW -> array.map {
-                val number = (it as NumericLiteral).number.toInt()
+                val number = it.number!!.toInt()
                 "$" + number.toString(16).padStart(4, '0')
             }
             DataType.ARRAY_W -> array.map {
-                val number = (it as NumericLiteral).number.toInt()
+                val number = it.number!!.toInt()
                 val hexnum = number.absoluteValue.toString(16).padStart(4, '0')
                 if(number>=0)
                     "$$hexnum"

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

@@ -2,62 +2,71 @@ package prog8.codegen.cpu6502
 
 import com.github.michaelbull.result.fold
 import com.github.michaelbull.result.onSuccess
-import prog8.ast.base.ArrayDatatypes
-import prog8.ast.base.DataType
-import prog8.ast.base.IntegerDatatypes
-import prog8.ast.expressions.StringLiteral
-import prog8.ast.statements.Subroutine
-import prog8.ast.statements.ZeropageWish
-import prog8.compilerinterface.*
+import prog8.code.StNode
+import prog8.code.StNodeType
+import prog8.code.StStaticVariable
+import prog8.code.SymbolTable
+import prog8.code.core.*
 
 
-internal class VariableAllocator(private val vars: IVariablesAndConsts,
+internal class VariableAllocator(private val symboltable: SymbolTable,
                                  private val options: CompilationOptions,
-                                 private val errors: IErrorReporter) {
+                                 private val errors: IErrorReporter
+) {
 
     private val zeropage = options.compTarget.machine.zeropage
-    private val subroutineExtras = mutableMapOf<Subroutine, SubroutineExtraAsmInfo>()
     private val memorySlabsInternal = mutableMapOf<String, Pair<UInt, UInt>>()
     internal val memorySlabs: Map<String, Pair<UInt, UInt>> = memorySlabsInternal
     internal val globalFloatConsts = mutableMapOf<Double, String>()     // all float values in the entire program (value -> varname)
     internal val zeropageVars: Map<List<String>, Zeropage.ZpAllocation> = zeropage.allocatedVariables
 
+    init {
+        allocateZeropageVariables()
+    }
+
     internal fun getMemorySlab(name: String) = memorySlabsInternal[name]
+
     internal fun allocateMemorySlab(name: String, size: UInt, align: UInt) {
         memorySlabsInternal[name] = Pair(size, align)
     }
 
+    internal fun isZpVar(scopedName: List<String>) = scopedName in zeropage.allocatedVariables
+
+    internal fun getFloatAsmConst(number: Double): String {
+        val asmName = globalFloatConsts[number]
+        if(asmName!=null)
+            return asmName
+
+        val newName = "prog8_float_const_${globalFloatConsts.size}"
+        globalFloatConsts[number] = newName
+        return newName
+    }
+
     /**
      * Allocate variables into the Zeropage.
      * The result should be retrieved from the current machine's zeropage object!
      */
-    internal fun allocateZeropageVariables() {
+    private fun allocateZeropageVariables() {
         if(options.zeropage== ZeropageType.DONTUSE)
             return
 
-        val allVariables = (
-                        vars.blockVars.asSequence().flatMap { it.value } +
-                        vars.subroutineVars.asSequence().flatMap { it.value }
-                ).toList()
+        val allVariables = collectAllVariables(symboltable)
 
         val numberOfAllocatableVariables = allVariables.size
-        val varsRequiringZp = allVariables.filter { it.zp == ZeropageWish.REQUIRE_ZEROPAGE }
-        val varsPreferringZp = allVariables.filter { it.zp == ZeropageWish.PREFER_ZEROPAGE }
-        val varsDontCare = allVariables.filter { it.zp == ZeropageWish.DONTCARE }
-        val numberOfExplicitNonZpVariables = allVariables.count { it.zp == ZeropageWish.NOT_IN_ZEROPAGE }
+        val varsRequiringZp = allVariables.filter { it.zpwish == ZeropageWish.REQUIRE_ZEROPAGE }
+        val varsPreferringZp = allVariables.filter { it.zpwish == ZeropageWish.PREFER_ZEROPAGE }
+        val varsDontCare = allVariables.filter { it.zpwish == ZeropageWish.DONTCARE }
+        val numberOfExplicitNonZpVariables = allVariables.count { it.zpwish == ZeropageWish.NOT_IN_ZEROPAGE }
         require(varsDontCare.size + varsRequiringZp.size + varsPreferringZp.size + numberOfExplicitNonZpVariables == numberOfAllocatableVariables)
 
         var numVariablesAllocatedInZP = 0
         var numberOfNonIntegerVariables = 0
 
         varsRequiringZp.forEach { variable ->
-            val numElements = numArrayElements(variable)
             val result = zeropage.allocate(
-                variable.scopedname,
-                variable.type,
-                variable.scope,
-                numElements,
-                variable.initialValue,
+                variable.scopedName,
+                variable.dt,
+                variable.length,
                 variable.position,
                 errors
             )
@@ -73,13 +82,10 @@ internal class VariableAllocator(private val vars: IVariablesAndConsts,
 
         if(errors.noErrors()) {
             varsPreferringZp.forEach { variable ->
-                val numElements = numArrayElements(variable)
                 val result = zeropage.allocate(
-                    variable.scopedname,
-                    variable.type,
-                    variable.scope,
-                    numElements,
-                    variable.initialValue,
+                    variable.scopedName,
+                    variable.dt,
+                    variable.length,
                     variable.position,
                     errors
                 )
@@ -90,18 +96,15 @@ internal class VariableAllocator(private val vars: IVariablesAndConsts,
             // try to allocate any other interger variables into the zeropage until it is full.
             // TODO some form of intelligent priorization? most often used variables first? loopcounter vars first? ...?
             if(errors.noErrors()) {
-                for (variable in varsDontCare) {
-                    if(variable.type in IntegerDatatypes) {
+                for (variable in varsDontCare.sortedBy { it.scopedName.size }) {
+                    if(variable.dt in IntegerDatatypes) {
                         if(zeropage.free.isEmpty()) {
                             break
                         } else {
-                            val numElements = numArrayElements(variable)
                             val result = zeropage.allocate(
-                                variable.scopedname,
-                                variable.type,
-                                variable.scope,
-                                numElements,
-                                variable.initialValue,
+                                variable.scopedName,
+                                variable.dt,
+                                variable.length,
                                 variable.position,
                                 errors
                             )
@@ -118,49 +121,17 @@ internal class VariableAllocator(private val vars: IVariablesAndConsts,
         println("  zeropage free space: ${zeropage.free.size} bytes")
     }
 
-    internal fun isZpVar(scopedName: List<String>) = scopedName in zeropage.allocatedVariables
-
-    private fun numArrayElements(variable: IVariablesAndConsts.StaticVariable) =
-        when(variable.type) {
-            DataType.STR -> (variable.initialValue as StringLiteral).value.length
-            in ArrayDatatypes -> variable.arraysize!!
-            else -> null
+    private fun collectAllVariables(st: SymbolTable): Collection<StStaticVariable> {
+        val vars = mutableListOf<StStaticVariable>()
+        fun collect(node: StNode) {
+            for(child in node.children) {
+                if(child.value.type == StNodeType.STATICVAR)
+                    vars.add(child.value as StStaticVariable)
+                else
+                    collect(child.value)
+            }
         }
-
-    internal fun subroutineExtra(sub: Subroutine): SubroutineExtraAsmInfo {
-        var extra = subroutineExtras[sub]
-        return if(extra==null) {
-            extra = SubroutineExtraAsmInfo()
-            subroutineExtras[sub] = extra
-            extra
-        }
-        else
-            extra
-    }
-
-    internal fun getFloatAsmConst(number: Double): String {
-        val asmName = globalFloatConsts[number]
-        if(asmName!=null)
-            return asmName
-
-        val newName = "prog8_float_const_${globalFloatConsts.size}"
-        globalFloatConsts[number] = newName
-        return newName
+        collect(st)
+        return vars
     }
 }
-
-/**
- * This class contains various attributes that influence the assembly code generator.
- * Conceptually it should be part of any INameScope.
- * But because the resulting code only creates "real" scopes on a subroutine level,
- * it's more consistent to only define these attributes on a Subroutine node.
- */
-internal class SubroutineExtraAsmInfo {
-    var usedRegsaveA = false
-    var usedRegsaveX = false
-    var usedRegsaveY = false
-    var usedFloatEvalResultVar1 = false
-    var usedFloatEvalResultVar2 = false
-
-    val extraVars = mutableListOf<Triple<DataType, String, UInt?>>()
-}

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

@@ -1,12 +1,10 @@
 package prog8.codegen.cpu6502.assignment
 
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
+import prog8.code.core.*
 import prog8.codegen.cpu6502.AsmGen
-import prog8.compilerinterface.AssemblyError
-import prog8.compilerinterface.IMemSizer
 
 
 internal enum class TargetStorageKind {

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

@@ -1,15 +1,12 @@
 package prog8.codegen.cpu6502.assignment
 
 import prog8.ast.Program
-import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
-import prog8.ast.toHex
+import prog8.code.core.*
 import prog8.codegen.cpu6502.AsmGen
 import prog8.codegen.cpu6502.VariableAllocator
-import prog8.compilerinterface.AssemblyError
-import prog8.compilerinterface.CpuType
-import prog8.compilerinterface.builtinFunctionReturnType
+import prog8.compiler.builtinFunctionReturnType
 
 
 internal class AssignmentAsmGen(private val program: Program, 
@@ -336,154 +333,87 @@ internal class AssignmentAsmGen(private val program: Program,
 
     private fun containmentCheckIntoA(containment: ContainmentCheck) {
         val elementDt = containment.element.inferType(program)
-        val range = containment.iterable as? RangeExpression
-        if(range!=null) {
-            val constRange = range.toConstantIntegerRange()
-            if(constRange!=null)
-                return containmentCheckIntoA(containment.element, elementDt.getOr(DataType.UNDEFINED), constRange.toList())
-            throw AssemblyError("non const range containment check not supported")
-        }
         val variable = (containment.iterable as? IdentifierReference)?.targetVarDecl(program)
-        if(variable!=null) {
-            if(elementDt istype DataType.FLOAT)
-                throw AssemblyError("containment check of floats not supported")
-            if(variable.origin!=VarDeclOrigin.USERCODE) {
-                when(variable.datatype) {
-                    DataType.STR -> {
-                        require(elementDt.isBytes)
-                        val stringVal = variable.value as StringLiteral
-                        if(stringVal.value.length > ContainmentCheck.max_inlined_string_length) {
-                            // use subroutine
-                            val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
-                            assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
-                            assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
-                            asmgen.out("  ldy  #${stringVal.value.length}")
-                            asmgen.out("  jsr  prog8_lib.containment_bytearray")
-                            return
-                        } else {
-                            // inline cmp table
-                            val encoded = program.encoding.encodeString(stringVal.value, stringVal.encoding)
-                            return containmentCheckIntoA(containment.element, elementDt.getOr(DataType.UNDEFINED), encoded.map { it.toInt() })
-                        }
-                    }
-                    DataType.ARRAY_F -> {
-                        // require(elementDt istype DataType.FLOAT)
-                        throw AssemblyError("containment check of floats not supported")
-                    }
-                    in ArrayDatatypes -> {
-                        require(elementDt.isInteger)
-                        val arrayVal = variable.value as ArrayLiteral
-                        val dt = elementDt.getOr(DataType.UNDEFINED)
-                        if(arrayVal.value.size > ContainmentCheck.max_inlined_string_length) {
-                            // use subroutine
-                            val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
-                            when(dt) {
-                                in ByteDatatypes -> {
-                                    assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
-                                    assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
-                                    asmgen.out("  ldy  #${arrayVal.value.size}")
-                                    asmgen.out("  jsr  prog8_lib.containment_bytearray")
-                                }
-                                in WordDatatypes -> {
-                                    assignExpressionToVariable(containment.element, "P8ZP_SCRATCH_W1", elementDt.getOr(DataType.UNDEFINED), containment.definingSubroutine)
-                                    assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W2"), varname)
-                                    asmgen.out("  ldy  #${arrayVal.value.size}")
-                                    asmgen.out("  jsr  prog8_lib.containment_wordarray")
-                                }
-                                else -> throw AssemblyError("invalid dt")
-                            }
-                            return
-                        } else {
-                            // inline cmp table
-                            val values = arrayVal.value.map { it.constValue(program)!!.number.toInt() }
-                            return containmentCheckIntoA(containment.element, dt, values)
-                        }
-                    }
-                    else -> throw AssemblyError("invalid dt")
-                }
-            }
-            val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
+            ?: throw AssemblyError("invalid containment iterable type")
+
+        if(elementDt istype DataType.FLOAT)
+            throw AssemblyError("containment check of floats not supported")
+        if(variable.origin!=VarDeclOrigin.USERCODE) {
             when(variable.datatype) {
                 DataType.STR -> {
-                    // use subroutine
-                    assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
-                    assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
+                    require(elementDt.isBytes)
                     val stringVal = variable.value as StringLiteral
+                    val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
+                    assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
+                    asmgen.saveRegisterLocal(CpuRegister.A, containment.definingSubroutine!!)
+                    assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
+                    asmgen.restoreRegisterLocal(CpuRegister.A)
                     asmgen.out("  ldy  #${stringVal.value.length}")
                     asmgen.out("  jsr  prog8_lib.containment_bytearray")
                     return
                 }
-                DataType.ARRAY_F -> throw AssemblyError("containment check of floats not supported")
-                DataType.ARRAY_B, DataType.ARRAY_UB -> {
-                    val arrayVal = variable.value as ArrayLiteral
-                    assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
-                    assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
-                    asmgen.out("  ldy  #${arrayVal.value.size}")
-                    asmgen.out("  jsr  prog8_lib.containment_bytearray")
-                    return
+                DataType.ARRAY_F -> {
+                    // require(elementDt istype DataType.FLOAT)
+                    throw AssemblyError("containment check of floats not supported")
                 }
-                DataType.ARRAY_W, DataType.ARRAY_UW -> {
+                in ArrayDatatypes -> {
+                    require(elementDt.isInteger)
                     val arrayVal = variable.value as ArrayLiteral
-                    assignExpressionToVariable(containment.element, "P8ZP_SCRATCH_W1", elementDt.getOr(DataType.UNDEFINED), containment.definingSubroutine)
-                    assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W2"), varname)
-                    asmgen.out("  ldy  #${arrayVal.value.size}")
-                    asmgen.out("  jsr  prog8_lib.containment_wordarray")
+                    val dt = elementDt.getOr(DataType.UNDEFINED)
+                    val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
+                    when(dt) {
+                        in ByteDatatypes -> {
+                            assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
+                            asmgen.saveRegisterLocal(CpuRegister.A, containment.definingSubroutine!!)
+                            assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
+                            asmgen.restoreRegisterLocal(CpuRegister.A)
+                            asmgen.out("  ldy  #${arrayVal.value.size}")
+                            asmgen.out("  jsr  prog8_lib.containment_bytearray")
+                        }
+                        in WordDatatypes -> {
+                            assignExpressionToVariable(containment.element, "P8ZP_SCRATCH_W1", elementDt.getOr(DataType.UNDEFINED), containment.definingSubroutine)
+                            assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W2"), varname)
+                            asmgen.out("  ldy  #${arrayVal.value.size}")
+                            asmgen.out("  jsr  prog8_lib.containment_wordarray")
+                        }
+                        else -> throw AssemblyError("invalid dt")
+                    }
                     return
                 }
                 else -> throw AssemblyError("invalid dt")
             }
         }
-        val stringVal = containment.iterable as? StringLiteral
-        if(stringVal!=null) {
-            require(elementDt.isBytes)
-            if(stringVal.value.length > ContainmentCheck.max_inlined_string_length)
-                throw AssemblyError("string should have been inlined in if it was this long")
-            val encoded = program.encoding.encodeString(stringVal.value, stringVal.encoding)
-            return containmentCheckIntoA(containment.element, elementDt.getOr(DataType.UNDEFINED), encoded.map { it.toInt() })
-        }
-        val arrayVal = containment.iterable as? ArrayLiteral
-        if(arrayVal!=null) {
-            require(elementDt.isInteger)
-            if(arrayVal.value.size > ContainmentCheck.max_inlined_string_length)
-                throw AssemblyError("array should have been inlined in if it was this long")
-            val values = arrayVal.value.map { it.constValue(program)!!.number.toInt() }
-            return containmentCheckIntoA(containment.element, elementDt.getOr(DataType.UNDEFINED), values)
-        }
-
-        throw AssemblyError("invalid containment iterable type")
-    }
-
-    private fun containmentCheckIntoA(element: Expression, dt: DataType, values: List<Number>) {
-        if(values.size<2)
-            throw AssemblyError("containment check against 0 or 1 values should have been optimized away")
-        val containsLabel = asmgen.makeLabel("contains")
-        when(dt) {
-            in ByteDatatypes -> {
-                asmgen.assignExpressionToRegister(element, RegisterOrPair.A, dt==DataType.BYTE)
-                for (value in values) {
-                    asmgen.out("  cmp  #$value |  beq  +")
-                }
-                asmgen.out("""
-                    lda  #0
-                    beq  ++
-+                   lda  #1
-+""")
+        val varname = asmgen.asmVariableName(containment.iterable as IdentifierReference)
+        when(variable.datatype) {
+            DataType.STR -> {
+                // use subroutine
+                assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
+                asmgen.saveRegisterLocal(CpuRegister.A, containment.definingSubroutine!!)
+                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
+                asmgen.restoreRegisterLocal(CpuRegister.A)
+                val stringVal = variable.value as StringLiteral
+                asmgen.out("  ldy  #${stringVal.value.length}")
+                asmgen.out("  jsr  prog8_lib.containment_bytearray")
+                return
             }
-            in WordDatatypes -> {
-                asmgen.assignExpressionToRegister(element, RegisterOrPair.AY, dt==DataType.WORD)
-                for (value in values) {
-                    asmgen.out("""
-                        cmp  #<$value
-                        bne  +
-                        cpy  #>$value
-                        beq  $containsLabel
-+""")
-                }
-                asmgen.out("""
-                    lda  #0
-                    beq  +
-$containsLabel      lda  #1
-+""")
+            DataType.ARRAY_F -> throw AssemblyError("containment check of floats not supported")
+            DataType.ARRAY_B, DataType.ARRAY_UB -> {
+                val arrayVal = variable.value as ArrayLiteral
+                assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
+                asmgen.saveRegisterLocal(CpuRegister.A, containment.definingSubroutine!!)
+                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W1"), varname)
+                asmgen.restoreRegisterLocal(CpuRegister.A)
+                asmgen.out("  ldy  #${arrayVal.value.size}")
+                asmgen.out("  jsr  prog8_lib.containment_bytearray")
+                return
+            }
+            DataType.ARRAY_W, DataType.ARRAY_UW -> {
+                val arrayVal = variable.value as ArrayLiteral
+                assignExpressionToVariable(containment.element, "P8ZP_SCRATCH_W1", elementDt.getOr(DataType.UNDEFINED), containment.definingSubroutine)
+                assignAddressOf(AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.UWORD, containment.definingSubroutine, "P8ZP_SCRATCH_W2"), varname)
+                asmgen.out("  ldy  #${arrayVal.value.size}")
+                asmgen.out("  jsr  prog8_lib.containment_wordarray")
+                return
             }
             else -> throw AssemblyError("invalid dt")
         }

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

@@ -1,14 +1,12 @@
 package prog8.codegen.cpu6502.assignment
 
 import prog8.ast.Program
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.Subroutine
-import prog8.ast.toHex
+import prog8.code.core.*
 import prog8.codegen.cpu6502.AsmGen
 import prog8.codegen.cpu6502.VariableAllocator
-import prog8.compilerinterface.AssemblyError
-import prog8.compilerinterface.CpuType
 
 
 internal class AugmentableAssignmentAsmGen(private val program: Program,
@@ -1592,14 +1590,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         asmgen.assignExpressionToRegister(value, RegisterOrPair.FAC1)
         asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
-            "**" -> {
-                asmgen.out("""
-                    lda  #<$name
-                    ldy  #>$name
-                    jsr  floats.CONUPK
-                    jsr  floats.FPWRT
-                """)
-            }
             "+" -> {
                 asmgen.out("""
                     lda  #<$name
@@ -1646,28 +1636,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         val otherName = asmgen.asmVariableName(ident)
         asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
-            "**" -> {
-                if(asmgen.haveFPWRcall()) {
-                    asmgen.out("""
-                        lda  #<$name
-                        ldy  #>$name
-                        jsr  floats.CONUPK
-                        lda  #<$otherName
-                        ldy  #>$otherName
-                        jsr  floats.FPWR
-                    """)
-                } else
-                    // cx16 doesn't have FPWR() only FPWRT()
-                    asmgen.out("""
-                        lda  #<$name
-                        ldy  #>$name
-                        jsr  floats.CONUPK
-                        lda  #<$otherName
-                        ldy  #>$otherName
-                        jsr  floats.MOVFM
-                        jsr  floats.FPWRT
-                    """)
-            }
             "+" -> {
                 asmgen.out("""
                     lda  #<$name
@@ -1723,28 +1691,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
         val constValueName = allocator.getFloatAsmConst(value)
         asmgen.saveRegisterLocal(CpuRegister.X, scope)
         when (operator) {
-            "**" -> {
-                if(asmgen.haveFPWRcall()) {
-                    asmgen.out("""
-                        lda  #<$name
-                        ldy  #>$name
-                        jsr  floats.CONUPK
-                        lda  #<$constValueName
-                        ldy  #>$constValueName
-                        jsr  floats.FPWR
-                    """)
-                } else
-                    // cx16 doesn't have FPWR() only FPWRT()
-                    asmgen.out("""
-                        lda  #<$name
-                        ldy  #>$name
-                        jsr  floats.CONUPK
-                        lda  #<$constValueName
-                        ldy  #>$constValueName
-                        jsr  floats.MOVFM
-                        jsr  floats.FPWRT
-                    """)
-            }
             "+" -> {
                 if (value == 0.0)
                     return

codeGenExperimental/build.gradle

@@ -24,10 +24,12 @@ compileTestKotlin {
 }
 
 dependencies {
-    implementation project(':compilerAst')
+    implementation project(':codeAst')
+    implementation project(':codeCore')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.12"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
+
 }
 
 sourceSets {

codeGenExperimental/codeGenExperimental.iml

@@ -9,8 +9,8 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="module" module-name="compilerAst" />
-    <orderEntry type="module" module-name="compilerInterfaces" />
     <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
+    <orderEntry type="module" module-name="codeAst" />
+    <orderEntry type="module" module-name="codeCore" />
   </component>
 </module>

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

@@ -0,0 +1,39 @@
+package prog8.codegen.experimental
+
+import prog8.code.SymbolTable
+import prog8.code.ast.PtProgram
+import prog8.code.core.CompilationOptions
+import prog8.code.core.IAssemblyGenerator
+import prog8.code.core.IAssemblyProgram
+import prog8.code.core.IErrorReporter
+
+/*
+
+    NOTE: The goal is to keep the dependencies as lean as possible! For now, we depend only on:
+         - codeAst (the 'lean' new AST and the SymbolTable)
+         - codeCore (various base enums and interfaces)
+
+    This *should* be enough to build a complete code generator with. But we'll see :)
+
+ */
+
+
+class AsmGen(internal val program: PtProgram,
+             internal val symbolTable: SymbolTable,
+             internal val options: CompilationOptions,
+             internal val errors: IErrorReporter
+): IAssemblyGenerator {
+
+    override fun compileToAssembly(): IAssemblyProgram? {
+
+        println("\n** experimental code generator **\n")
+
+        println("Writing AST into XML form...")
+        val xmlConv = AstToXmlConverter(program, symbolTable, options)
+        xmlConv.writeXml()
+
+        println("..todo: create assembly program into ${options.outputDir.toAbsolutePath()}..")
+
+        return AssemblyProgram("dummy")
+    }
+}

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

@@ -1,13 +1,13 @@
-package prog8.codegen.experimental6502
+package prog8.codegen.experimental
 
-import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.IAssemblyProgram
+import prog8.code.core.CompilationOptions
+import prog8.code.core.IAssemblyProgram
 
 
 internal class AssemblyProgram(override val name: String) : IAssemblyProgram
 {
     override fun assemble(options: CompilationOptions): Boolean {
         println("..todo: assemble code into binary..")
-        return false
+        return true
     }
 }

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

@@ -0,0 +1,667 @@
+package prog8.codegen.experimental
+
+import prog8.code.*
+import prog8.code.ast.*
+import prog8.code.core.*
+import javax.xml.stream.XMLOutputFactory
+import kotlin.io.path.Path
+import kotlin.io.path.absolutePathString
+import kotlin.io.path.div
+
+/*
+
+    NOTE: The goal is to keep the dependencies as lean as possible! For now, we depend only on:
+         - codeAst (the 'lean' new AST and the SymbolTable)
+         - codeCore (various base enums and interfaces)
+
+    This *should* be enough to build a complete code generator with. But we'll see :)
+
+ */
+
+
+class AstToXmlConverter(internal val program: PtProgram,
+                        internal val symbolTable: SymbolTable,
+                        internal val options: CompilationOptions
+) {
+
+    private lateinit var xml: IndentingXmlWriter
+
+    fun writeXml() {
+        val writer = (options.outputDir / Path(program.name+"-ast.xml")).toFile().printWriter()
+        xml = IndentingXmlWriter(XMLOutputFactory.newFactory().createXMLStreamWriter(writer))
+        xml.doc()
+        xml.elt("program")
+        xml.attr("name", program.name)
+        xml.startChildren()
+        writeOptions(options)
+        program.children.forEach { writeNode(it) }
+        writeSymboltable(symbolTable)
+        xml.endElt()
+        xml.endDoc()
+        xml.close()
+    }
+
+    private fun writeSymboltable(st: SymbolTable) {
+        xml.elt("symboltable")
+        xml.startChildren()
+        st.flat.forEach{ (name, entry) ->
+            xml.elt("entry")
+            xml.attr("name", name.joinToString("."))
+            xml.attr("type", entry.type.name)
+            xml.startChildren()
+            writeStNode(entry)
+            xml.endElt()
+        }
+        xml.endElt()
+    }
+
+    private fun writeStNode(node: StNode) {
+        when(node.type) {
+            StNodeType.GLOBAL,
+            StNodeType.LABEL,
+            StNodeType.BLOCK,
+            StNodeType.BUILTINFUNC,
+            StNodeType.SUBROUTINE -> {/* no additional info*/}
+            StNodeType.ROMSUB -> {
+                node as StRomSub
+                xml.elt("romsub")
+                xml.attr("address", node.address.toString())
+                xml.endElt()
+            }
+            StNodeType.STATICVAR -> {
+                node as StStaticVariable
+                xml.elt("var")
+                xml.attr("type", node.dt.name)
+                xml.attr("zpwish", node.zpwish.name)
+                if(node.length!=null)
+                    xml.attr("length", node.length.toString())
+                if(node.initialNumericValue!=null || node.initialArrayValue!=null || node.initialStringValue!=null) {
+                    xml.startChildren()
+                    if(node.initialNumericValue!=null) {
+                        writeNumber(node.dt, node.initialNumericValue!!)
+                    }
+                    if(node.initialStringValue!=null) {
+                        xml.writeTextNode(
+                            "string",
+                            listOf(Pair("encoding", node.initialStringValue!!.second.name)),
+                            node.initialStringValue!!.first,
+                            false
+                        )
+                    }
+                    if(node.initialArrayValue!=null) {
+                        xml.elt("array")
+                        xml.startChildren()
+                        val eltDt = ArrayToElementTypes.getValue(node.dt)
+                        node.initialArrayValue!!.forEach {
+                            if(it.number!=null) {
+                                writeNumber(eltDt, it.number!!)
+                            }
+                            if(it.addressOf!=null) {
+                                xml.elt("addressof")
+                                xml.attr("symbol", it.addressOf!!.joinToString("."))
+                                xml.endElt()
+                            }
+                        }
+                        xml.endElt()
+                    }
+                }
+                xml.endElt()
+            }
+            StNodeType.MEMVAR -> {
+                node as StMemVar
+                xml.writeTextNode("memvar",
+                    listOf(Pair("type", node.dt.name)),
+                    node.address.toString(),
+                    false)
+            }
+            StNodeType.CONSTANT -> {
+                node as StConstant
+                xml.writeTextNode("const",
+                    listOf(Pair("type", node.dt.name)),
+                    intOrDouble(node.dt, node.value).toString(),
+                    false)
+            }
+        }
+    }
+
+    private fun writeOptions(options: CompilationOptions) {
+        xml.elt("options")
+        xml.attr("target", options.compTarget.name)
+        xml.attr("output", options.output.name)
+        xml.attr("launcher", options.launcher.name)
+        xml.attr("zeropage", options.zeropage.name)
+        xml.attr("loadaddress", options.loadAddress.toString())
+        xml.attr("floatsenabled", options.floats.toString())
+        xml.attr("nosysinit", options.noSysInit.toString())
+        xml.attr("dontreinitglobals", options.dontReinitGlobals.toString())
+        xml.attr("optimize", options.optimize.toString())
+        if(options.zpReserved.isNotEmpty()) {
+            xml.startChildren()
+            options.zpReserved.forEach {
+                xml.elt("zpreserved")
+                xml.attr("from", it.first.toString())
+                xml.attr("to", it.last.toString())
+                xml.endElt()
+            }
+        }
+        xml.endElt()
+    }
+
+    private fun writeNode(it: PtNode) {
+        when(it) {
+            is PtBlock -> write(it)
+            is PtSub -> write(it)
+            is PtVariable -> write(it)
+            is PtAssignment -> write(it)
+            is PtConstant -> write(it)
+            is PtAsmSub -> write(it)
+            is PtAddressOf -> write(it)
+            is PtArrayIndexer -> write(it)
+            is PtArray -> write(it)
+            is PtBinaryExpression -> write(it)
+            is PtBuiltinFunctionCall -> write(it)
+            is PtConditionalBranch -> write(it)
+            is PtContainmentCheck -> write(it)
+            is PtForLoop -> write(it)
+            is PtFunctionCall -> write(it)
+            is PtIdentifier -> write(it)
+            is PtIfElse -> write(it)
+            is PtInlineAssembly -> write(it)
+            is PtIncludeBinary -> write(it)
+            is PtJump -> write(it)
+            is PtMemoryByte -> write(it)
+            is PtMemMapped -> write(it)
+            is PtNumber -> write(it)
+            is PtPipe -> write(it)
+            is PtPostIncrDecr -> write(it)
+            is PtPrefix -> write(it)
+            is PtRange -> write(it)
+            is PtRepeatLoop -> write(it)
+            is PtReturn -> write(it)
+            is PtString -> write(it)
+            is PtTypeCast -> write(it)
+            is PtWhen -> write(it)
+            is PtWhenChoice -> write(it)
+            is PtLabel -> write(it)
+            is PtNop -> {}
+            is PtBreakpoint -> write(it)
+            is PtScopeVarsDecls -> write(it)
+            is PtNodeGroup -> it.children.forEach { writeNode(it) }
+            else -> TODO("$it")
+        }
+    }
+
+    private fun write(vars: PtScopeVarsDecls) {
+        xml.elt("vars")
+        xml.startChildren()
+        vars.children.forEach { writeNode(it) }
+        xml.endElt()
+    }
+
+    private fun write(breakPt: PtBreakpoint) {
+        xml.elt("breakpoint")
+        xml.pos(breakPt.position)
+        xml.endElt()
+    }
+
+    private fun write(pipe: PtPipe) {
+        xml.elt("pipe")
+        xml.attr("type", pipe.type.name)
+        xml.startChildren()
+        pipe.children.forEach { writeNode(it) }
+        xml.endElt()
+    }
+
+    private fun write(array: PtArray) {
+        xml.elt("array")
+        xml.attr("type", array.type.name)
+        xml.startChildren()
+        array.children.forEach { writeNode(it) }
+        xml.endElt()
+    }
+
+    private fun write(prefix: PtPrefix) {
+        xml.elt("prefix")
+        xml.attr("op", prefix.operator)
+        xml.attr("type", prefix.type.name)
+        xml.startChildren()
+        xml.elt("value")
+        xml.startChildren()
+        writeNode(prefix.value)
+        xml.endElt()
+        xml.endElt()
+    }
+
+    private fun write(string: PtString) =
+        xml.writeTextNode("string", listOf(Pair("encoding", string.encoding.name)), string.value, false)
+
+    private fun write(rept: PtRepeatLoop) {
+        xml.elt("repeat")
+        xml.pos(rept.position)
+        xml.startChildren()
+        xml.elt("count")
+        xml.startChildren()
+        writeNode(rept.count)
+        xml.endElt()
+        writeNode(rept.statements)
+        xml.endElt()
+    }
+
+    private fun write(branch: PtConditionalBranch) {
+        xml.elt("conditionalbranch")
+        xml.attr("condition", branch.condition.name)
+        xml.pos(branch.position)
+        xml.startChildren()
+        xml.elt("true")
+        xml.startChildren()
+        writeNode(branch.trueScope)
+        xml.endElt()
+        if(branch.falseScope.children.isNotEmpty()) {
+            xml.elt("false")
+            xml.startChildren()
+            writeNode(branch.falseScope)
+            xml.endElt()
+        }
+        xml.endElt()
+    }
+
+    private fun write(check: PtContainmentCheck) {
+        xml.elt("containment")
+        xml.attr("type", check.type.name)
+        xml.startChildren()
+        xml.elt("element")
+        xml.startChildren()
+        writeNode(check.children[0])
+        xml.endElt()
+        xml.elt("iterable")
+        xml.startChildren()
+        writeNode(check.children[1])
+        xml.endElt()
+        xml.endElt()
+    }
+
+    private fun write(range: PtRange) {
+        xml.elt("range")
+        xml.attr("type", range.type.name)
+        xml.startChildren()
+        xml.elt("from")
+        xml.startChildren()
+        writeNode(range.from)
+        xml.endElt()
+        xml.elt("to")
+        xml.startChildren()
+        writeNode(range.to)
+        xml.endElt()
+        xml.elt("step")
+        xml.startChildren()
+        writeNode(range.step)
+        xml.endElt()
+        xml.endElt()
+    }
+
+    private fun write(forLoop: PtForLoop) {
+        xml.elt("for")
+        xml.attr("loopvar", strTargetName(forLoop.variable))
+        xml.pos(forLoop.position)
+        xml.startChildren()
+        xml.elt("iterable")
+        xml.startChildren()
+        writeNode(forLoop.iterable)
+        xml.endElt()
+        writeNode(forLoop.statements)
+        xml.endElt()
+    }
+
+    private fun write(membyte: PtMemoryByte) {
+        xml.elt("membyte")
+        xml.attr("type", membyte.type.name)
+        xml.startChildren()
+        xml.elt("address")
+        xml.startChildren()
+        writeNode(membyte.address)
+        xml.endElt()
+        xml.endElt()
+    }
+
+    private fun write(whenStmt: PtWhen) {
+        xml.elt("when")
+        xml.pos(whenStmt.position)
+        xml.startChildren()
+        xml.elt("value")
+        xml.startChildren()
+        writeNode(whenStmt.value)
+        xml.endElt()
+        xml.elt("choices")
+        xml.startChildren()
+        writeNode(whenStmt.choices)
+        xml.endElt()
+        xml.endElt()
+    }
+
+    private fun write(choice: PtWhenChoice) {
+        xml.elt("choice")
+        if(choice.isElse) {
+            xml.attr("else", "true")
+            xml.startChildren()
+        } else {
+            xml.startChildren()
+            xml.elt("values")
+            xml.startChildren()
+            writeNode(choice.values)
+            xml.endElt()
+        }
+        writeNode(choice.statements)
+        xml.endElt()
+    }
+
+    private fun write(inlineAsm: PtInlineAssembly) {
+        xml.elt("assembly")
+        xml.pos(inlineAsm.position)
+        xml.startChildren()
+        xml.writeTextNode("code", emptyList(), inlineAsm.assembly)
+        xml.endElt()
+    }
+
+    private fun write(inlineBinary: PtIncludeBinary) {
+        xml.elt("binary")
+        xml.attr("filename", inlineBinary.file.absolutePathString())
+        if(inlineBinary.offset!=null)
+            xml.attr("offset", inlineBinary.offset!!.toString())
+        if(inlineBinary.length!=null)
+            xml.attr("length", inlineBinary.length!!.toString())
+        xml.pos(inlineBinary.position)
+        xml.endElt()
+    }
+
+    private fun write(fcall: PtBuiltinFunctionCall) {
+        xml.elt("builtinfcall")
+        xml.attr("name", fcall.name)
+        if(fcall.void)
+            xml.attr("type", "VOID")
+        else
+            xml.attr("type", fcall.type.name)
+        xml.startChildren()
+        fcall.children.forEach { writeNode(it) }
+        xml.endElt()
+    }
+
+    private fun write(cast: PtTypeCast) {
+        xml.elt("cast")
+        xml.attr("type", cast.type.name)
+        xml.startChildren()
+        writeNode(cast.value)
+        xml.endElt()
+    }
+
+    private fun write(aix: PtArrayIndexer) {
+        xml.elt("arrayindexed")
+        xml.attr("type", aix.type.name)
+        xml.startChildren()
+        write(aix.variable)
+        writeNode(aix.index)
+        xml.endElt()
+    }
+
+    private fun write(binexpr: PtBinaryExpression) {
+        xml.elt("binexpr")
+        xml.attr("op", binexpr.operator)
+        xml.attr("type", binexpr.type.name)
+        xml.startChildren()
+        writeNode(binexpr.left)
+        writeNode(binexpr.right)
+        xml.endElt()
+    }
+
+    private fun write(addrof: PtAddressOf) {
+        xml.elt("addressof")
+        xml.attr("symbol", strTargetName(addrof.identifier))
+        xml.endElt()
+    }
+
+    private fun write(fcall: PtFunctionCall) {
+        xml.elt("fcall")
+        xml.attr("name", strTargetName(fcall))
+        if(fcall.void)
+            xml.attr("type", "VOID")
+        else
+            xml.attr("type", fcall.type.name)
+        xml.pos(fcall.position)
+        xml.startChildren()
+        fcall.children.forEach { writeNode(it) }
+        xml.endElt()
+    }
+
+    private fun write(number: PtNumber) = writeNumber(number.type, number.number)
+
+    private fun writeNumber(type: DataType, number: Double) =
+        xml.writeTextNode("number", listOf(Pair("type", type.name)), intOrDouble(type, number).toString(), false)
+
+    private fun write(symbol: PtIdentifier) {
+        xml.elt("symbol")
+        xml.attr("name", strTargetName(symbol))
+        xml.attr("type", symbol.type.name)
+        xml.endElt()
+    }
+
+    private fun write(assign: PtAssignment) {
+        xml.elt("assign")
+        xml.attr("aug", assign.augmentable.toString())
+        xml.pos(assign.position)
+        xml.startChildren()
+        write(assign.target)
+        writeNode(assign.value)
+        xml.endElt()
+    }
+
+    private fun write(ifElse: PtIfElse) {
+        xml.elt("ifelse")
+        xml.pos(ifElse.position)
+        xml.startChildren()
+        xml.elt("condition")
+        xml.startChildren()
+        writeNode(ifElse.condition)
+        xml.endElt()
+        xml.elt("true")
+        xml.pos(ifElse.ifScope.position)
+        xml.startChildren()
+        writeNode(ifElse.ifScope)
+        xml.endElt()
+        if(ifElse.elseScope.children.isNotEmpty()) {
+            xml.elt("false")
+            xml.pos(ifElse.elseScope.position)
+            xml.startChildren()
+            writeNode(ifElse.elseScope)
+            xml.endElt()
+        }
+        xml.endElt()
+    }
+
+    private fun write(ret: PtReturn) {
+        xml.elt("return")
+        if(ret.hasValue) {
+            xml.startChildren()
+            writeNode(ret.value!!)
+        }
+        xml.endElt()
+    }
+
+    private fun write(incdec: PtPostIncrDecr) {
+        if(incdec.operator=="++") xml.elt("inc") else xml.elt("dec")
+        xml.startChildren()
+        write(incdec.target)
+        xml.endElt()
+    }
+
+    private fun write(label: PtLabel) {
+        xml.elt("label")
+        xml.attr("name", label.scopedName.joinToString("."))
+        xml.pos(label.position)
+        xml.endElt()
+    }
+
+    private fun write(block: PtBlock) {
+        xml.elt("block")
+        xml.attr("name", block.scopedName.joinToString("."))
+        if(block.address!=null)
+            xml.attr("address", block.address!!.toString())
+        xml.attr("library", block.library.toString())
+        xml.pos(block.position)
+        xml.startChildren()
+        block.children.forEach { writeNode(it) }
+        xml.endElt()
+    }
+
+    private fun write(memMapped: PtMemMapped) {
+        xml.writeTextNode("memvar",
+            listOf(
+                Pair("name", memMapped.scopedName.joinToString(".")),
+                Pair("type", memMapped.type.name)
+            ),
+            memMapped.address.toString(),
+            false)
+    }
+
+    private fun write(target: PtAssignTarget) {
+        xml.elt("target")
+        xml.startChildren()
+        if(target.identifier!=null) {
+            writeNode(target.identifier!!)
+        } else if(target.memory!=null) {
+            writeNode(target.memory!!)
+        } else if(target.array!=null) {
+            writeNode(target.array!!)
+        } else
+            throw InternalCompilerException("weird assign target")
+        xml.endElt()
+    }
+
+    private fun write(jump: PtJump) {
+        xml.elt("jump")
+        if(jump.identifier!=null) xml.attr("symbol", strTargetName(jump.identifier!!))
+        else if(jump.address!=null) xml.attr("address", jump.address!!.toString())
+        else if(jump.generatedLabel!=null) xml.attr("label", jump.generatedLabel!!)
+        else
+            throw InternalCompilerException("weird jump target")
+        xml.endElt()
+    }
+
+    private fun write(sub: PtSub) {
+        xml.elt("sub")
+        xml.attr("name", sub.scopedName.joinToString("."))
+        if(sub.inline)
+            xml.attr("inline", "true")
+        xml.attr("returntype", sub.returntype?.toString() ?: "VOID")
+        xml.pos(sub.position)
+        xml.startChildren()
+        if(sub.parameters.isNotEmpty()) {
+            xml.elt("parameters")
+            xml.startChildren()
+            sub.parameters.forEach { write(it) }
+            xml.endElt()
+        }
+        sub.children.forEach { writeNode(it) }
+        xml.endElt()
+    }
+
+    private fun write(parameter: PtSubroutineParameter, registerOrStatusflag: RegisterOrStatusflag? = null) {
+        xml.elt("param")
+        xml.attr("name", parameter.name)
+        xml.attr("type", parameter.type.name)
+        if(registerOrStatusflag?.statusflag!=null) {
+            xml.attr("statusflag", registerOrStatusflag.statusflag!!.toString())
+        }
+        if(registerOrStatusflag?.registerOrPair!=null){
+            xml.attr("registers", registerOrStatusflag.registerOrPair!!.name)
+        }
+        xml.endElt()
+    }
+
+    private fun write(asmSub: PtAsmSub) {
+        if(asmSub.address!=null) {
+            xml.elt("romsub")
+            xml.attr("name", asmSub.scopedName.joinToString("."))
+            xml.attr("address", asmSub.address!!.toString())
+            if(asmSub.inline)
+                xml.attr("inline", "true")
+            xml.pos(asmSub.position)
+            xml.startChildren()
+            paramsEtcetera(asmSub)
+            xml.endElt()
+        }
+        else {
+            xml.elt("asmsub")
+            xml.attr("name", asmSub.scopedName.joinToString("."))
+            if(asmSub.inline)
+                xml.attr("inline", "true")
+            xml.pos(asmSub.position)
+            xml.startChildren()
+            paramsEtcetera(asmSub)
+            xml.elt("code")
+            xml.startChildren()
+            asmSub.children.forEach { writeNode(it) }
+            xml.endElt()
+            xml.endElt()
+        }
+    }
+
+    private fun paramsEtcetera(asmSub: PtAsmSub) {
+        if(asmSub.parameters.isNotEmpty()) {
+            xml.elt("parameters")
+            xml.startChildren()
+            asmSub.parameters.forEach { (param, reg) -> write(param, reg) }
+            xml.endElt()
+        }
+        if(asmSub.clobbers.isNotEmpty()) {
+            xml.elt("clobbers")
+            xml.attr("registers", asmSub.clobbers.map {it.name}.joinToString(","))
+            xml.endElt()
+        }
+        if(asmSub.retvalRegisters.isNotEmpty()) {
+            xml.elt("returns")
+            xml.startChildren()
+            asmSub.retvalRegisters.forEach {
+                xml.elt("register")
+                if(it.statusflag!=null)
+                    xml.attr("statusflag", it.statusflag!!.toString())
+                if(it.registerOrPair!=null)
+                    xml.attr("registers", it.registerOrPair!!.toString())
+                xml.endElt()
+            }
+            xml.endElt()
+        }
+    }
+
+    private fun write(constant: PtConstant) {
+        xml.writeTextNode("const",
+            listOf(
+                Pair("name", constant.scopedName.joinToString(".")),
+                Pair("type", constant.type.name)
+            ),
+            intOrDouble(constant.type, constant.value).toString(), false)
+    }
+
+    private fun write(variable: PtVariable) {
+        // the variable declaration nodes are still present in the Ast,
+        // but the Symboltable should be used look up their details.
+        xml.elt("vardecl")
+        xml.attr("name", variable.scopedName.joinToString("."))
+        xml.attr("type", variable.type.name)
+        if(variable.arraySize!=null)
+            xml.attr("arraysize", variable.arraySize.toString())
+        if(variable.value!=null) {
+            // static initialization value
+            xml.startChildren()
+            writeNode(variable.value!!)
+        }
+        xml.endElt()
+    }
+
+
+
+    private fun strTargetName(ident: PtIdentifier): String = ident.targetName.joinToString(".")
+
+    private fun strTargetName(call: PtFunctionCall): String = call.functionName.joinToString(".")
+
+    private fun intOrDouble(type: DataType, value: Double): Number =
+        if(type in IntegerDatatypes) value.toInt() else value
+}

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

@@ -0,0 +1,89 @@
+package prog8.codegen.experimental
+
+import prog8.code.core.Position
+import java.util.*
+import javax.xml.stream.XMLStreamWriter
+
+class IndentingXmlWriter(val xml: XMLStreamWriter): XMLStreamWriter by xml {
+    private var indent = 0
+    private var content = Stack<Boolean>()
+
+    fun doc(version: String? = null) = if(version==null) writeStartDocument() else writeStartDocument(version)
+    fun endDoc() = writeEndDocument()
+    fun elt(name: String) = writeStartElement(name)
+    fun attr(name: String, value: String) = writeAttribute(name, value)
+    fun attrs(attributes: List<Pair<String, String>>) = attributes.forEach { writeAttribute(it.first, it.second) }
+    fun startChildren() {
+        xml.writeCharacters("\n")
+        content.pop()
+        content.push(true)
+    }
+    fun endElt(writeIndent: Boolean=true) = writeEndElement(writeIndent)
+    fun pos(pos: Position) = writeAttribute("src", pos.toString())
+    fun comment(text: String) {
+        writeComment(text)
+        writeCharacters("\n")
+    }
+
+    override fun writeStartDocument() {
+        xml.writeStartDocument()
+        xml.writeCharacters("\n")
+        content.push(true)
+    }
+
+    override fun writeStartDocument(version: String) {
+        xml.writeStartDocument(version)
+        xml.writeCharacters("\n")
+        content.push(true)
+    }
+
+    override fun writeEndDocument() {
+        xml.writeEndDocument()
+        xml.writeCharacters("\n")
+        require(indent==0)
+        require(content.size==1)
+    }
+
+    override fun writeStartElement(name: String) {
+        xml.writeCharacters("  ".repeat(indent))
+        xml.writeStartElement(name)
+        indent++
+        content.push(false)
+    }
+
+    override fun writeStartElement(name: String, ns: String) {
+        xml.writeCharacters("  ".repeat(indent))
+        xml.writeStartElement(name, ns)
+        indent++
+        content.push(false)
+    }
+
+    fun writeEndElement(writeIndents: Boolean) {
+        indent--
+        if(content.pop() && writeIndents)
+            xml.writeCharacters("  ".repeat(indent))
+        xml.writeEndElement()
+        xml.writeCharacters("\n")
+    }
+
+    override fun writeEndElement() = writeEndElement(true)
+
+    override fun writeStartElement(name: String, ns: String, p2: String) {
+        xml.writeCharacters("  ".repeat(indent))
+        xml.writeStartElement(name, ns, p2)
+        indent++
+        content.push(false)
+    }
+
+    fun writeTextNode(name: String, attrs: List<Pair<String, String>>, text: String, cdata: Boolean = true) {
+        xml.writeCharacters("  ".repeat(indent))
+        xml.writeStartElement(name)
+        attrs.forEach { (name, value) -> xml.writeAttribute(name, value) }
+        if(cdata)
+            xml.writeCData(text)
+        else
+            xml.writeCharacters(text)
+        xml.writeEndElement()
+        xml.writeCharacters("\n")
+    }
+}

codeGenExperimental6502/src/prog8/codegen/experimental6502/AsmGen.kt

@@ -1,18 +0,0 @@
-package prog8.codegen.experimental6502
-
-import prog8.ast.Program
-import prog8.compilerinterface.*
-
-class AsmGen(internal val program: Program,
-             internal val errors: IErrorReporter,
-             internal val variables: IVariablesAndConsts,
-             internal val options: CompilationOptions): IAssemblyGenerator {
-
-    override fun compileToAssembly(): IAssemblyProgram? {
-
-        println("\n** experimental 65(c)02 code generator **\n")
-
-        println("..todo: create assembly code into ${options.outputDir.toAbsolutePath()}..")
-        return AssemblyProgram("dummy")
-    }
-}

codeGenTargets/readme-tests.txt

@@ -1,2 +0,0 @@
-Unittests for things in this module are located in the Compiler module instead,
-for convenience sake, and to not spread the test cases around too much.

codeGenTargets/src/prog8/codegen/target/AtariTarget.kt

@@ -1,52 +0,0 @@
-package prog8.codegen.target
-
-import prog8.ast.base.*
-import prog8.ast.expressions.Expression
-import prog8.ast.expressions.StringLiteral
-import prog8.ast.statements.RegisterOrStatusflag
-import prog8.ast.statements.Subroutine
-import prog8.ast.statements.VarDecl
-import prog8.codegen.target.atari.AtariMachineDefinition
-import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder
-import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk
-import prog8.compilerinterface.*
-
-
-class AtariTarget: ICompilationTarget, IStringEncoding by Encoder, IMemSizer {
-    override val name = NAME
-    override val machine = AtariMachineDefinition()
-    override val supportedEncodings = setOf(Encoding.ATASCII)
-    override val defaultEncoding = Encoding.ATASCII
-
-    companion object {
-        const val NAME = "atari"
-    }
-
-    override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
-        asmsub6502ArgsEvalOrder(sub)
-    override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
-        asmsub6502ArgsHaveRegisterClobberRisk(args, paramRegisters)
-
-    override fun memorySize(dt: DataType): Int {
-        return when(dt) {
-            in ByteDatatypes -> 1
-            in WordDatatypes, in PassByReferenceDatatypes -> 2
-            DataType.FLOAT -> 6
-            else -> Int.MIN_VALUE
-        }
-    }
-
-    override fun memorySize(decl: VarDecl): Int {
-        return when(decl.type) {
-            VarDeclType.CONST -> 0
-            VarDeclType.VAR, VarDeclType.MEMORY -> {
-                when(val dt = decl.datatype) {
-                    in NumericDatatypes -> return memorySize(dt)
-                    in ArrayDatatypes -> decl.arraysize!!.constIndex()!! * memorySize(ArrayToElementTypes.getValue(dt))
-                    DataType.STR -> (decl.value as StringLiteral).value.length + 1
-                    else -> 0
-                }
-            }
-        }
-    }
-}

codeGenTargets/src/prog8/codegen/target/C128Target.kt

@@ -1,27 +0,0 @@
-package prog8.codegen.target
-
-import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
-import prog8.ast.statements.Subroutine
-import prog8.codegen.target.c128.C128MachineDefinition
-import prog8.codegen.target.cbm.CbmMemorySizer
-import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder
-import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk
-import prog8.compilerinterface.*
-
-
-class C128Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
-    override val name = NAME
-    override val machine = C128MachineDefinition()
-    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES)
-    override val defaultEncoding = Encoding.PETSCII
-
-    companion object {
-        const val NAME = "c128"
-    }
-
-    override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
-        asmsub6502ArgsEvalOrder(sub)
-    override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
-        asmsub6502ArgsHaveRegisterClobberRisk(args, paramRegisters)
-}

codeGenTargets/src/prog8/codegen/target/C64Target.kt

@@ -1,27 +0,0 @@
-package prog8.codegen.target
-
-import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
-import prog8.ast.statements.Subroutine
-import prog8.codegen.target.c64.C64MachineDefinition
-import prog8.codegen.target.cbm.CbmMemorySizer
-import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder
-import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk
-import prog8.compilerinterface.*
-
-
-class C64Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
-    override val name = NAME
-    override val machine = C64MachineDefinition()
-    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES)
-    override val defaultEncoding = Encoding.PETSCII
-
-    companion object {
-        const val NAME = "c64"
-    }
-
-    override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
-        asmsub6502ArgsEvalOrder(sub)
-    override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
-        asmsub6502ArgsHaveRegisterClobberRisk(args, paramRegisters)
-}

codeGenTargets/src/prog8/codegen/target/Cx16Target.kt

@@ -1,27 +0,0 @@
-package prog8.codegen.target
-
-import prog8.ast.expressions.Expression
-import prog8.ast.statements.RegisterOrStatusflag
-import prog8.ast.statements.Subroutine
-import prog8.codegen.target.cbm.CbmMemorySizer
-import prog8.codegen.target.cbm.asmsub6502ArgsEvalOrder
-import prog8.codegen.target.cbm.asmsub6502ArgsHaveRegisterClobberRisk
-import prog8.codegen.target.cx16.CX16MachineDefinition
-import prog8.compilerinterface.*
-
-
-class Cx16Target: ICompilationTarget, IStringEncoding by Encoder, IMemSizer by CbmMemorySizer {
-    override val name = NAME
-    override val machine = CX16MachineDefinition()
-    override val supportedEncodings = setOf(Encoding.PETSCII, Encoding.SCREENCODES, Encoding.ISO)
-    override val defaultEncoding = Encoding.PETSCII
-
-    companion object {
-        const val NAME = "cx16"
-    }
-
-    override fun asmsubArgsEvalOrder(sub: Subroutine): List<Int> =
-        asmsub6502ArgsEvalOrder(sub)
-    override fun asmsubArgsHaveRegisterClobberRisk(args: List<Expression>, paramRegisters: List<RegisterOrStatusflag>) =
-        asmsub6502ArgsHaveRegisterClobberRisk(args, paramRegisters)
-}

codeGenTargets/src/prog8/codegen/target/cbm/CbmMemorySizer.kt

@@ -1,31 +0,0 @@
-package prog8.codegen.target.cbm
-
-import prog8.ast.base.*
-import prog8.ast.expressions.StringLiteral
-import prog8.ast.statements.VarDecl
-import prog8.compilerinterface.IMemSizer
-
-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 -> Int.MIN_VALUE
-        }
-    }
-
-    override fun memorySize(decl: VarDecl): Int {
-        return when(decl.type) {
-            VarDeclType.CONST -> 0
-            VarDeclType.VAR, VarDeclType.MEMORY -> {
-                when(val dt = decl.datatype) {
-                    in NumericDatatypes -> return memorySize(dt)
-                    in ArrayDatatypes -> decl.arraysize!!.constIndex()!! * memorySize(ArrayToElementTypes.getValue(dt))
-                    DataType.STR -> (decl.value as StringLiteral).value.length + 1
-                    else -> 0
-                }
-            }
-        }
-    }
-}

codeGenVirtual/build.gradle

@@ -24,11 +24,12 @@ compileTestKotlin {
 }
 
 dependencies {
-    implementation project(':compilerInterfaces')
-    implementation project(':compilerAst')
+    implementation project(':virtualmachine')
+    implementation project(':codeAst')
+    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.12"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
 
 }
 

codeGenVirtual/codeGenVirtual.iml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
+    <orderEntry type="module" module-name="codeAst" />
+    <orderEntry type="module" module-name="codeCore" />
+    <orderEntry type="module" module-name="virtualmachine" />
+  </component>
+</module>

codeGenVirtual/src/prog8/codegen/virtual/AssemblyProgram.kt

@@ -0,0 +1,84 @@
+package prog8.codegen.virtual
+
+import prog8.code.core.CompilationOptions
+import prog8.code.core.IAssemblyProgram
+import prog8.vm.Instruction
+import prog8.vm.Opcode
+import prog8.vm.VmDataType
+import java.io.BufferedWriter
+import kotlin.io.path.bufferedWriter
+import kotlin.io.path.div
+
+
+internal class AssemblyProgram(override val name: String,
+                               private val allocations: VariableAllocator
+) : IAssemblyProgram {
+
+    private val globalInits = mutableListOf<VmCodeLine>()
+    private val blocks = mutableListOf<VmCodeChunk>()
+
+    override fun assemble(options: CompilationOptions): Boolean {
+        val outfile = options.outputDir / ("$name.p8virt")
+        println("write code to $outfile")
+        outfile.bufferedWriter().use { out ->
+            allocations.asVmMemory().forEach { (name, alloc) ->
+                out.write("; ${name.joinToString(".")}\n")
+                out.write(alloc + "\n")
+            }
+            out.write("------PROGRAM------\n")
+
+            out.write("; global var inits\n")
+            globalInits.forEach { out.writeLine(it) }
+
+            out.write("; actual program code\n")
+            blocks.asSequence().flatMap { it.lines }.forEach { line->out.writeLine(line) }
+        }
+        return true
+    }
+
+    private fun BufferedWriter.writeLine(line: VmCodeLine) {
+        when(line) {
+            is VmCodeComment -> write("; ${line.comment}\n")
+            is VmCodeInstruction -> {
+                write(line.ins.toString() + "\n")
+            }
+            is VmCodeLabel -> write("_" + line.name.joinToString(".") + ":\n")
+        }
+    }
+
+    fun addGlobalInits(chunk: VmCodeChunk) = globalInits.addAll(chunk.lines)
+    fun addBlock(block: VmCodeChunk) = blocks.add(block)
+}
+
+internal sealed class VmCodeLine
+
+internal class VmCodeInstruction(
+    opcode: Opcode,
+    type: VmDataType?=null,
+    reg1: Int?=null,        // 0-$ffff
+    reg2: Int?=null,        // 0-$ffff
+    reg3: Int?=null,        // 0-$ffff
+    value: Int?=null,       // 0-$ffff
+    symbol: List<String>?=null    // alternative to value
+    ): VmCodeLine() {
+        val ins = Instruction(opcode, type, reg1, reg2, reg3, value, symbol)
+    }
+internal class VmCodeLabel(val name: List<String>): VmCodeLine()
+internal class VmCodeComment(val comment: String): VmCodeLine()
+
+internal class VmCodeChunk(initial: VmCodeLine? = null) {
+    val lines = mutableListOf<VmCodeLine>()
+
+    init {
+        if(initial!=null)
+            lines.add(initial)
+    }
+
+    operator fun plusAssign(line: VmCodeLine) {
+        lines.add(line)
+    }
+
+    operator fun plusAssign(chunk: VmCodeChunk) {
+        lines.addAll(chunk.lines)
+    }
+}

codeGenVirtual/src/prog8/codegen/virtual/BuiltinFuncGen.kt

@@ -0,0 +1,126 @@
+package prog8.codegen.virtual
+
+import prog8.code.ast.PtBuiltinFunctionCall
+import prog8.code.ast.PtNumber
+import prog8.code.ast.PtString
+import prog8.vm.Opcode
+import prog8.vm.Syscall
+import prog8.vm.VmDataType
+
+internal class BuiltinFuncGen(private val codeGen: CodeGen, private val exprGen: ExpressionGen) {
+
+    fun translate(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        when(call.name) {
+            "syscall" -> {
+                val vExpr = call.args.single() as PtNumber
+                code += VmCodeInstruction(Opcode.SYSCALL, value=vExpr.number.toInt())
+            }
+            "syscall1" -> {
+                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 0)
+                val callNr = (call.args[0] as PtNumber).number.toInt()
+                code += exprGen.translateExpression(call.args[1], 0)
+                code += VmCodeInstruction(Opcode.SYSCALL, value=callNr)
+                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 0)
+            }
+            "syscall2" -> {
+                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 0)
+                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 1)
+                while(codeGen.vmRegisters.peekNext()<2) {
+                    codeGen.vmRegisters.nextFree()
+                }
+                val callNr = (call.args[0] as PtNumber).number.toInt()
+                code += exprGen.translateExpression(call.args[1], 0)
+                code += exprGen.translateExpression(call.args[2], 1)
+                code += VmCodeInstruction(Opcode.SYSCALL, value=callNr)
+                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 1)
+                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 0)
+            }
+            "syscall3" -> {
+                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 0)
+                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 1)
+                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 2)
+                while(codeGen.vmRegisters.peekNext()<3) {
+                    codeGen.vmRegisters.nextFree()
+                }
+                val callNr = (call.args[0] as PtNumber).number.toInt()
+                code += exprGen.translateExpression(call.args[1], 0)
+                code += exprGen.translateExpression(call.args[2], 1)
+                code += exprGen.translateExpression(call.args[3], 2)
+                code += VmCodeInstruction(Opcode.SYSCALL, value=callNr)
+                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 2)
+                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 1)
+                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 0)
+            }
+            "msb" -> {
+                code += exprGen.translateExpression(call.args.single(), resultRegister)
+                code += VmCodeInstruction(Opcode.SWAP, VmDataType.BYTE, reg1 = resultRegister)
+                // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
+            }
+            "lsb" -> {
+                code += exprGen.translateExpression(call.args.single(), resultRegister)
+                // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
+            }
+            "memory" -> {
+                val name = (call.args[0] as PtString).value
+                val size = (call.args[1] as PtNumber).number.toUInt()
+                val align = (call.args[2] as PtNumber).number.toUInt()
+                val existing = codeGen.allocations.getMemorySlab(name)
+                val address = if(existing==null)
+                    codeGen.allocations.allocateMemorySlab(name, size, align)
+                else if(existing.second!=size || existing.third!=align) {
+                    codeGen.errors.err("memory slab '$name' already exists with a different size or alignment", call.position)
+                    return VmCodeChunk()
+                }
+                else
+                    existing.first
+                code += VmCodeInstruction(Opcode.LOAD, VmDataType.WORD, reg1=resultRegister, value=address.toInt())
+            }
+            "rnd" -> {
+                code += VmCodeInstruction(Opcode.SYSCALL, value= Syscall.RND.ordinal)
+                if(resultRegister!=0)
+                    code += VmCodeInstruction(Opcode.LOADR, VmDataType.BYTE, reg1=resultRegister, reg2=0)
+            }
+            "peek" -> {
+                val addressReg = codeGen.vmRegisters.nextFree()
+                code += exprGen.translateExpression(call.args.single(), addressReg)
+                code += VmCodeInstruction(Opcode.LOADI, VmDataType.BYTE, reg1 = resultRegister, reg2=addressReg)
+            }
+            "peekw" -> {
+                val addressReg = codeGen.vmRegisters.nextFree()
+                code += exprGen.translateExpression(call.args.single(), addressReg)
+                code += VmCodeInstruction(Opcode.LOADI, VmDataType.WORD, reg1 = resultRegister, reg2=addressReg)
+            }
+            "mkword" -> {
+                val msbReg = codeGen.vmRegisters.nextFree()
+                val lsbReg = codeGen.vmRegisters.nextFree()
+                code += exprGen.translateExpression(call.args[0], msbReg)
+                code += exprGen.translateExpression(call.args[1], lsbReg)
+                code += VmCodeInstruction(Opcode.CONCAT, VmDataType.BYTE, reg1=resultRegister, reg2=msbReg, reg3=lsbReg)
+            }
+            else -> {
+                TODO("builtinfunc ${call.name}")
+//                code += VmCodeInstruction(Opcode.NOP))
+//                for (arg in call.args) {
+//                    code += translateExpression(arg, resultRegister)
+//                    code += when(arg.type) {
+//                        in ByteDatatypes -> VmCodeInstruction(Opcode.PUSH, VmDataType.BYTE, reg1=resultRegister))
+//                        in WordDatatypes -> VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1=resultRegister))
+//                        else -> throw AssemblyError("weird arg dt")
+//                    }
+//                }
+//                code += VmCodeInstruction(Opcode.CALL), labelArg = listOf("_prog8_builtin", call.name))
+//                for (arg in call.args) {
+//                    code += when(arg.type) {
+//                        in ByteDatatypes -> VmCodeInstruction(Opcode.POP, VmDataType.BYTE, reg1=resultRegister))
+//                        in WordDatatypes -> VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1=resultRegister))
+//                        else -> throw AssemblyError("weird arg dt")
+//                    }
+//                }
+//                code += VmCodeInstruction(Opcode.NOP))
+            }
+        }
+        return code
+    }
+
+}

codeGenVirtual/src/prog8/codegen/virtual/CodeGen.kt

@@ -0,0 +1,593 @@
+package prog8.codegen.virtual
+
+import prog8.code.StStaticVariable
+import prog8.code.SymbolTable
+import prog8.code.ast.*
+import prog8.code.core.*
+import prog8.vm.Opcode
+import prog8.vm.VmDataType
+import kotlin.math.pow
+
+
+internal class VmRegisterPool {
+    private var firstFree: Int=3    // registers 0,1,2 are reserved
+    
+    fun peekNext() = firstFree
+
+    fun nextFree(): Int {
+        val result = firstFree
+        firstFree++
+        if(firstFree>65535)
+            throw AssemblyError("out of virtual registers")
+        return result
+    }
+}
+
+
+class CodeGen(internal val program: PtProgram,
+              internal val symbolTable: SymbolTable,
+              internal val options: CompilationOptions,
+              internal val errors: IErrorReporter
+): IAssemblyGenerator {
+
+    internal val allocations = VariableAllocator(symbolTable, program, errors)
+    private val expressionEval = ExpressionGen(this)
+    private val builtinFuncGen = BuiltinFuncGen(this, expressionEval)
+    internal val vmRegisters = VmRegisterPool()
+
+    init {
+        if(options.dontReinitGlobals)
+            TODO("support no globals re-init in vm")
+    }
+
+    override fun compileToAssembly(): IAssemblyProgram? {
+        val vmprog = AssemblyProgram(program.name, allocations)
+
+        // collect global variables initializers
+        program.allBlocks().forEach {
+            val code = VmCodeChunk()
+            it.children.filterIsInstance<PtAssignment>().forEach { assign -> code += translate(assign) }
+            vmprog.addGlobalInits(code)
+        }
+
+        for (block in program.allBlocks()) {
+            vmprog.addBlock(translate(block))
+        }
+
+        println("Vm codegen: amount of vm registers=${vmRegisters.peekNext()}")
+
+        return vmprog
+    }
+
+
+    private fun translateNode(node: PtNode): VmCodeChunk {
+        val code = when(node) {
+            is PtBlock -> translate(node)
+            is PtSub -> translate(node)
+            is PtScopeVarsDecls -> VmCodeChunk() // vars should be looked up via symbol table
+            is PtVariable -> VmCodeChunk() // var should be looked up via symbol table
+            is PtMemMapped -> VmCodeChunk() // memmapped var should be looked up via symbol table
+            is PtConstant -> VmCodeChunk() // constants have all been folded into the code
+            is PtAssignment -> translate(node)
+            is PtNodeGroup -> translateGroup(node.children)
+            is PtBuiltinFunctionCall -> translateBuiltinFunc(node, 0)
+            is PtFunctionCall -> expressionEval.translate(node, 0)
+            is PtNop -> VmCodeChunk()
+            is PtReturn -> translate(node)
+            is PtJump -> translate(node)
+            is PtWhen -> translate(node)
+            is PtPipe -> expressionEval.translate(node, 0)
+            is PtForLoop -> translate(node)
+            is PtIfElse -> translate(node)
+            is PtPostIncrDecr -> translate(node)
+            is PtRepeatLoop -> translate(node)
+            is PtLabel -> VmCodeChunk(VmCodeLabel(node.scopedName))
+            is PtBreakpoint -> VmCodeChunk(VmCodeInstruction(Opcode.BREAKPOINT))
+            is PtAddressOf,
+            is PtContainmentCheck,
+            is PtMemoryByte,
+            is PtProgram,
+            is PtArrayIndexer,
+            is PtBinaryExpression,
+            is PtIdentifier,
+            is PtWhenChoice,
+            is PtPrefix,
+            is PtRange,
+            is PtAssignTarget,
+            is PtTypeCast,
+            is PtSubroutineParameter,
+            is PtNumber,
+            is PtArray,
+            is PtString -> throw AssemblyError("strings should not occur as separate statement node ${node.position}")
+            is PtAsmSub -> throw AssemblyError("asmsub not supported on virtual machine target ${node.position}")
+            is PtInlineAssembly -> throw AssemblyError("inline assembly not supported on virtual machine target ${node.position}")
+            is PtIncludeBinary -> throw AssemblyError("inline binary data not supported on virtual machine target ${node.position}")
+            is PtConditionalBranch -> throw AssemblyError("conditional branches not supported in vm target due to lack of cpu flags ${node.position}")
+            else -> TODO("missing codegen for $node")
+        }
+        if(code.lines.isNotEmpty() && node.position.line!=0)
+            code.lines.add(0, VmCodeComment(node.position.toString()))
+        return code
+    }
+
+    private fun translate(whenStmt: PtWhen): VmCodeChunk {
+        if(whenStmt.choices.children.isEmpty())
+            return VmCodeChunk()
+        val code = VmCodeChunk()
+        val valueReg = vmRegisters.nextFree()
+        val choiceReg = vmRegisters.nextFree()
+        val valueDt = vmType(whenStmt.value.type)
+        code += expressionEval.translateExpression(whenStmt.value, valueReg)
+        val choices = whenStmt.choices.children.map {it as PtWhenChoice }
+        val endLabel = createLabelName()
+        for (choice in choices) {
+            if(choice.isElse) {
+                code += translateNode(choice.statements)
+            } else {
+                val skipLabel = createLabelName()
+                val values = choice.values.children.map {it as PtNumber}
+                if(values.size==1) {
+                    code += VmCodeInstruction(Opcode.LOAD, valueDt, reg1=choiceReg, value=values[0].number.toInt())
+                    code += VmCodeInstruction(Opcode.BNE, valueDt, reg1=valueReg, reg2=choiceReg, symbol = skipLabel)
+                    code += translateNode(choice.statements)
+                    if(choice.statements.children.last() !is PtReturn)
+                        code += VmCodeInstruction(Opcode.JUMP, symbol = endLabel)
+                } else {
+                    val matchLabel = createLabelName()
+                    for (value in values) {
+                        code += VmCodeInstruction(Opcode.LOAD, valueDt, reg1=choiceReg, value=value.number.toInt())
+                        code += VmCodeInstruction(Opcode.BEQ, valueDt, reg1=valueReg, reg2=choiceReg, symbol = matchLabel)
+                    }
+                    code += VmCodeInstruction(Opcode.JUMP, symbol = skipLabel)
+                    code += VmCodeLabel(matchLabel)
+                    code += translateNode(choice.statements)
+                    if(choice.statements.children.last() !is PtReturn)
+                        code += VmCodeInstruction(Opcode.JUMP, symbol = endLabel)
+                }
+                code += VmCodeLabel(skipLabel)
+            }
+        }
+        code += VmCodeLabel(endLabel)
+        return code
+    }
+
+    private fun translate(forLoop: PtForLoop): VmCodeChunk {
+        val loopvar = symbolTable.lookup(forLoop.variable.targetName) as StStaticVariable
+        val iterable = forLoop.iterable
+        val code = VmCodeChunk()
+        when(iterable) {
+            is PtRange -> {
+                if(iterable.from is PtNumber && iterable.to is PtNumber)
+                    code += translateForInConstantRange(forLoop, loopvar)
+                else
+                    code += translateForInNonConstantRange(forLoop, loopvar)
+            }
+            is PtIdentifier -> {
+                val arrayAddress = allocations.get(iterable.targetName)
+                val iterableVar = symbolTable.lookup(iterable.targetName) as StStaticVariable
+                val loopvarAddress = allocations.get(loopvar.scopedName)
+                val indexReg = vmRegisters.nextFree()
+                val loopLabel = createLabelName()
+                val endLabel = createLabelName()
+                if(iterableVar.dt==DataType.STR) {
+                    // iterate over a zero-terminated string
+                    code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=indexReg, value=0)
+                    code += VmCodeLabel(loopLabel)
+                    code += VmCodeInstruction(Opcode.LOADX, VmDataType.BYTE, reg1=0, reg2=indexReg, value = arrayAddress)
+                    code += VmCodeInstruction(Opcode.BZ, VmDataType.BYTE, reg1=0, symbol = endLabel)
+                    code += VmCodeInstruction(Opcode.STOREM, VmDataType.BYTE, reg1=0, value = loopvarAddress)
+                    code += translateNode(forLoop.statements)
+                    code += VmCodeInstruction(Opcode.INC, VmDataType.BYTE, reg1=indexReg)
+                    code += VmCodeInstruction(Opcode.JUMP, symbol = loopLabel)
+                    code += VmCodeLabel(endLabel)
+                } else {
+                    // iterate over array
+                    val elementDt = ArrayToElementTypes.getValue(iterable.type)
+                    val elementSize = program.memsizer.memorySize(elementDt)
+                    val lengthBytes = iterableVar.length!! * elementSize
+                    val lengthReg = vmRegisters.nextFree()
+                    code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=indexReg, value=0)
+                    code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=lengthReg, value=lengthBytes)
+                    code += VmCodeLabel(loopLabel)
+                    code += VmCodeInstruction(Opcode.BEQ, VmDataType.BYTE, reg1=indexReg, reg2=lengthReg, symbol = endLabel)
+                    code += VmCodeInstruction(Opcode.LOADX, vmType(elementDt), reg1=0, reg2=indexReg, value=arrayAddress)
+                    code += VmCodeInstruction(Opcode.STOREM, vmType(elementDt), reg1=0, value = loopvarAddress)
+                    code += translateNode(forLoop.statements)
+                    code += addConstReg(VmDataType.BYTE, indexReg, elementSize)
+                    code += VmCodeInstruction(Opcode.JUMP, symbol = loopLabel)
+                    code += VmCodeLabel(endLabel)
+                }
+            }
+            else -> throw AssemblyError("weird for iterable")
+        }
+        return code
+    }
+
+    private fun translateForInNonConstantRange(forLoop: PtForLoop, loopvar: StStaticVariable): VmCodeChunk {
+        val iterable = forLoop.iterable as PtRange
+        val step = iterable.step.number.toInt()
+        if (step==0)
+            throw AssemblyError("step 0")
+        val indexReg = vmRegisters.nextFree()
+        val endvalueReg = vmRegisters.nextFree()
+        val loopvarAddress = allocations.get(loopvar.scopedName)
+        val loopvarDt = vmType(loopvar.dt)
+        val loopLabel = createLabelName()
+        val code = VmCodeChunk()
+
+        code += expressionEval.translateExpression(iterable.to, endvalueReg)
+        code += expressionEval.translateExpression(iterable.from, indexReg)
+        code += VmCodeInstruction(Opcode.STOREM, loopvarDt, reg1=indexReg, value=loopvarAddress)
+        code += VmCodeLabel(loopLabel)
+        code += translateNode(forLoop.statements)
+        if(step<3) {
+            code += addConstMem(loopvarDt, loopvarAddress.toUInt(), step)
+            code += VmCodeInstruction(Opcode.LOADM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
+        } else {
+            code += VmCodeInstruction(Opcode.LOADM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
+            code += addConstReg(loopvarDt, indexReg, step)
+            code += VmCodeInstruction(Opcode.STOREM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
+        }
+        val branchOpcode = if(loopvar.dt in SignedDatatypes) Opcode.BLES else Opcode.BLE
+        code += VmCodeInstruction(branchOpcode, loopvarDt, reg1=indexReg, reg2=endvalueReg, symbol=loopLabel)
+        return code
+    }
+
+    private fun translateForInConstantRange(forLoop: PtForLoop, loopvar: StStaticVariable): VmCodeChunk {
+        val iterable = forLoop.iterable as PtRange
+        val step = iterable.step.number.toInt()
+        val range = IntProgression.fromClosedRange(
+            (iterable.from as PtNumber).number.toInt(),
+            (iterable.to as PtNumber).number.toInt() + step,
+            step)
+        if (range.isEmpty() || range.step==0)
+            throw AssemblyError("empty range or step 0")
+
+        val loopLabel = createLabelName()
+        val loopvarAddress = allocations.get(loopvar.scopedName)
+        val indexReg = vmRegisters.nextFree()
+        val endvalueReg = vmRegisters.nextFree()
+        val loopvarDt = vmType(loopvar.dt)
+        val code = VmCodeChunk()
+        code += VmCodeInstruction(Opcode.LOAD, loopvarDt, reg1=endvalueReg, value=range.last)
+        code += VmCodeInstruction(Opcode.LOAD, loopvarDt, reg1=indexReg, value=range.first)
+        code += VmCodeInstruction(Opcode.STOREM, loopvarDt, reg1=indexReg, value=loopvarAddress)
+        code += VmCodeLabel(loopLabel)
+        code += translateNode(forLoop.statements)
+        if(range.step<3) {
+            code += addConstMem(loopvarDt, loopvarAddress.toUInt(), range.step)
+            code += VmCodeInstruction(Opcode.LOADM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
+        } else {
+            code += VmCodeInstruction(Opcode.LOADM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
+            code += addConstReg(loopvarDt, indexReg, range.step)
+            code += VmCodeInstruction(Opcode.STOREM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
+        }
+        // TODO more optimal loop instruction for loops ending on 0 (BNZ?)
+        code += VmCodeInstruction(Opcode.BNE, loopvarDt, reg1=indexReg, reg2=endvalueReg, symbol=loopLabel)
+        return code
+    }
+
+    private fun addConstReg(dt: VmDataType, reg: Int, value: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        when(value) {
+            0 -> { /* do nothing */ }
+            1 -> {
+                code += VmCodeInstruction(Opcode.INC, dt, reg1=reg)
+            }
+            2 -> {
+                code += VmCodeInstruction(Opcode.INC, dt, reg1=reg)
+                code += VmCodeInstruction(Opcode.INC, dt, reg1=reg)
+            }
+            -1 -> {
+                code += VmCodeInstruction(Opcode.DEC, dt, reg1=reg)
+            }
+            -2 -> {
+                code += VmCodeInstruction(Opcode.DEC, dt, reg1=reg)
+                code += VmCodeInstruction(Opcode.DEC, dt, reg1=reg)
+            }
+            else -> {
+                val valueReg = vmRegisters.nextFree()
+                if(value>0) {
+                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=valueReg, value= value)
+                    code += VmCodeInstruction(Opcode.ADD, dt, reg1 = reg, reg2 = reg, reg3 = valueReg)
+                }
+                else {
+                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=valueReg, value= -value)
+                    code += VmCodeInstruction(Opcode.SUB, dt, reg1 = reg, reg2 = reg, reg3 = valueReg)
+                }
+            }
+        }
+        return code
+    }
+
+    private fun addConstMem(dt: VmDataType, address: UInt, value: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        when(value) {
+            0 -> { /* do nothing */ }
+            1 -> {
+                code += VmCodeInstruction(Opcode.INCM, dt, value=address.toInt())
+            }
+            2 -> {
+                code += VmCodeInstruction(Opcode.INCM, dt, value=address.toInt())
+                code += VmCodeInstruction(Opcode.INCM, dt, value=address.toInt())
+            }
+            -1 -> {
+                code += VmCodeInstruction(Opcode.DECM, dt, value=address.toInt())
+            }
+            -2 -> {
+                code += VmCodeInstruction(Opcode.DECM, dt, value=address.toInt())
+                code += VmCodeInstruction(Opcode.DECM, dt, value=address.toInt())
+            }
+            else -> {
+                val valueReg = vmRegisters.nextFree()
+                val operandReg = vmRegisters.nextFree()
+                if(value>0) {
+                    code += VmCodeInstruction(Opcode.LOADM, dt, reg1=valueReg, value=address.toInt())
+                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=operandReg, value=value)
+                    code += VmCodeInstruction(Opcode.ADD, dt, reg1 = valueReg, reg2 = valueReg, reg3 = operandReg)
+                    code += VmCodeInstruction(Opcode.STOREM, dt, reg1=valueReg, value=address.toInt())
+                }
+                else {
+                    code += VmCodeInstruction(Opcode.LOADM, dt, reg1=valueReg, value=address.toInt())
+                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=operandReg, value=-value)
+                    code += VmCodeInstruction(Opcode.SUB, dt, reg1 = valueReg, reg2 = valueReg, reg3 = operandReg)
+                    code += VmCodeInstruction(Opcode.STOREM, dt, reg1=valueReg, value=address.toInt())
+                }
+            }
+        }
+        return code
+    }
+
+    private val powersOfTwo = (0..16).map { 2.0.pow(it.toDouble()).toInt() }
+
+    private fun multiplyByConst(dt: VmDataType, reg: Int, factor: UInt): VmCodeChunk {
+        val code = VmCodeChunk()
+        val pow2 = powersOfTwo.indexOf(factor.toInt())
+        if(pow2>=1) {
+            // just shift bits
+            code += VmCodeInstruction(Opcode.LSL, dt, reg1=reg, reg2=reg, reg3=pow2)
+        } else {
+            when(factor) {
+                0u -> {
+                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=reg, value=0)
+                }
+                1u -> { /* do nothing */ }
+                else -> {
+                    val factorReg = vmRegisters.nextFree()
+                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=factorReg, value=factor.toInt())
+                    code += VmCodeInstruction(Opcode.MUL, dt, reg1=reg, reg2=reg, reg3=factorReg)
+                }
+            }
+        }
+        return code
+    }
+
+    private fun translate(ifElse: PtIfElse): VmCodeChunk {
+        var branch = Opcode.BZ
+        var condition = ifElse.condition
+
+        val cond = ifElse.condition as? PtBinaryExpression
+        if((cond?.right as? PtNumber)?.number==0.0) {
+            if(cond.operator == "==") {
+                // if X==0 ...   so we branch on Not-zero instead.
+                branch = Opcode.BNZ
+                condition = cond.left
+            }
+            else if(cond.operator == "!=") {
+                // if X!=0 ...   so we keep branching on Zero.
+                condition = cond.left
+            }
+        }
+
+        val conditionReg = vmRegisters.nextFree()
+        val vmDt = vmType(condition.type)
+        val code = VmCodeChunk()
+        code += expressionEval.translateExpression(condition, conditionReg)
+        if(ifElse.elseScope.children.isNotEmpty()) {
+            // if and else parts
+            val elseLabel = createLabelName()
+            val afterIfLabel = createLabelName()
+            code += VmCodeInstruction(branch, vmDt, reg1=conditionReg, symbol = elseLabel)
+            code += translateNode(ifElse.ifScope)
+            code += VmCodeInstruction(Opcode.JUMP, symbol = afterIfLabel)
+            code += VmCodeLabel(elseLabel)
+            code += translateNode(ifElse.elseScope)
+            code += VmCodeLabel(afterIfLabel)
+        } else {
+            // only if part
+            val afterIfLabel = createLabelName()
+            code += VmCodeInstruction(branch, vmDt, reg1=conditionReg, symbol = afterIfLabel)
+            code += translateNode(ifElse.ifScope)
+            code += VmCodeLabel(afterIfLabel)
+        }
+        return code
+    }
+
+    private fun translate(postIncrDecr: PtPostIncrDecr): VmCodeChunk {
+        val code = VmCodeChunk()
+        val operation = when(postIncrDecr.operator) {
+            "++" -> Opcode.INC
+            "--" -> Opcode.DEC
+            else -> throw AssemblyError("weird operator")
+        }
+        val ident = postIncrDecr.target.identifier
+        val memory = postIncrDecr.target.memory
+        val array = postIncrDecr.target.array
+        val vmDt = vmType(postIncrDecr.target.type)
+        val resultReg = vmRegisters.nextFree()
+        if(ident!=null) {
+            val address = allocations.get(ident.targetName)
+            code += VmCodeInstruction(Opcode.LOADM, vmDt, reg1=resultReg, value = address)
+            code += VmCodeInstruction(operation, vmDt, reg1=resultReg)
+            code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=resultReg, value = address)
+        } else if(memory!=null) {
+            val addressReg = vmRegisters.nextFree()
+            code += expressionEval.translateExpression(memory.address, addressReg)
+            code += VmCodeInstruction(Opcode.LOADI, vmDt, reg1=resultReg, reg2=addressReg)
+            code += VmCodeInstruction(operation, vmDt, reg1=resultReg)
+            code += VmCodeInstruction(Opcode.STOREI, vmDt, reg1=resultReg, reg2=addressReg)
+        } else if (array!=null) {
+            val variable = array.variable.targetName
+            var variableAddr = allocations.get(variable)
+            val itemsize = program.memsizer.memorySize(array.type)
+            val fixedIndex = (array.index as? PtNumber)?.number?.toInt()
+            val memOp = when(postIncrDecr.operator) {
+                "++" -> Opcode.INCM
+                "--" -> Opcode.DECM
+                else -> throw AssemblyError("weird operator")
+            }
+            if(fixedIndex!=null) {
+                variableAddr += fixedIndex*itemsize
+                code += VmCodeInstruction(memOp, vmDt, value=variableAddr)
+            } else {
+                val indexReg = vmRegisters.nextFree()
+                code += expressionEval.translateExpression(array.index, indexReg)
+                code += VmCodeInstruction(Opcode.LOADX, vmDt, reg1=resultReg, reg2=indexReg, value=variableAddr)
+                code += VmCodeInstruction(operation, vmDt, reg1=resultReg)
+                code += VmCodeInstruction(Opcode.STOREX, vmDt, reg1=resultReg, reg2=indexReg, value=variableAddr)
+            }
+        } else
+            throw AssemblyError("weird assigntarget")
+
+        return code
+    }
+
+    private fun translate(repeat: PtRepeatLoop): VmCodeChunk {
+        if((repeat.count as? PtNumber)?.number==0.0)
+            return VmCodeChunk()
+        if((repeat.count as? PtNumber)?.number==1.0)
+            return translateGroup(repeat.children)
+        if((repeat.count as? PtNumber)?.number==256.0) {
+            // 256 iterations can still be done with just a byte counter if you set it to zero as starting value.
+            repeat.children[0] = PtNumber(DataType.UBYTE, 0.0, repeat.count.position)
+        }
+
+        val code = VmCodeChunk()
+        val counterReg = vmRegisters.nextFree()
+        val vmDt = vmType(repeat.count.type)
+        code += expressionEval.translateExpression(repeat.count, counterReg)
+        val repeatLabel = createLabelName()
+        code += VmCodeLabel(repeatLabel)
+        code += translateNode(repeat.statements)
+        code += VmCodeInstruction(Opcode.DEC, vmDt, reg1=counterReg)
+        code += VmCodeInstruction(Opcode.BNZ, vmDt, reg1=counterReg, symbol = repeatLabel)
+        return code
+    }
+
+    private fun translate(jump: PtJump): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(jump.address!=null)
+            throw AssemblyError("cannot jump to memory location in the vm target")
+        code += if(jump.generatedLabel!=null)
+            VmCodeInstruction(Opcode.JUMP, symbol = listOf(jump.generatedLabel!!))
+        else if(jump.identifier!=null)
+            VmCodeInstruction(Opcode.JUMP, symbol = jump.identifier!!.targetName)
+        else
+            throw AssemblyError("weird jump")
+        return code
+    }
+
+    private fun translateGroup(group: List<PtNode>): VmCodeChunk {
+        val code = VmCodeChunk()
+        group.forEach { code += translateNode(it) }
+        return code
+    }
+
+    private fun translate(assignment: PtAssignment): VmCodeChunk {
+        // TODO can in-place assignments (assignment.augmentable = true) be optimized more?
+
+        val code = VmCodeChunk()
+        val resultRegister = vmRegisters.nextFree()
+        code += expressionEval.translateExpression(assignment.value, resultRegister)
+        val ident = assignment.target.identifier
+        val memory = assignment.target.memory
+        val array = assignment.target.array
+        val vmDt = vmType(assignment.value.type)
+        if(ident!=null) {
+            val address = allocations.get(ident.targetName)
+            code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=resultRegister, value=address)
+        }
+        else if(array!=null) {
+            val variable = array.variable.targetName
+            var variableAddr = allocations.get(variable)
+            val itemsize = program.memsizer.memorySize(array.type)
+            val fixedIndex = (array.index as? PtNumber)?.number?.toInt()
+            val vmDtArrayIdx = vmType(array.type)
+            if(fixedIndex!=null) {
+                variableAddr += fixedIndex*itemsize
+                code += VmCodeInstruction(Opcode.STOREM, vmDtArrayIdx, reg1 = resultRegister, value=variableAddr)
+            } else {
+                val indexReg = vmRegisters.nextFree()
+                code += expressionEval.translateExpression(array.index, indexReg)
+                code += VmCodeInstruction(Opcode.STOREX, vmDtArrayIdx, reg1 = resultRegister, reg2=indexReg, value=variableAddr)
+            }
+        }
+        else if(memory!=null) {
+            if(memory.address is PtNumber) {
+                code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=resultRegister, value=(memory.address as PtNumber).number.toInt())
+            } else {
+                val addressRegister = vmRegisters.nextFree()
+                code += expressionEval.translateExpression(assignment.value, addressRegister)
+                code += VmCodeInstruction(Opcode.STOREI, vmDt, reg1=resultRegister, reg2=addressRegister)
+            }
+        }
+        else
+            throw AssemblyError("weird assigntarget")
+        return code
+    }
+
+    private fun translate(ret: PtReturn): VmCodeChunk {
+        val code = VmCodeChunk()
+        val value = ret.value
+        if(value!=null) {
+            // Call Convention: return value is always returned in r0
+            code += expressionEval.translateExpression(value, 0)
+        }
+        code += VmCodeInstruction(Opcode.RETURN)
+        return code
+    }
+
+    private fun translate(sub: PtSub): VmCodeChunk {
+        // TODO actually inline subroutines marked as inline
+        val code = VmCodeChunk()
+        code += VmCodeComment("SUB: ${sub.scopedName} -> ${sub.returntype}")
+        code += VmCodeLabel(sub.scopedName)
+        for (child in sub.children) {
+            code += translateNode(child)
+        }
+        code += VmCodeComment("SUB-END '${sub.name}'")
+        return code
+    }
+
+    private fun translate(block: PtBlock): VmCodeChunk {
+        val code = VmCodeChunk()
+        code += VmCodeComment("BLOCK '${block.name}'  addr=${block.address}  lib=${block.library}")
+        for (child in block.children) {
+            if(child !is PtAssignment) // global variable initialization is done elsewhere
+                code += translateNode(child)
+        }
+        code += VmCodeComment("BLOCK-END '${block.name}'")
+        return code
+    }
+
+
+    internal fun vmType(type: DataType): VmDataType {
+        return when(type) {
+            DataType.UBYTE,
+            DataType.BYTE -> VmDataType.BYTE
+            DataType.UWORD,
+            DataType.WORD -> VmDataType.WORD
+            in PassByReferenceDatatypes -> VmDataType.WORD
+            else -> throw AssemblyError("no vm datatype for $type")
+        }
+    }
+
+    private var labelSequenceNumber = 0
+    internal fun createLabelName(): List<String> {
+        labelSequenceNumber++
+        return listOf("prog8_label_gen_$labelSequenceNumber")
+    }
+
+    internal fun translateBuiltinFunc(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk =
+        builtinFuncGen.translate(call, resultRegister)
+}

codeGenVirtual/src/prog8/codegen/virtual/ExpressionGen.kt

@@ -0,0 +1,306 @@
+package prog8.codegen.virtual
+
+import prog8.code.StStaticVariable
+import prog8.code.StSub
+import prog8.code.ast.*
+import prog8.code.core.AssemblyError
+import prog8.code.core.DataType
+import prog8.code.core.PassByValueDatatypes
+import prog8.code.core.SignedDatatypes
+import prog8.vm.Opcode
+import prog8.vm.VmDataType
+
+
+internal class ExpressionGen(private val codeGen: CodeGen) {
+    fun translateExpression(expr: PtExpression, resultRegister: Int): VmCodeChunk {
+        require(codeGen.vmRegisters.peekNext() > resultRegister)
+
+        val code = VmCodeChunk()
+        val vmDt = codeGen.vmType(expr.type)
+
+        when (expr) {
+            is PtNumber -> {
+                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=expr.number.toInt())
+            }
+            is PtIdentifier -> {
+                val mem = codeGen.allocations.get(expr.targetName)
+                code += if(expr.type in PassByValueDatatypes) {
+                    VmCodeInstruction(Opcode.LOADM, vmDt, reg1=resultRegister, value=mem)
+                } else {
+                    // for strings and arrays etc., load the *address* of the value instead
+                    VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=mem)
+                }
+            }
+            is PtAddressOf -> {
+                val mem = codeGen.allocations.get(expr.identifier.targetName)
+                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=mem)
+            }
+            is PtMemoryByte -> {
+                val addressRegister = codeGen.vmRegisters.nextFree()
+                val addressExprCode = translateExpression(expr.address, addressRegister)
+                code += addressExprCode
+            }
+            is PtTypeCast -> code += translate(expr, resultRegister)
+            is PtPrefix -> code += translate(expr, resultRegister)
+            is PtArrayIndexer -> code += translate(expr, resultRegister)
+            is PtBinaryExpression -> code += translate(expr, resultRegister)
+            is PtBuiltinFunctionCall -> code += codeGen.translateBuiltinFunc(expr, resultRegister)
+            is PtFunctionCall -> code += translate(expr, resultRegister)
+            is PtContainmentCheck -> code += translate(expr, resultRegister)
+            is PtPipe -> code += translate(expr, resultRegister)
+            is PtRange,
+            is PtArray,
+            is PtString -> throw AssemblyError("range/arrayliteral/string should no longer occur as expression")
+            else -> throw AssemblyError("weird expression")
+        }
+        return code
+    }
+
+    internal fun translate(pipe: PtPipe, resultRegister: Int): VmCodeChunk {
+        TODO("Not yet implemented: pipe expression")
+    }
+
+    private fun translate(check: PtContainmentCheck, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        code += translateExpression(check.element, resultRegister)   // load the element to check in resultRegister
+        val iterable = codeGen.symbolTable.flat.getValue(check.iterable.targetName) as StStaticVariable
+        when(iterable.dt) {
+            DataType.STR -> {
+                val call = PtFunctionCall(listOf("prog8_lib", "string_contains"), false, DataType.UBYTE, check.position)
+                call.children.add(check.element)
+                call.children.add(check.iterable)
+                code += translate(call, resultRegister)
+            }
+            DataType.ARRAY_UB, DataType.ARRAY_B -> {
+                val call = PtFunctionCall(listOf("prog8_lib", "bytearray_contains"), false, DataType.UBYTE, check.position)
+                call.children.add(check.element)
+                call.children.add(check.iterable)
+                call.children.add(PtNumber(DataType.UBYTE, iterable.length!!.toDouble(), iterable.position))
+                code += translate(call, resultRegister)
+            }
+            DataType.ARRAY_UW, DataType.ARRAY_W -> {
+                val call = PtFunctionCall(listOf("prog8_lib", "wordarray_contains"), false, DataType.UBYTE, check.position)
+                call.children.add(check.element)
+                call.children.add(check.iterable)
+                call.children.add(PtNumber(DataType.UBYTE, iterable.length!!.toDouble(), iterable.position))
+                code += translate(call, resultRegister)
+            }
+            DataType.ARRAY_F -> TODO("containment check in float-array")
+            else -> throw AssemblyError("weird iterable dt ${iterable.dt} for ${check.iterable.targetName}")
+        }
+        return code
+    }
+
+    private fun translate(arrayIx: PtArrayIndexer, resultRegister: Int): VmCodeChunk {
+        val eltSize = codeGen.program.memsizer.memorySize(arrayIx.type)
+        val vmDt = codeGen.vmType(arrayIx.type)
+        val code = VmCodeChunk()
+        val idxReg = codeGen.vmRegisters.nextFree()
+        // TODO: optimized code when the index is a constant value
+        code += translateExpression(arrayIx.index, idxReg)
+        if(eltSize>1) {
+            val factorReg = codeGen.vmRegisters.nextFree()
+            code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=factorReg, value=eltSize)
+            code += VmCodeInstruction(Opcode.MUL, VmDataType.BYTE, reg1=idxReg, reg2=idxReg, reg3=factorReg)
+        }
+        val arrayLocation = codeGen.allocations.get(arrayIx.variable.targetName)
+        code += VmCodeInstruction(Opcode.LOADX, vmDt, reg1=resultRegister, reg2=idxReg, value = arrayLocation)
+        return code
+    }
+
+    private fun translate(expr: PtPrefix, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        code += translateExpression(expr.value, resultRegister)
+        val vmDt = codeGen.vmType(expr.type)
+        when(expr.operator) {
+            "+" -> { }
+            "-" -> {
+                code += VmCodeInstruction(Opcode.NEG, vmDt, reg1=resultRegister)
+            }
+            "~" -> {
+                val regMask = codeGen.vmRegisters.nextFree()
+                val mask = if(vmDt==VmDataType.BYTE) 0x00ff else 0xffff
+                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=regMask, value=mask)
+                code += VmCodeInstruction(Opcode.XOR, vmDt, reg1=resultRegister, reg2=resultRegister, reg3=regMask)
+            }
+            "not" -> {
+                val label = codeGen.createLabelName()
+                code += VmCodeInstruction(Opcode.BZ, vmDt, reg1=resultRegister, symbol = label)
+                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=1)
+                code += VmCodeLabel(label)
+                val regMask = codeGen.vmRegisters.nextFree()
+                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=regMask, value=1)
+                code += VmCodeInstruction(Opcode.XOR, vmDt, reg1=resultRegister, reg2=resultRegister, reg3=regMask)
+            }
+            else -> throw AssemblyError("weird prefix operator")
+        }
+        return code
+    }
+
+    private fun translate(cast: PtTypeCast, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(cast.type==cast.value.type)
+            return code
+        code += translateExpression(cast.value, resultRegister)
+        when(cast.type) {
+            DataType.UBYTE -> {
+                when(cast.value.type) {
+                    DataType.BYTE, DataType.UWORD, DataType.WORD -> { /* just keep the LSB as it is */ }
+                    DataType.FLOAT -> {
+                        TODO("float -> ubyte") // float not yet supported
+                    }
+                    else -> throw AssemblyError("weird cast value type")
+                }
+            }
+            DataType.BYTE -> {
+                when(cast.value.type) {
+                    DataType.UBYTE, DataType.UWORD, DataType.WORD -> { /* just keep the LSB as it is */ }
+                    DataType.FLOAT -> {
+                        TODO("float -> byte") // float not yet supported
+                    }
+                    else -> throw AssemblyError("weird cast value type")
+                }
+            }
+            DataType.UWORD -> {
+                when(cast.value.type) {
+                    DataType.BYTE -> {
+                        // byte -> uword:   sign extend
+                        code += VmCodeInstruction(Opcode.EXTS, type = VmDataType.BYTE, reg1 = resultRegister)
+                    }
+                    DataType.UBYTE -> {
+                        // ubyte -> uword:   sign extend
+                        code += VmCodeInstruction(Opcode.EXT, type = VmDataType.BYTE, reg1 = resultRegister)
+                    }
+                    DataType.WORD -> { }
+                    DataType.FLOAT -> {
+                        TODO("float -> uword") // float not yet supported
+                    }
+                    else -> throw AssemblyError("weird cast value type")
+                }
+            }
+            DataType.WORD -> {
+                when(cast.value.type) {
+                    DataType.BYTE -> {
+                        // byte -> word:   sign extend
+                        code += VmCodeInstruction(Opcode.EXTS, type = VmDataType.BYTE, reg1 = resultRegister)
+                    }
+                    DataType.UBYTE -> {
+                        // byte -> word:   sign extend
+                        code += VmCodeInstruction(Opcode.EXT, type = VmDataType.BYTE, reg1 = resultRegister)
+                    }
+                    DataType.UWORD -> { }
+                    DataType.FLOAT -> {
+                        TODO("float -> word") // float not yet supported
+                    }
+                    else -> throw AssemblyError("weird cast value type")
+                }
+            }
+            DataType.FLOAT -> {
+                TODO("floating point not yet supported")
+//                when(cast.value.type) {
+//                    DataType.BYTE -> {
+//                    }
+//                    DataType.UBYTE -> {
+//                    }
+//                    DataType.WORD -> {
+//                    }
+//                    DataType.UWORD -> {
+//                    }
+//                    else -> throw AssemblyError("weird cast value type")
+//                }
+            }
+            else -> throw AssemblyError("weird cast type")
+        }
+        return code
+    }
+
+    private fun translate(binExpr: PtBinaryExpression, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        val leftResultReg = codeGen.vmRegisters.nextFree()
+        val rightResultReg = codeGen.vmRegisters.nextFree()
+        // TODO: optimized codegen when left or right operand is known 0 or 1 or whatever. But only if this would result in a different opcode such as ADD 1 -> INC, MUL 1 -> NOP
+        //       actually optimizing the code should not be done here but in a tailored code optimizer step.
+        val leftCode = translateExpression(binExpr.left, leftResultReg)
+        val rightCode = translateExpression(binExpr.right, rightResultReg)
+        code += leftCode
+        code += rightCode
+        val vmDt = codeGen.vmType(binExpr.left.type)
+        val signed = binExpr.left.type in SignedDatatypes
+        when(binExpr.operator) {
+            "+" -> {
+                code += VmCodeInstruction(Opcode.ADD, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "-" -> {
+                code += VmCodeInstruction(Opcode.SUB, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "*" -> {
+                code += VmCodeInstruction(Opcode.MUL, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "/" -> {
+                code += VmCodeInstruction(Opcode.DIV, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "%" -> {
+                code += VmCodeInstruction(Opcode.MOD, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "|", "or" -> {
+                code += VmCodeInstruction(Opcode.OR, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "&", "and" -> {
+                code += VmCodeInstruction(Opcode.AND, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "^", "xor" -> {
+                code += VmCodeInstruction(Opcode.XOR, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "<<" -> {
+                code += VmCodeInstruction(Opcode.LSL, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            ">>" -> {
+                val opc = if(signed) Opcode.ASR else Opcode.LSR
+                code += VmCodeInstruction(opc, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "==" -> {
+                code += VmCodeInstruction(Opcode.SEQ, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "!=" -> {
+                code += VmCodeInstruction(Opcode.SNE, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "<" -> {
+                val ins = if(signed) Opcode.SLTS else Opcode.SLT
+                code += VmCodeInstruction(ins, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            ">" -> {
+                val ins = if(signed) Opcode.SGTS else Opcode.SGT
+                code += VmCodeInstruction(ins, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            "<=" -> {
+                val ins = if(signed) Opcode.SLES else Opcode.SLE
+                code += VmCodeInstruction(ins, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            ">=" -> {
+                val ins = if(signed) Opcode.SGES else Opcode.SGE
+                code += VmCodeInstruction(ins, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
+            }
+            else -> throw AssemblyError("weird operator ${binExpr.operator}")
+        }
+        return code
+    }
+
+    fun translate(fcall: PtFunctionCall, resultRegister: Int): VmCodeChunk {
+        val subroutine = codeGen.symbolTable.flat.getValue(fcall.functionName) as StSub
+        val code = VmCodeChunk()
+        for ((arg, parameter) in fcall.args.zip(subroutine.parameters)) {
+            val argReg = codeGen.vmRegisters.nextFree()
+            code += translateExpression(arg, argReg)
+            val vmDt = codeGen.vmType(parameter.type)
+            val mem = codeGen.allocations.get(fcall.functionName + parameter.name)
+            code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=argReg, value=mem)
+        }
+        code += VmCodeInstruction(Opcode.CALL, symbol=fcall.functionName)
+        if(!fcall.void && resultRegister!=0) {
+            // Call convention: result value is in r0, so put it in the required register instead.
+            code += VmCodeInstruction(Opcode.LOADR, codeGen.vmType(fcall.type), reg1=resultRegister, reg2=0)
+        }
+        return code
+    }
+
+}

codeGenVirtual/src/prog8/codegen/virtual/VariableAllocator.kt

@@ -0,0 +1,91 @@
+package prog8.codegen.virtual
+
+import prog8.code.SymbolTable
+import prog8.code.ast.PtProgram
+import prog8.code.core.*
+
+class VariableAllocator(private val st: SymbolTable, private val program: PtProgram, errors: IErrorReporter) {
+
+    private val allocations = mutableMapOf<List<String>, Int>()
+    private var freeMemoryStart: Int
+
+    val freeMem: Int
+        get() = freeMemoryStart
+
+    init {
+        var nextLocation = 0
+        for (variable in st.allVariables) {
+            val memsize =
+                when (variable.dt) {
+                    DataType.STR -> variable.initialStringValue!!.first.length + 1  // include the zero byte
+                    in NumericDatatypes -> program.memsizer.memorySize(variable.dt)
+                    in ArrayDatatypes -> program.memsizer.memorySize(variable.dt, variable.length!!)
+                    else -> throw InternalCompilerException("weird dt")
+                }
+
+            allocations[variable.scopedName] = nextLocation
+            nextLocation += memsize
+        }
+
+        freeMemoryStart = nextLocation
+    }
+
+    fun get(name: List<String>) = allocations.getValue(name)
+
+    fun asVmMemory(): List<Pair<List<String>, String>> {
+        val mm = mutableListOf<Pair<List<String>, String>>()
+        for (variable in st.allVariables) {
+            val location = allocations.getValue(variable.scopedName)
+            val typeStr = when(variable.dt) {
+                DataType.UBYTE, DataType.ARRAY_UB, DataType.STR -> "ubyte"
+                DataType.BYTE, DataType.ARRAY_B -> "byte"
+                DataType.UWORD, DataType.ARRAY_UW -> "uword"
+                DataType.WORD, DataType.ARRAY_W -> "word"
+                DataType.FLOAT, DataType.ARRAY_F -> "float"
+                else -> throw InternalCompilerException("weird dt")
+            }
+            val value = when(variable.dt) {
+                DataType.FLOAT -> (variable.initialNumericValue ?: 0.0).toString()
+                in NumericDatatypes -> (variable.initialNumericValue ?: 0).toHex()
+                DataType.STR -> {
+                    val encoded = program.encoding.encodeString(variable.initialStringValue!!.first, variable.initialStringValue!!.second)
+                    encoded.joinToString(",") { it.toInt().toHex() } + ",0"
+                }
+                DataType.ARRAY_F -> {
+                    if(variable.initialArrayValue!=null) {
+                        variable.initialArrayValue!!.joinToString(",") { it.number!!.toString() }
+                    } else {
+                        (1..variable.length!!).joinToString(",") { "0" }
+                    }
+                }
+                in ArrayDatatypes -> {
+                    if(variable.initialArrayValue!==null) {
+                        variable.initialArrayValue!!.joinToString(",") { it.number!!.toHex() }
+                    } else {
+                        (1..variable.length!!).joinToString(",") { "0" }
+                    }
+                }
+                else -> throw InternalCompilerException("weird dt")
+            }
+            mm.add(Pair(variable.scopedName, "${location.toHex()} $typeStr $value"))
+        }
+        return mm
+    }
+
+    private val memorySlabsInternal = mutableMapOf<String, Triple<UInt, UInt, UInt>>()
+    internal val memorySlabs: Map<String, Triple<UInt, UInt, UInt>> = memorySlabsInternal
+
+    fun allocateMemorySlab(name: String, size: UInt, align: UInt): UInt {
+        val address =
+            if(align==0u || align==1u)
+                freeMemoryStart.toUInt()
+            else
+                (freeMemoryStart.toUInt() + align-1u) and (0xffffffffu xor (align-1u))
+
+        memorySlabsInternal[name] = Triple(address, size, align)
+        freeMemoryStart = (address + size).toInt()
+        return address
+    }
+
+    fun getMemorySlab(name: String): Triple<UInt, UInt, UInt>? = memorySlabsInternal[name]
+}

codeOptimizers/build.gradle

@@ -24,7 +24,7 @@ compileTestKotlin {
 }
 
 dependencies {
-    implementation project(':compilerInterfaces')
+    implementation project(':codeCore')
     implementation project(':compilerAst')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"

codeOptimizers/codeOptimizers.iml

@@ -9,7 +9,7 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="module" module-name="compilerInterfaces" />
+    <orderEntry type="module" module-name="codeCore" />
     <orderEntry type="module" module-name="compilerAst" />
   </component>
 </module>

codeOptimizers/src/prog8/optimizer/BinExprSplitter.kt

@@ -3,7 +3,6 @@ package prog8.optimizer
 import prog8.ast.IStatementContainer
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.DataType
 import prog8.ast.expressions.AugmentAssignmentOperators
 import prog8.ast.expressions.BinaryExpression
 import prog8.ast.expressions.IdentifierReference
@@ -14,12 +13,12 @@ import prog8.ast.statements.Assignment
 import prog8.ast.statements.AssignmentOrigin
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.ICompilationTarget
-import prog8.compilerinterface.isIOAddress
+import prog8.code.core.CompilationOptions
+import prog8.code.core.DataType
+import prog8.code.target.VMTarget
 
 
-class BinExprSplitter(private val program: Program, private val options: CompilationOptions, private val compTarget: ICompilationTarget) : AstWalker() {
+class BinExprSplitter(private val program: Program, private val options: CompilationOptions) : AstWalker() {
 
     override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {
 
@@ -93,7 +92,7 @@ X =      BinExpr                                    X   =   LeftExpr
         val typecast = assignment.value as? TypecastExpression
         if(typecast!=null) {
             val origExpr = typecast.expression as? BinaryExpression
-            if(origExpr!=null) {
+            if(origExpr!=null && options.compTarget.name!=VMTarget.NAME) {
                 // it's a typecast of a binary expression.
                 // we can see if we can unwrap the binary expression by working on a new temporary variable
                 // (that has the type of the expression), and then finally doing the typecast.
@@ -115,7 +114,7 @@ X =      BinExpr                                    X   =   LeftExpr
 
     private fun isSimpleTarget(target: AssignTarget) =
             if (target.identifier!=null || target.memoryAddress!=null)
-                !target.isIOAddress(compTarget.machine)
+                !target.isIOAddress(options.compTarget.machine)
             else
                 false
 

codeOptimizers/src/prog8/optimizer/ConstExprEvaluator.kt

@@ -1,9 +1,12 @@
 package prog8.optimizer
 
-import prog8.ast.base.*
+import prog8.ast.base.ExpressionError
+import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.Expression
 import prog8.ast.expressions.NumericLiteral
-import kotlin.math.pow
+import prog8.code.core.DataType
+import prog8.code.core.IntegerDatatypes
+import prog8.code.core.Position
 
 
 class ConstExprEvaluator {
@@ -16,7 +19,6 @@ class ConstExprEvaluator {
                 "*" -> multiply(left, right)
                 "/" -> divide(left, right)
                 "%" -> remainder(left, right)
-                "**" -> power(left, right)
                 "&" -> bitwiseand(left, right)
                 "|" -> bitwiseor(left, right)
                 "^" -> bitwisexor(left, right)
@@ -146,23 +148,6 @@ class ConstExprEvaluator {
         throw ExpressionError("cannot calculate $left & $right", left.position)
     }
 
-    private fun power(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
-        val error = "cannot calculate $left ** $right"
-        return when (left.type) {
-            in IntegerDatatypes -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteral.optimalNumeric(left.number.toInt().toDouble().pow(right.number.toInt()), left.position)
-                DataType.FLOAT -> NumericLiteral(DataType.FLOAT, left.number.toInt().toDouble().pow(right.number), left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            DataType.FLOAT -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteral(DataType.FLOAT, left.number.pow(right.number.toInt()), left.position)
-                DataType.FLOAT -> NumericLiteral(DataType.FLOAT, left.number.pow(right.number), left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
     private fun plus(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
         val error = "cannot add $left and $right"
         return when (left.type) {

codeOptimizers/src/prog8/optimizer/ConstantFoldingOptimizer.kt

@@ -2,14 +2,17 @@ package prog8.optimizer
 
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.*
+import prog8.ast.base.ExpressionError
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.UndefinedSymbolError
 import prog8.ast.expressions.*
-import prog8.ast.statements.Assignment
 import prog8.ast.statements.ForLoop
 import prog8.ast.statements.VarDecl
+import prog8.ast.statements.VarDeclType
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import kotlin.math.pow
+import prog8.code.core.DataType
+import prog8.code.core.IntegerDatatypes
 
 
 class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
@@ -135,42 +138,6 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
             }
         }
 
-        if(expr.operator == "**" && leftconst!=null) {
-            // optimize various simple cases of ** :
-            //  optimize away 1 ** x into just 1 and 0 ** x into just 0
-            //  optimize 2 ** x into (1<<x)  if both operands are integer.
-            val leftDt = leftconst.inferType(program).getOr(DataType.UNDEFINED)
-            when (leftconst.number) {
-                0.0 -> {
-                    val value = NumericLiteral(leftDt, 0.0, expr.position)
-                    modifications += IAstModification.ReplaceNode(expr, value, parent)
-                }
-                1.0 -> {
-                    val value = NumericLiteral(leftDt, 1.0, expr.position)
-                    modifications += IAstModification.ReplaceNode(expr, value, parent)
-                }
-                2.0 -> {
-                    if(rightconst!=null) {
-                        val value = NumericLiteral(leftDt, 2.0.pow(rightconst.number), expr.position)
-                        modifications += IAstModification.ReplaceNode(expr, value, parent)
-                    } else {
-                        val rightDt = expr.right.inferType(program).getOr(DataType.UNDEFINED)
-                        if(leftDt in IntegerDatatypes && rightDt in IntegerDatatypes) {
-                            val targetDt =
-                                when (parent) {
-                                    is Assignment -> parent.target.inferType(program).getOr(DataType.UNDEFINED)
-                                    is VarDecl -> parent.datatype
-                                    else -> leftDt
-                                }
-                            val one = NumericLiteral(targetDt, 1.0, expr.position)
-                            val shift = BinaryExpression(one, "<<", expr.right, expr.position)
-                            modifications += IAstModification.ReplaceNode(expr, shift, parent)
-                        }
-                    }
-                }
-            }
-        }
-
         if(expr.inferType(program) istype DataType.FLOAT) {
             val subExpr: BinaryExpression? = when {
                 leftconst != null -> expr.right as? BinaryExpression

codeOptimizers/src/prog8/optimizer/ConstantIdentifierReplacer.kt

@@ -2,14 +2,13 @@ package prog8.optimizer
 
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.base.*
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.UndefinedSymbolError
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.ICompilationTarget
-import prog8.compilerinterface.IErrorReporter
-import prog8.compilerinterface.InternalCompilerException
+import prog8.code.core.*
 
 // Fix up the literal value's type to match that of the vardecl
 //   (also check range literal operands types before they get expanded into arrays for instance)
@@ -22,10 +21,10 @@ class VarConstantValueTypeAdjuster(private val program: Program, private val err
 
         try {
             val declConstValue = decl.value?.constValue(program)
-            if(declConstValue!=null && (decl.type==VarDeclType.VAR || decl.type==VarDeclType.CONST)
+            if(declConstValue!=null && (decl.type== VarDeclType.VAR || decl.type==VarDeclType.CONST)
                 && declConstValue.type != decl.datatype) {
                 // avoid silent float roundings
-                if(decl.datatype in IntegerDatatypes && declConstValue.type==DataType.FLOAT) {
+                if(decl.datatype in IntegerDatatypes && declConstValue.type == DataType.FLOAT) {
                     errors.err("refused rounding of float to avoid loss of precision", decl.value!!.position)
                 } else {
                     // cast the numeric literal to the appropriate datatype of the variable

codeOptimizers/src/prog8/optimizer/ExpressionSimplifier.kt

@@ -1,15 +1,15 @@
 package prog8.optimizer
 
 import prog8.ast.*
-import prog8.ast.base.DataType
 import prog8.ast.base.FatalAstException
-import prog8.ast.base.IntegerDatatypes
-import prog8.ast.base.NumericDatatypes
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.IErrorReporter
+import prog8.code.core.DataType
+import prog8.code.core.IErrorReporter
+import prog8.code.core.IntegerDatatypes
+import prog8.code.core.NumericDatatypes
 import kotlin.math.abs
 import kotlin.math.log2
 import kotlin.math.pow
@@ -256,7 +256,6 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
             "/" -> optimizeDivision(expr, leftVal, rightVal)
             "+" -> optimizeAdd(expr, leftVal, rightVal)
             "-" -> optimizeSub(expr, leftVal, rightVal)
-            "**" -> optimizePower(expr, leftVal, rightVal)
             "%" -> optimizeRemainder(expr, leftVal, rightVal)
             ">>" -> optimizeShiftRight(expr, rightVal)
             "<<" -> optimizeShiftLeft(expr, rightVal)
@@ -435,75 +434,6 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
         return null
     }
 
-    private fun optimizePower(expr: BinaryExpression, leftVal: NumericLiteral?, rightVal: NumericLiteral?): Expression? {
-        if (leftVal == null && rightVal == null)
-            return null
-
-        if (rightVal != null) {
-            // right value is a constant, see if we can optimize
-            val rightConst: NumericLiteral = rightVal
-            when (rightConst.number) {
-                -3.0 -> {
-                    // -1/(left*left*left)
-                    return BinaryExpression(NumericLiteral(DataType.FLOAT, -1.0, expr.position), "/",
-                            BinaryExpression(expr.left, "*", BinaryExpression(expr.left, "*", expr.left, expr.position), expr.position),
-                            expr.position)
-                }
-                -2.0 -> {
-                    // -1/(left*left)
-                    return BinaryExpression(NumericLiteral(DataType.FLOAT, -1.0, expr.position), "/",
-                            BinaryExpression(expr.left, "*", expr.left, expr.position),
-                            expr.position)
-                }
-                -1.0 -> {
-                    // -1/left
-                    return BinaryExpression(NumericLiteral(DataType.FLOAT, -1.0, expr.position), "/",
-                            expr.left, expr.position)
-                }
-                0.0 -> {
-                    // 1
-                    return NumericLiteral(rightConst.type, 1.0, expr.position)
-                }
-                0.5 -> {
-                    // sqrt(left)
-                    return FunctionCallExpression(IdentifierReference(listOf("sqrt"), expr.position), mutableListOf(expr.left), expr.position)
-                }
-                1.0 -> {
-                    // left
-                    return expr.left
-                }
-                2.0 -> {
-                    // left*left
-                    return BinaryExpression(expr.left, "*", expr.left, expr.position)
-                }
-                3.0 -> {
-                    // left*left*left
-                    return BinaryExpression(expr.left, "*", BinaryExpression(expr.left, "*", expr.left, expr.position), expr.position)
-                }
-            }
-        }
-        if (leftVal != null) {
-            // left value is a constant, see if we can optimize
-            when (leftVal.number) {
-                -1.0 -> {
-                    // -1
-                    return NumericLiteral(DataType.FLOAT, -1.0, expr.position)
-                }
-                0.0 -> {
-                    // 0
-                    return NumericLiteral(leftVal.type, 0.0, expr.position)
-                }
-                1.0 -> {
-                    //1
-                    return NumericLiteral(leftVal.type, 1.0, expr.position)
-                }
-
-            }
-        }
-
-        return null
-    }
-
     private fun optimizeRemainder(expr: BinaryExpression, leftVal: NumericLiteral?, rightVal: NumericLiteral?): Expression? {
         if (leftVal == null && rightVal == null)
             return null

codeOptimizers/src/prog8/optimizer/Extensions.kt

@@ -2,9 +2,9 @@ package prog8.optimizer
 
 import prog8.ast.IBuiltinFunctions
 import prog8.ast.Program
-import prog8.compilerinterface.CompilationOptions
-import prog8.compilerinterface.ICompilationTarget
-import prog8.compilerinterface.IErrorReporter
+import prog8.code.core.CompilationOptions
+import prog8.code.core.ICompilationTarget
+import prog8.code.core.IErrorReporter
 
 
 fun Program.constantFold(errors: IErrorReporter, compTarget: ICompilationTarget) {
@@ -60,8 +60,8 @@ fun Program.simplifyExpressions(errors: IErrorReporter) : Int {
     return opti.applyModifications()
 }
 
-fun Program.splitBinaryExpressions(options: CompilationOptions, compTarget: ICompilationTarget) : Int {
-    val opti = BinExprSplitter(this, options, compTarget)
+fun Program.splitBinaryExpressions(options: CompilationOptions) : Int {
+    val opti = BinExprSplitter(this, options)
     opti.visit(this)
     return opti.applyModifications()
 }

codeOptimizers/src/prog8/optimizer/StatementOptimizer.kt

@@ -1,23 +1,20 @@
 package prog8.optimizer
 
 import prog8.ast.*
-import prog8.ast.base.ArrayDatatypes
-import prog8.ast.base.DataType
-import prog8.ast.base.IntegerDatatypes
-import prog8.ast.base.VarDeclType
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.ICompilationTarget
-import prog8.compilerinterface.IErrorReporter
+import prog8.code.core.*
+import prog8.code.target.VMTarget
+import prog8.code.target.virtual.VirtualMachineDefinition
 import kotlin.math.floor
 
 
 class StatementOptimizer(private val program: Program,
-                                  private val errors: IErrorReporter,
-                                  private val functions: IBuiltinFunctions,
-                                  private val compTarget: ICompilationTarget
+                         private val errors: IErrorReporter,
+                         private val functions: IBuiltinFunctions,
+                         private val compTarget: ICompilationTarget
 ) : AstWalker() {
 
     override fun before(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
@@ -125,22 +122,23 @@ class StatementOptimizer(private val program: Program,
                 return listOf(IAstModification.Remove(functionCallStatement, parent as IStatementContainer))
         }
 
-        // see if we can optimize any complex argument expressions to be just a simple variable
-        // TODO for now, only works for single-argument functions because we use just 1 temp var: R9
-        if(functionCallStatement.target.nameInSource !in listOf(listOf("pop"), listOf("popw")) && functionCallStatement.args.size==1) {
-            val arg = functionCallStatement.args[0]
-            if(!arg.isSimple && arg !is IFunctionCall) {
-                val name = getTempRegisterName(arg.inferType(program))
-                val tempvar = IdentifierReference(name, functionCallStatement.position)
-                val assignTempvar = Assignment(AssignTarget(tempvar.copy(), null, null, functionCallStatement.position), arg, AssignmentOrigin.OPTIMIZER, functionCallStatement.position)
-                return listOf(
-                    IAstModification.InsertBefore(functionCallStatement, assignTempvar, parent as IStatementContainer),
-                    IAstModification.ReplaceNode(arg, tempvar, functionCallStatement)
-                )
+        if(compTarget.name!=VMTarget.NAME) {
+            // see if we can optimize any complex argument expressions to be just a simple variable
+            // TODO for now, only works for single-argument functions because we use just 1 temp var: R9
+            if(functionCallStatement.target.nameInSource !in listOf(listOf("pop"), listOf("popw")) && functionCallStatement.args.size==1) {
+                val arg = functionCallStatement.args[0]
+                if(!arg.isSimple && arg !is IFunctionCall) {
+                    val name = getTempRegisterName(arg.inferType(program))
+                    val tempvar = IdentifierReference(name, functionCallStatement.position)
+                    val assignTempvar = Assignment(AssignTarget(tempvar.copy(), null, null, functionCallStatement.position), arg, AssignmentOrigin.OPTIMIZER, functionCallStatement.position)
+                    return listOf(
+                        IAstModification.InsertBefore(functionCallStatement, assignTempvar, parent as IStatementContainer),
+                        IAstModification.ReplaceNode(arg, tempvar, functionCallStatement)
+                    )
+                }
             }
         }
 
-
         return noModifications
     }
 
@@ -293,13 +291,13 @@ class StatementOptimizer(private val program: Program,
 
     override fun after(gosub: GoSub, parent: Node): Iterable<IAstModification> {
         // if the next statement is return with no returnvalue, change into a regular jump if there are no parameters as well.
-        val subroutineParams = gosub.identifier?.targetSubroutine(program)?.parameters
+        val subroutineParams = gosub.identifier.targetSubroutine(program)?.parameters
         if(subroutineParams!=null && subroutineParams.isEmpty()) {
             val returnstmt = gosub.nextSibling() as? Return
             if(returnstmt!=null && returnstmt.value==null) {
                 return listOf(
                     IAstModification.Remove(returnstmt, parent as IStatementContainer),
-                    IAstModification.ReplaceNode(gosub, Jump(gosub.address, gosub.identifier, gosub.generatedLabel, gosub.position), parent)
+                    IAstModification.ReplaceNode(gosub, Jump(null, gosub.identifier, null, gosub.position), parent)
                 )
             }
         }
@@ -401,7 +399,7 @@ class StatementOptimizer(private val program: Program,
                         if (rightCv == 0.0) {
                             return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
                         } else if (targetDt in IntegerDatatypes && floor(rightCv) == rightCv) {
-                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..4.0) {
+                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..4.0 && compTarget.name!=VMTarget.NAME) {
                                 // replace by several INCs if it's not a memory address (inc on a memory mapped register doesn't work very well)
                                 val incs = AnonymousScope(mutableListOf(), assignment.position)
                                 repeat(rightCv.toInt()) {
@@ -415,7 +413,7 @@ class StatementOptimizer(private val program: Program,
                         if (rightCv == 0.0) {
                             return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
                         } else if (targetDt in IntegerDatatypes && floor(rightCv) == rightCv) {
-                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..4.0) {
+                            if (vardeclDt != VarDeclType.MEMORY && rightCv in 1.0..4.0 && compTarget.name!=VMTarget.NAME) {
                                 // replace by several DECs if it's not a memory address (dec on a memory mapped register doesn't work very well)
                                 val decs = AnonymousScope(mutableListOf(), assignment.position)
                                 repeat(rightCv.toInt()) {
@@ -427,7 +425,6 @@ class StatementOptimizer(private val program: Program,
                     }
                     "*" -> if (rightCv == 1.0) return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
                     "/" -> if (rightCv == 1.0) return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
-                    "**" -> if (rightCv == 1.0) return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
                     "|" -> if (rightCv == 0.0) return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
                     "^" -> if (rightCv == 0.0) return listOf(IAstModification.Remove(assignment, parent as IStatementContainer))
                     "<<" -> {
@@ -469,6 +466,10 @@ class StatementOptimizer(private val program: Program,
     }
 
     override fun after(returnStmt: Return, parent: Node): Iterable<IAstModification> {
+
+        if(compTarget.name==VMTarget.NAME)
+            return noModifications
+
         fun returnViaIntermediaryVar(value: Expression): Iterable<IAstModification>? {
             val subr = returnStmt.definingSubroutine!!
             val returnDt = subr.returntypes.single()

codeOptimizers/src/prog8/optimizer/UnusedCodeRemover.kt

@@ -1,17 +1,15 @@
 package prog8.optimizer
 
 import prog8.ast.*
-import prog8.ast.base.DataType
-import prog8.ast.base.VarDeclType
-import prog8.ast.base.defaultZero
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.compilerinterface.CallGraph
-import prog8.compilerinterface.ICompilationTarget
-import prog8.compilerinterface.IErrorReporter
-import prog8.compilerinterface.isIOAddress
+import prog8.code.core.DataType
+import prog8.code.core.ICompilationTarget
+import prog8.code.core.IErrorReporter
+import prog8.code.core.internedStringsModuleName
+import prog8.compiler.CallGraph
 
 
 class UnusedCodeRemover(private val program: Program,
@@ -68,7 +66,7 @@ class UnusedCodeRemover(private val program: Program,
                 return listOf(IAstModification.Remove(block, parent as IStatementContainer))
             }
             if(callgraph.unused(block)) {
-                if(block.statements.any{ it !is VarDecl || it.type==VarDeclType.VAR})
+                if(block.statements.any{ it !is VarDecl || it.type== VarDeclType.VAR})
                     errors.warn("removing unused block '${block.name}'", block.position)
                 program.removeInternedStringsFromRemovedBlock(block)
                 return listOf(IAstModification.Remove(block, parent as IStatementContainer))

compiler/build.gradle

@@ -2,8 +2,8 @@ plugins {
     id 'java'
     id 'application'
     id "org.jetbrains.kotlin.jvm"
-    id 'com.github.johnrengelman.shadow' version '7.1.0'
-    id "io.kotest" version "0.3.8"
+    id 'com.github.johnrengelman.shadow' version '7.1.2'
+    id "io.kotest" version "0.3.9"
 }
 
 java {
@@ -27,19 +27,20 @@ compileTestKotlin {
 def prog8version = rootProject.file('compiler/res/version.txt').text.trim()
 
 dependencies {
-    implementation project(':compilerInterfaces')
+    implementation project(':codeAst')
+    implementation project(':codeCore')
     implementation project(':codeOptimizers')
     implementation project(':compilerAst')
-    implementation project(':codeGenTargets')
     implementation project(':codeGenCpu6502')
-    implementation project(':codeGenExperimental6502')
-    implementation 'org.antlr:antlr4-runtime:4.9.2'
+    implementation project(':codeGenVirtual')
+    implementation project(':codeGenExperimental')
+    implementation 'org.antlr:antlr4-runtime:4.9.3'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.3'
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.12"
+    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.4'
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
 
-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:4.6.3'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.1.0'
 }
 
 configurations.all {

compiler/compiler.iml

@@ -11,16 +11,17 @@
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="module" module-name="compilerAst" />
     <orderEntry type="library" name="jetbrains.kotlinx.cli.jvm" level="project" />
     <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
-    <orderEntry type="module" module-name="codeOptimizers" />
-    <orderEntry type="module" module-name="compilerInterfaces" />
-    <orderEntry type="module" module-name="codeGenTargets" />
     <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="antlr.antlr4" level="project" />
+    <orderEntry type="module" module-name="codeCore" />
+    <orderEntry type="module" module-name="codeAst" />
+    <orderEntry type="module" module-name="compilerAst" />
+    <orderEntry type="module" module-name="codeOptimizers" />
     <orderEntry type="module" module-name="codeGenCpu6502" />
-    <orderEntry type="module" module-name="codeGenExperimental6502" />
+    <orderEntry type="module" module-name="codeGenExperimental" />
+    <orderEntry type="module" module-name="codeGenVirtual" />
   </component>
 </module>